Skip to content
FrontDepth, Home

Flux and Redux → Component frameworks (Vue, Angular, Svelte)

2014 – today · 2014 – today

Older era
Newer era
Compare

What changed

Where the state lives

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.

Component frameworks (Vue, Angular, Svelte)

In the component's data(): plain objects and arrays that Vue makes reactive. shown and left are computed, cached until the data they read changes.

How the page is rendered

Flux and Redux

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

Component frameworks (Vue, Angular, Svelte)

Vue compiles the HTML template (written in the page here) into a render function. When data it read changes, the component re-renders and Vue patches only what differs.

What happens on a change

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.

Component frameworks (Vue, Angular, Svelte)

Methods and v-model change the data directly (this.todos.push, todo.done); Vue buffers the DOM update until the next tick, a microtask.

How the code is organised

Flux and Redux

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

Component frameworks (Vue, Angular, Svelte)

One component object of options (data, computed, methods) plus its template. Larger apps nest such components into a tree.

Why it changed

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

  1. Flux and Redux→Component frameworks (Vue, Angular, Svelte)

    Every small feature needed the same pieces in several files: an action type constant, an action creator, a case in a reducer, and mapStateToProps / mapDispatchToProps to connect a component, plus objects copied by hand so that nothing was mutated. Setting up a store with middleware and the DevTools took more code still. Redux itself later answered with Redux Toolkit; component frameworks like Vue, Angular and Svelte offered reactive state you change directly and HTML templates that update themselves, with much less ceremony.

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.

Flux and Redux
Component frameworks (Vue, Angular, Svelte)

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);

Component frameworks (Vue, Angular, Svelte)

Vue 3.5.45

/src/main.js · 41 lines

JavaScript
// Component-framework era (Vue): the component declares its state, derived values and
// methods; the HTML template in index.html describes the page. Vue keeps the two in sync.
import { createApp } from "vue";

let nextId = 3;

createApp({
  // data() returns the state. Vue makes it reactive: while rendering it records which
  // properties were read, and any later change to them re-renders the component.
  data() {
    return {
      todos: [
        { id: 1, title: "Read the docs", done: true },
        { id: 2, title: "Write the app", done: false },
      ],
      filter: "all",
      title: "",
    };
  },

  // Computed values are cached and re-evaluated only when the data they read changes.
  computed: {
    shown() {
      return this.todos.filter((t) => this.filter === "all" || (this.filter === "done") === t.done);
    },
    left() {
      return this.todos.filter((t) => !t.done).length;
    },
  },

  methods: {
    addTodo() {
      const title = this.title.trim();
      if (!title) return;
      // A plain push is enough: no new array, no setState. Vue sees the change itself.
      this.todos.push({ id: nextId++, title, done: false });
      this.title = "";
    },
  },
  // There is no template option, so mount() uses the HTML inside #app as the template.
}).mount("#app");