Skip to content
FrontDepth, Home

AJAX → Flux and Redux

1999 – today · 2014 – today

Older era
Newer era
Compare

What changed

Where the state lives

AJAX

On the server: the list is server data; the page keeps the last copy it received, and the filter.

Flux and Redux

In one Redux store: { todos, filter }, built by two reducers joined with combineReducers. Only the half-typed text stays in the input, read through a ref.

How the page is rendered

AJAX

The server sends data (JSON), not HTML; the page builds the list items with document.createElement.

Flux and Redux

React still renders the components; connect renders TodoApp again when the props it maps from the store change.

What happens on a change

AJAX

Each change is a background request; its callback replaces the page's copy of the list and redraws only the list, the counter and the filter buttons.

Flux and Redux

A handler calls a prop like onToggle(id), which dispatches toggleTodo(id); the reducer returns a new state and the store notifies its subscribers.

How the code is organised

AJAX

A page script with a request helper and handlers attached in window.onload, talking to a server API that answers JSON.

Flux and Redux

Action types and creators, reducers, the store setup and a connected function component, each in its own file.

Why it changed

What hurt in each era along the way, and the era that came next.

  1. AJAX→jQuery

    Every browser did it a little differently. Internet Explorer 5 and 6 created the object with new ActiveXObject("Microsoft.XMLHTTP"), Internet Explorer before version 9 attached events with attachEvent instead of addEventListener, and each browser had its own DOM quirks, so scripts grew long and full of browser checks. Libraries like jQuery wrapped XHR, events and the DOM in one short API that worked the same in every browser.

  2. jQuery→MVC in the browser (Backbone)

    When the data lives only in the DOM, every feature reads and writes the page directly: the counter counts <li> elements, the filter checks classes. As apps grew, handlers changing the page from many places became hard to follow ("jQuery spaghetti"), and there was no model of the data to test, save or reuse. Libraries like Backbone moved the data into models and kept the page in views.

  3. MVC in the browser (Backbone)→Two-way binding (AngularJS)

    Backbone left the wiring to you. Every view subscribed to its models by hand, chose what to redraw and read form fields back itself, so much of the code only connected data to the DOM. A view thrown away without remove() stayed subscribed and kept reacting as a "zombie view", and re-rendering a template replaced elements, losing focus and half-typed text. AngularJS answered with two-way data binding: the HTML declares what shows what, and the framework keeps the page and the data in sync.

  4. Two-way binding (AngularJS)→React and the virtual DOM

    Every binding added a watcher, and every digest checked all of them, at least twice whenever something had changed, so pages with many bindings slowed down on each click or keystroke (1.3 added one-time bindings, ::, to cut the count). Two-way bindings and watchers that change other values made it hard to see what changed what, and code outside AngularJS, like a setTimeout callback or a jQuery plugin, had to remember to call $scope.$apply().

    Angular 2 was a new framework rather than the next version: an app could not just upgrade, and the official path was to migrate it piece by piece, with both frameworks running side by side. React answered with one-way data flow: a component renders from its state, and a virtual DOM works out what to change on the page.

  5. React and the virtual DOM→Flux and Redux

    State that several components need has to live in their closest common parent and travel down as props through every component in between, even those that only pass it on, while callbacks travel down the same way to change it. In a large app, setState calls in many components, triggered by clicks, server responses and timers, all changed what the screen showed, so it was hard to follow why it looked the way it did. Flux and Redux moved the shared state out of the components into a store that changes only through actions.

The same app, side by side

The main file of each version. Both apps pass the same test: same markup, same behaviour, different ideas.

The apps run in sandboxes in your browser.

AJAX
Flux and Redux

AJAX

plain browser APIs, no library

/src/main.js · 97 lines

JavaScript
// AJAX era: the page talks to the server in the background with XMLHttpRequest and
// redraws only the list. The page itself is never loaded again.

// The list belongs to the server; the page keeps the last copy it received.
var todos = [];
var filter = "all";

// Every request goes the same way: open, send, then wait until readyState is 4 (done).
function request(method, url, body, callback) {
  var xhr = new XMLHttpRequest();
  // true = asynchronous: the page stays usable while the request travels.
  xhr.open(method, url, true);
  if (body) xhr.setRequestHeader("Content-Type", "application/x-www-form-urlencoded");
  xhr.onreadystatechange = function () {
    if (xhr.readyState === 4 && xhr.status === 200) {
      callback(JSON.parse(xhr.responseText));
    }
  };
  xhr.send(body);
}

// Every answer is the whole list as JSON: keep it and redraw.
function show(list) {
  todos = list;
  render();
}

// One call per todo gives each handler its own todo. A handler created inside render()'s
// for loop would close over the loop's single var and see its value from the end of the loop.
function makeItem(todo) {
  var li = document.createElement("li");
  var label = document.createElement("label");
  var box = document.createElement("input");
  var title = document.createElement("span");
  box.type = "checkbox";
  box.checked = todo.done;
  box.setAttribute("data-toggle", "");
  box.onclick = function () {
    request("POST", "/todos/" + todo.id + "/toggle", null, show);
  };
  // A text node: what the user typed never becomes HTML.
  title.className = "title";
  title.appendChild(document.createTextNode(todo.title));
  label.appendChild(box);
  label.appendChild(document.createTextNode(" "));
  label.appendChild(title);
  li.appendChild(label);
  if (todo.done) li.className = "done";
  return li;
}

// Only the list, the counter and the filter buttons change; the rest of the page stays.
function render() {
  var list = document.getElementById("todo-list");
  var buttons = document.getElementById("filters").getElementsByTagName("button");
  var left = 0;
  var i;
  list.innerHTML = "";
  for (i = 0; i < todos.length; i++) {
    if (!todos[i].done) left++;
    if (filter === "all" || (filter === "done") === todos[i].done) {
      list.appendChild(makeItem(todos[i]));
    }
  }
  document.getElementById("todo-count").innerHTML = left + " left";
  for (i = 0; i < buttons.length; i++) {
    buttons[i].className = buttons[i].getAttribute("data-filter") === filter ? "selected" : "";
  }
}

// Handlers are attached from the script when the page has loaded, not written into the HTML.
window.onload = function () {
  var field = document.getElementById("new-todo");
  var buttons = document.getElementById("filters").getElementsByTagName("button");
  var i;

  document.getElementById("todo-form").onsubmit = function () {
    var title = field.value.replace(/^\s+|\s+$/g, "");
    if (title !== "") {
      request("POST", "/todos", "title=" + encodeURIComponent(title), show);
      field.value = "";
    }
    // false cancels the normal submission: no new page, the request runs in the background.
    return false;
  };

  for (i = 0; i < buttons.length; i++) {
    // Inside the handler, this is the button that was clicked.
    buttons[i].onclick = function () {
      filter = this.getAttribute("data-filter");
      render();
    };
  }

  // The page arrives without the list; the first request fetches it.
  request("GET", "/todos", null, show);
};

Flux and Redux

React 19.3.0, React DOM 19.3.0, Redux 5.0.1, React Redux 9.3.1

/src/App.jsx · 91 lines

JSX
// A container component: it owns no data. connect() passes it the store's state and the actions as props.
// JSX then compiled to React.createElement, so React had to be imported; the automatic runtime used here does not need it.
import React from "react";
import { connect } from "react-redux";
import { addTodo, toggleTodo, setFilter } from "./actions.js";

const FILTERS = { all: "All", active: "Active", done: "Done" };

// A plain function of props, as in the Redux docs of the time: the typed text is read from
// the input through a ref, so the component needs no state of its own.
function TodoApp({ todos, left, filter, onAdd, onToggle, onFilter }) {
  let input;

  function handleSubmit(event) {
    event.preventDefault();
    const title = input.value.trim();
    if (!title) return;
    onAdd(title);
    input.value = "";
  }

  return (
    <main className="todo-app">
      <h1>Todos</h1>
      <form id="todo-form" onSubmit={handleSubmit}>
        <input
          id="new-todo"
          ref={(node) => {
            input = node;
          }}
          placeholder="What needs doing?"
          autoComplete="off"
          aria-label="New todo"
        />
        <button id="add" type="submit">
          Add
        </button>
      </form>
      <ul id="todo-list">
        {todos.map((todo) => (
          <li key={todo.id} className={todo.done ? "done" : undefined}>
            <label>
              <input
                type="checkbox"
                data-toggle
                checked={todo.done}
                onChange={() => onToggle(todo.id)}
              />{" "}
              <span className="title">{todo.title}</span>
            </label>
          </li>
        ))}
      </ul>
      <div className="footer">
        <span id="todo-count">{left} left</span>
        <div className="filters">
          {Object.keys(FILTERS).map((name) => (
            <button
              key={name}
              type="button"
              data-filter={name}
              className={filter === name ? "selected" : undefined}
              onClick={() => onFilter(name)}
            >
              {FILTERS[name]}
            </button>
          ))}
        </div>
      </div>
    </main>
  );
}

// Picks what the component reads from the state. Derived values are computed, not stored.
const mapStateToProps = (state) => ({
  todos: state.todos.filter((t) => state.filter === "all" || (state.filter === "done") === t.done),
  left: state.todos.filter((t) => !t.done).length,
  filter: state.filter,
});

// The component never changes data itself: its callbacks dispatch actions to the store.
const mapDispatchToProps = (dispatch) => ({
  onAdd: (title) => dispatch(addTodo(title)),
  onToggle: (id) => dispatch(toggleTodo(id)),
  onFilter: (name) => dispatch(setFilter(name)),
});

// connect() subscribes to the store, runs mapStateToProps when the state changes and renders
// TodoApp again when the result differs. @deprecated since React-Redux 9.3 (hooks are
// recommended), it still works the same and prints nothing (legacy_connect is the same).
export default connect(mapStateToProps, mapDispatchToProps)(TodoApp);