Component frameworks (Vue, Angular, Svelte) → Signals and fine-grained reactivity
2014 – today · 2021 – today
What changed
- Where the state lives
Component frameworks (Vue, Angular, Svelte)
In the component's
data(): plain objects and arrays that Vue makes reactive.shownandleftarecomputed, cached until the data they read changes.Signals and fine-grained reactivity
In signals: the list and the filter are signals, and each todo's
doneis a signal of its own.leftand each row'sshownarecomputed.- How the page is rendered
Component frameworks (Vue, Angular, Svelte)
Vue compiles the HTML template (written in the page here) into a render function. When data it read changes, the component re-renders and Vue patches only what differs.
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
Component frameworks (Vue, Angular, Svelte)
Methods and
v-modelchange the data directly (this.todos.push,todo.done); Vue buffers the DOM update until the next tick, a microtask.Signals and fine-grained reactivity
Setting
.valuere-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
Component frameworks (Vue, Angular, Svelte)
One component object of options (
data,computed,methods) plus its template. Larger apps nest such components into a tree.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.
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.
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
TodoAppand compares every item; keeping large islands fast takesmemo,useMemoanduseCallback. 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.
Component frameworks (Vue, Angular, Svelte)
Vue 3.5.45
/src/main.js · 41 lines
// Component-framework era (Vue): the component declares its state, derived values and
// methods; the HTML template in index.html describes the page. Vue keeps the two in sync.
import { createApp } from "vue";
let nextId = 3;
createApp({
// data() returns the state. Vue makes it reactive: while rendering it records which
// properties were read, and any later change to them re-renders the component.
data() {
return {
todos: [
{ id: 1, title: "Read the docs", done: true },
{ id: 2, title: "Write the app", done: false },
],
filter: "all",
title: "",
};
},
// Computed values are cached and re-evaluated only when the data they read changes.
computed: {
shown() {
return this.todos.filter((t) => this.filter === "all" || (this.filter === "done") === t.done);
},
left() {
return this.todos.filter((t) => !t.done).length;
},
},
methods: {
addTodo() {
const title = this.title.trim();
if (!title) return;
// A plain push is enough: no new array, no setState. Vue sees the change itself.
this.todos.push({ id: nextId++, title, done: false });
this.title = "";
},
},
// There is no template option, so mount() uses the HTML inside #app as the template.
}).mount("#app");Signals and fine-grained reactivity
Preact Signals 1.14.5
/src/main.js · 78 lines
// 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 = "";
});