Skip to content
FrontDepth, Home

Flux and Redux → Server components and islands

2014 – today · 2020 – 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.

Server components and islands

In the island's useState, started from the props the server serialized next to it. The static parts have no state at all.

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.

Server components and islands

The server renders the whole page to HTML; only the island's element is hydrated with hydrateRoot(). React never touches the static HTML.

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.

Server components and islands

Inside the island a setter re-renders TodoApp and React updates the DOM that differs; the rest of the page never changes.

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.

Server components and islands

Server-only components that never reach the browser, around client islands that each have their own root, script and props.

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.

  2. Component frameworks (Vue, Angular, Svelte)→SSR, SSG and meta-frameworks

    These apps still rendered in the browser. The server sent an almost empty page, and nothing useful appeared until the framework and the app's JavaScript had downloaded and run; crawlers and link previews that do not run JavaScript saw nothing. Routing, server rendering, code splitting and data loading were left to each team to put together. Meta-frameworks such as Next.js and Nuxt bundled those pieces around the component framework and rendered pages on the server or at build time.

  3. SSR, SSG and meta-frameworks→Hooks

    Pages now arrived rendered, but the components were still classes: one feature's logic was spread over componentDidMount, componentDidUpdate and componentWillUnmount, sharing stateful logic needed higher-order components or render props, and every handler had to be bound to this (see the constructor). Hooks (React 16.8, 2019) gave function components state and effects that can be shared as custom hooks.

    Hydration had its own cost: the browser downloads and runs the code of the whole page, even of parts that never change, and the data travels twice, as HTML and as JSON. Islands and server components later went after that.

  4. Hooks→Server components and islands

    Everything still ran in the browser: the page arrived empty, every component's JavaScript had to download, run and render before anything useful appeared, and server rendering hydrated the whole page even where nothing was interactive. Effects with dependency arrays and stale closures became a common source of bugs. Islands and React Server Components moved the non-interactive parts back to the server.

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
Server components and islands

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

Server components and islands

React 19.3.0, React DOM 19.3.0

/server.jsx · 48 lines

JSX
// Islands era: the server renders the whole page to HTML, and only the islands get JavaScript.
// An islands framework such as Astro does this for you: you only mark what is interactive.
import { renderToStaticMarkup, renderToString } from "react-dom/server";
import TodoApp from "./islands/TodoApp.jsx";

// The "database" lives on the server.
const todos = [
  { id: 1, title: "Read the docs", done: true },
  { id: 2, title: "Write the app", done: false },
];

// A server-only component: it runs here and leaves plain HTML behind. It ships NO JavaScript:
// this file is never sent to the browser, and nothing hydrates its HTML.
function Intro() {
  return (
    <>
      <h1>Todos</h1>
      <p>This heading and note are plain HTML with no JavaScript. Everything below them is an island.</p>
    </>
  );
}

// "<" is escaped so that a todo titled "</script>" cannot end the script element early.
function serialize(props) {
  return JSON.stringify(props).replace(/</g, "\\u003c");
}

export async function handle({ method, path }) {
  if (method !== "GET" || path !== "/") return { status: 404, body: "<h1>Not found</h1>" };
  const props = { initialTodos: todos };

  // Static part: HTML only, without the markers hydration needs. No JavaScript.
  const intro = renderToStaticMarkup(<Intro />);

  // The island: HTML that hydrateRoot can attach to, with its props as JSON right next to it.
  const island = renderToString(<TodoApp {...props} />);

  return {
    status: 200,
    body: `
    <main class="todo-app">
      ${intro}
      <div id="todo-island">${island}</div>
      <script id="todo-island-props" type="application/json">${serialize(props)}</script>
    </main>
    <script src="/client.jsx"></script>`,
  };
}