Skip to content
FrontDepth, Home

React and the virtual DOM → SSR, SSG and meta-frameworks

2013 – today · 2016 – today

Older era
Newer era
Compare

What changed

Where the state lives

React and the virtual DOM

In this.state of the top App class: the todos, the filter and the typed text, changed only through this.setState.

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.

How the page is rendered

React and the virtual DOM

render() returns the whole UI as React elements on every change; React compares them with the previous ones and patches only the DOM that differs.

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.

What happens on a change

React and the virtual DOM

A bound handler calls this.setState; React merges the change into the state and calls render() again.

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.

How the code is organised

React and the virtual DOM

A class component that owns the state and a small function component that gets props: data goes down as props, changes come back up through callbacks.

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.

Why it changed

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

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

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

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

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.

React and the virtual DOM
SSR, SSG and meta-frameworks

React and the virtual DOM

React 19.3.0, React DOM 19.3.0

/src/App.jsx · 98 lines

JSX
// Virtual DOM era: render() describes the whole UI from this.state, and React updates the DOM.
// JSX then compiled to React.createElement, so every file imported React; the automatic runtime used here does not need it.
import React from "react";
import TodoItem from "./TodoItem.jsx";

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

let nextId = 3;

export default class App extends React.Component {
  constructor(props) {
    super(props);
    // The top component owns the state; its children get pieces of it as props.
    this.state = {
      todos: [
        { id: 1, title: "Read the docs", done: true },
        { id: 2, title: "Write the app", done: false },
      ],
      filter: "all",
      title: "",
    };
    // A class method passed as a callback loses `this`, so each handler is bound once here.
    this.handleChange = this.handleChange.bind(this);
    this.handleSubmit = this.handleSubmit.bind(this);
    this.toggle = this.toggle.bind(this);
  }

  handleChange(event) {
    // setState merges the given keys into this.state and asks React to render again.
    this.setState({ title: event.target.value });
  }

  handleSubmit(event) {
    event.preventDefault();
    const title = this.state.title.trim();
    if (!title) return;
    const todo = { id: nextId++, title, done: false };
    // setState is a request, not an immediate change: the function form gets the latest state.
    this.setState((state) => ({ todos: state.todos.concat(todo), title: "" }));
  }

  toggle(id) {
    // Copy the todo instead of changing it. Object spread ({ ...t }) only became standard
    // in ES2018, so code of the time used Object.assign.
    this.setState((state) => ({
      todos: state.todos.map((t) => (t.id === id ? Object.assign({}, t, { done: !t.done }) : t)),
    }));
  }

  // React calls it again on every state change, compares the new elements with the previous ones
  // (the virtual DOM) and changes only the DOM nodes that differ.
  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">
          {/* Data goes down as props; the change comes back up through onToggle. */}
          {shown.map((todo) => (
            <TodoItem key={todo.id} todo={todo} onToggle={this.toggle} />
          ))}
        </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={() => this.setState({ filter: name })}
              >
                {FILTERS[name]}
              </button>
            ))}
          </div>
        </div>
      </main>
    );
  }
}

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