JavaScript Reactivity, the one-pager

Every framework, plotted on three axes

A summary of Parts 1 through 4 of the series. Reactivity has two halves: the notification (something changed) and the update (go sync the view). Depth and granularity describe the notification. Directionality describes the update.

The three axes

01 Depth

"What is the smallest change I can make that still triggers updates?"

ShallowDeep

JavaScript only sees a write when it goes through a setter or Proxy trap. Mutate a nested object and the outer reference never notices. That's why primitives get wrapped in a container with .value, and why deep systems (Vue, MobX, Solid stores) recursively proxy everything you touch.

Shallow is simple and leans on reassignment. Deep is ergonomic but brings proxy identity weirdness. Either way, every system ships an escape hatch: requestUpdate(), triggerRef(), notify().

Read Part 2: Deep vs. Shallow →

02 Granularity

"At what level are changes detected, and how does the system find what actually changed?"

CoarseFine

Scope shrinks in rings: window, application, service, component, template, DOM node. Zone.js rechecks the world. React re-renders a subtree and diffs. Signals frameworks track every read and update the exact bound node.

Coarse is simpler and gets you surprisingly far. Fine does less work, but now you own dependency tracking: de-duping, conditional reads, and the diamond problem.

Read Part 3: Coarse vs. Fine →

03 Directionality

"Does change get pushed to dependents, or pulled at render time?"

PullPush

Every framework nudges itself on a write, so that's not the test. A system is push when its dependencies are figured out ahead of time. Pull systems re-run render top to bottom and never see an inconsistent state.

Push-pull (signals) must solve glitches with scheduling and topological ordering. There's no truly pure push framework; Svelte 4 comes closest.

Read Part 4: Push vs. Pull →

Four families emerge

Cross depth with granularity and the landscape splits into four quadrants. See the interactive chart in Part 1.

Fine + deep Reactive graphs

Recursive proxies track exactly which paths you read. Vue, MobX, Valtio, Solid stores, Svelte 5.

Fine + shallow Atomic primitives

A box around a value, exposed through .value or a getter. Signals, shallowRef, nanostores.

Coarse + shallow Diffing

Swap the reference, re-render virtually, compare. React, Preact, Redux, Lit.

Coarse + deep Wholesale discovery

"Something changed, go find it." Least efficient, easiest to share across a platform. Zone.js, wc-services.

Where each one lands

Framework / library Depth Granularity (scope) Direction

Granularity bars run coarse (window) to fine (DOM node). Lighter segments mark a range. Placements are approximate and full of "it depends"; the posts carry the nuance.

The takeaways