Skip to content
FrontDepth, Home

Dynamic HTML and the browser wars → SSR, SSG and meta-frameworks

1995 – today · 2016 – today

Older era
Newer era
Compare

What changed

Where the state lives

Dynamic HTML and the browser wars

In the page: a JavaScript array and a filter variable. Nothing is saved; a reload starts again from the code.

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

Dynamic HTML and the browser wars

render() builds the whole list as one HTML string and swaps it in with innerHTML.

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

Dynamic HTML and the browser wars

Handler attributes (onsubmit, onclick) call global functions that change the array and call render().

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

Dynamic HTML and the browser wars

One script of global functions, wired to the page by attributes in the HTML. No server is involved.

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. Dynamic HTML and the browser wars→AJAX

    The page could change itself, but it could not exchange data with the server without leaving: loading fresh data or saving a change still meant a form submission or a link and a whole new page, and everything kept in variables was gone after it. On top of that, every browser needed its own branch of the code. XMLHttpRequest and the AJAX approach let a script talk to the server in the background and update only the part of the page that changed.

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

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

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

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

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

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

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

Dynamic HTML and the browser wars
SSR, SSG and meta-frameworks

Dynamic HTML and the browser wars

plain browser APIs, no library

/src/main.js · 73 lines

JavaScript
// DHTML era: the page changes itself in the browser. The list is a JavaScript array, and
// render() writes it into the page as one HTML string. No server is asked.

// The state is plain variables in the page: a reload starts again from these lines.
var todos = [
  { id: 1, title: "Read the docs", done: true },
  { id: 2, title: "Write the app", done: false }
];
var nextId = 3;
var filter = "all";
var FILTERS = ["all", "active", "done"];

// The text the user typed becomes part of the HTML, so it is escaped first.
function escapeHtml(text) {
  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
}

function render() {
  var html = "";
  var left = 0;
  var i, todo;
  for (i = 0; i < todos.length; i++) {
    todo = todos[i];
    if (!todo.done) left++;
    if (filter == "all" || (filter == "done") == todo.done) {
      // The handler is part of the string: onclick calls a global function with the id.
      html += '<li' + (todo.done ? ' class="done"' : '') + '><label>' +
        '<input type="checkbox" data-toggle onclick="toggleTodo(' + todo.id + ')"' +
        (todo.done ? ' checked' : '') + '> ' +
        '<span class="title">' + escapeHtml(todo.title) + '</span></label></li>';
    }
  }
  // innerHTML throws the old items away and builds new ones, so a focused checkbox loses focus.
  document.getElementById("todo-list").innerHTML = html;
  document.getElementById("todo-count").innerHTML = left + " left";
  for (i = 0; i < FILTERS.length; i++) {
    document.getElementById("filter-" + FILTERS[i]).className = FILTERS[i] == filter ? "selected" : "";
  }
}

function addTodo() {
  var field = document.getElementById("new-todo");
  var title = field.value.replace(/^\s+|\s+$/g, "");
  if (title != "") {
    todos.push({ id: nextId++, title: title, done: false });
    field.value = "";
    render();
  }
  // false cancels what the browser would do next: send the form and load a new page.
  return false;
}

function toggleTodo(id) {
  for (var i = 0; i < todos.length; i++) {
    if (todos[i].id == id) todos[i].done = !todos[i].done;
  }
  render();
}

function setFilter(name) {
  filter = name;
  render();
}

// A <script> of the time ran in the global scope: every function above became global, and
// the onclick attributes could call it. The lab runs each file as a module with its own
// scope, so the functions the markup calls are put on window by hand.
window.addTodo = addTodo;
window.toggleTodo = toggleTodo;
window.setFilter = setFilter;

// Like a <script> at the end of <body>, this runs when the elements already exist: draw the list.
render();

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