Skip to content
FrontDepth, Home

SSR, SSG and meta-frameworks → Signals and fine-grained reactivity

2016 – today · 2021 – today

Older era
Newer era
Compare

What changed

Where the state lives

SSR, SSG and meta-frameworks

In the page component's this.state, started from the props the server loaded with getInitialProps(); a copy of those props travels with the HTML as JSON.

Signals and fine-grained reactivity

In signals: the list and the filter are signals, and each todo's done is a signal of its own. left and each row's shown are computed.

How the page is rendered

SSR, SSG and meta-frameworks

The server renders the whole page to HTML with renderToString(); the browser hydrates it with hydrateRoot() and renders every later change itself.

Signals and fine-grained reactivity

Plain DOM: a row is built once, when its todo appears. After that only effects touch it; there is no virtual DOM and no template re-render.

What happens on a change

SSR, SSG and meta-frameworks

After hydration everything happens in the browser: a handler calls this.setState() and React re-renders the page component. Nothing goes back to the server.

Signals and fine-grained reactivity

Setting .value re-runs only the effects that read that signal, right away: ticking a todo updates its row's class and the counter text, nothing else.

How the code is organised

SSR, SSG and meta-frameworks

A page in pages/ written once for both sides, plus framework code: a server that renders and serializes, and a client entry that hydrates.

Signals and fine-grained reactivity

Signals and computed values at the top, then small effects, each bound to one piece of the DOM.

Why it changed

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

  1. 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.

  2. 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.

  3. Server components and islands→Signals and fine-grained reactivity

    Inside an island, and inside every client component, nothing changed: each state change runs the component again and React compares the new output with the old. Ticking one checkbox here re-renders the whole TodoApp and compares every item; keeping large islands fast takes memo, useMemo and useCallback. Signals and fine-grained reactivity track which piece of the DOM reads which value and update only that.

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.

SSR, SSG and meta-frameworks
Signals and fine-grained reactivity

SSR, SSG and meta-frameworks

React 19.3.0, React DOM 19.3.0

/pages/index.jsx · 101 lines

JSX
// A page as Next.js apps wrote it in 2016–2018: a class component with a static data method.
// The same file runs twice: on the server (to HTML) and in the browser (hydration).
import { Component } from "react";

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

export default class TodoPage extends Component {
  // Called on the server before the first render; what it returns becomes the page's props.
  // A real page would read a database or an API here.
  static async getInitialProps() {
    return {
      todos: [
        { id: 1, title: "Read the docs", done: true },
        { id: 2, title: "Write the app", done: false },
      ],
    };
  }

  constructor(props) {
    super(props);
    // The first state comes only from props, so the server and the browser render the same HTML.
    this.state = { todos: props.todos, filter: "all", title: "" };
    this.nextId = Math.max(0, ...props.todos.map((t) => t.id)) + 1;
    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
  }

  handleChange(event) {
    this.setState({ title: event.target.value });
  }

  handleSubmit(event) {
    event.preventDefault();
    const title = this.state.title.trim();
    if (!title) return;
    const todo = { id: this.nextId++, title, done: false };
    this.setState((state) => ({ todos: [...state.todos, todo], title: "" }));
  }

  toggle(id) {
    this.setState((state) => ({
      todos: state.todos.map((t) => (t.id === id ? { ...t, done: !t.done } : t)),
    }));
  }

  render() {
    const { todos, filter, title } = this.state;
    const shown = todos.filter((t) => filter === "all" || (filter === "done") === t.done);
    const left = todos.filter((t) => !t.done).length;

    return (
      <main className="todo-app">
        <h1>Todos</h1>
        <form id="todo-form" onSubmit={this.handleSubmit}>
          <input
            id="new-todo"
            value={title}
            onChange={this.handleChange}
            placeholder="What needs doing?"
            autoComplete="off"
            aria-label="New todo"
          />
          <button id="add" type="submit">
            Add
          </button>
        </form>
        <ul id="todo-list">
          {shown.map((todo) => (
            <li key={todo.id} className={todo.done ? "done" : undefined}>
              <label>
                <input
                  type="checkbox"
                  data-toggle
                  checked={todo.done}
                  onChange={() => this.toggle(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.entries(FILTERS).map(([name, label]) => (
              <button
                key={name}
                type="button"
                data-filter={name}
                className={filter === name ? "selected" : undefined}
                onClick={() => this.setState({ filter: name })}
              >
                {label}
              </button>
            ))}
          </div>
        </div>
      </main>
    );
  }
}

Signals and fine-grained reactivity

Preact Signals 1.14.5

/src/main.js · 78 lines

JavaScript
// Signals era: state lives in signals, and each effect keeps one piece of the DOM in sync.
// An effect remembers which signals it read and re-runs only when one of them changes.
import { signal, computed, effect } from "@preact/signals-core";

let nextId = 1;
// Each todo's done is a signal of its own, so ticking one todo touches only its own row.
const createTodo = (title, done = false) => ({ id: nextId++, title, done: signal(done) });

const todos = signal([createTodo("Read the docs", true), createTodo("Write the app")]);
const filter = signal("all");
// A computed is cached: it is recomputed only after a signal it read has changed.
const left = computed(() => todos.value.filter((t) => !t.done.value).length);

const list = document.getElementById("todo-list");
const rowTemplate = document.getElementById("todo-row");

// Builds a row once. From then on only its own two effects touch it.
function renderRow(todo) {
  const li = rowTemplate.content.firstElementChild.cloneNode(true);
  const checkbox = li.querySelector("[data-toggle]");
  li.querySelector(".title").textContent = todo.title;
  checkbox.addEventListener("change", () => {
    todo.done.value = checkbox.checked;
  });

  // Re-runs only when THIS todo's done changes.
  effect(() => {
    li.classList.toggle("done", todo.done.value);
    checkbox.checked = todo.done.value;
  });

  // Recomputed when the filter or this todo's done changes. If the answer stays the same
  // (ticking a todo under "All"), the effect that reads it does not run at all.
  const shown = computed(() => filter.value === "all" || (filter.value === "done") === todo.done.value);
  effect(() => {
    li.style.display = shown.value ? "" : "none";
  });
  return li;
}

// Re-runs only when the list itself changes (a todo is added). It builds rows for new todos
// and leaves the existing ones alone. Nothing is ever removed here, so no effect is disposed.
const rendered = new Set();
effect(() => {
  for (const todo of todos.value) {
    if (rendered.has(todo)) continue;
    rendered.add(todo);
    list.append(renderRow(todo));
  }
});

// Re-runs when left changes: after adding or ticking a todo, never after picking a filter.
const count = document.getElementById("todo-count");
effect(() => {
  count.textContent = `${left.value} left`;
});

// Re-runs when the filter changes: moves the "selected" class.
const buttons = document.querySelectorAll("[data-filter]");
effect(() => {
  for (const button of buttons) button.classList.toggle("selected", button.dataset.filter === filter.value);
});

for (const button of buttons) {
  button.addEventListener("click", () => {
    filter.value = button.dataset.filter;
  });
}

document.getElementById("todo-form").addEventListener("submit", (event) => {
  event.preventDefault();
  const input = document.getElementById("new-todo");
  const title = input.value.trim();
  if (!title) return;
  // A new array, so the signal gets a new value and the effects that read it re-run.
  todos.value = [...todos.value, createTodo(title)];
  input.value = "";
});