MVC in the browser (Backbone) → Server components and islands
2010 – today · 2020 – today
What changed
- Where the state lives
MVC in the browser (Backbone)
In models: every todo is a
Backbone.Modelin aCollection, and the filter sits in a model of its own (ui).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
MVC in the browser (Backbone)
Each
TodoViewrenders its own<li>from an_.template; the app view updates only the counter and the filter buttons.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
MVC in the browser (Backbone)
A handler calls
set()on a model; the model fireschange, and every view listening to it re-renders itself.Server components and islands
Inside the island a setter re-renders
TodoAppand React updates the DOM that differs; the rest of the page never changes.- How the code is organised
MVC in the browser (Backbone)
Models, a collection and views connected by events. A view's
eventshash delegates DOM events to its element.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.
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.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 asetTimeoutcallback 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.
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,
setStatecalls 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.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/mapDispatchToPropsto 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.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.
SSR, SSG and meta-frameworks→Hooks
Pages now arrived rendered, but the components were still classes: one feature's logic was spread over
componentDidMount,componentDidUpdateandcomponentWillUnmount, sharing stateful logic needed higher-order components or render props, and every handler had to be bound tothis(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.
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.
MVC in the browser (Backbone)
Backbone 1.6.1, Underscore 1.13.8, jQuery 4.0.0
/src/main.js · 100 lines
// Backbone era: the data lives in models. Views listen to them and re-render themselves.
import Backbone from "backbone";
import _ from "underscore";
import $ from "jquery";
// A model keeps attributes; set() changes one and fires "change:done", then "change".
const Todo = Backbone.Model.extend({
defaults: { title: "", done: false },
toggle: function () {
this.set("done", !this.get("done"));
},
});
// A collection is an ordered list of models and passes their events on.
const TodoList = Backbone.Collection.extend({
model: Todo,
remaining: function () {
return this.where({ done: false });
},
});
const todos = new TodoList([
{ title: "Read the docs", done: true },
{ title: "Write the app", done: false },
]);
// The filter is state too, so it lives in a model that views can listen to.
const ui = new Backbone.Model({ filter: "all" });
// Compiled once into a function. <%- %> escapes the title, <%= %> writes HTML as it is.
const itemTemplate = _.template(
'<label><input type="checkbox" data-toggle<%= done ? " checked" : "" %>> ' +
'<span class="title"><%- title %></span></label>',
);
// One view per todo: it owns its <li> and redraws it whenever the model changes.
const TodoView = Backbone.View.extend({
tagName: "li",
// Delegated to this.el, so the handler survives every re-render of the <li>.
events: { "change [data-toggle]": "toggleDone" },
initialize: function () {
// listenTo remembers each subscription, so view.remove() can drop them all. A view thrown
// away without remove() stays subscribed to ui and keeps rendering: a "zombie view".
this.listenTo(this.model, "change", this.render);
this.listenTo(ui, "change:filter", this.render);
},
render: function () {
const done = this.model.get("done");
const filter = ui.get("filter");
// New HTML replaces the checkbox, so the view has to give keyboard focus back itself.
const focused = this.el.contains(document.activeElement);
this.$el.html(itemTemplate(this.model.toJSON()));
if (focused) this.$("[data-toggle]").trigger("focus");
this.$el.toggleClass("done", done);
this.$el.toggle(filter === "all" || (filter === "done") === done);
return this;
},
toggleDone: function () {
this.model.toggle();
},
});
// The app view takes over markup that is already in the page: el is a selector.
const AppView = Backbone.View.extend({
el: ".todo-app",
events: {
"submit #todo-form": "create",
"click [data-filter]": "pickFilter",
},
initialize: function () {
this.listenTo(todos, "add", this.addOne);
this.listenTo(todos, "add change:done", this.render);
this.listenTo(ui, "change:filter", this.render);
todos.each(this.addOne, this);
this.render();
},
addOne: function (todo) {
this.$("#todo-list").append(new TodoView({ model: todo }).render().el);
},
// Renders only what this view owns: the counter and the selected filter.
render: function () {
this.$("#todo-count").text(todos.remaining().length + " left");
this.$("[data-filter]").removeClass("selected");
this.$('[data-filter="' + ui.get("filter") + '"]').addClass("selected");
return this;
},
create: function (event) {
event.preventDefault();
const $input = this.$("#new-todo");
const title = $input.val().trim();
if (!title) return;
todos.add({ title: title });
$input.val("");
},
pickFilter: function (event) {
ui.set("filter", $(event.currentTarget).data("filter"));
},
});
new AppView();Server components and islands
React 19.3.0, React DOM 19.3.0
/server.jsx · 48 lines
// 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>`,
};
}