JavaScript Reactivity

Every framework, plotted on three axes

A summary of Parts 1 through 4 of the series. Drag the plot to spin it.

←→ slides carousels inside slides swipe too F fullscreen

The shape of it

Reactivity has two halves

The notification

Something changed.

Depth · Granularity

The update

Go sync the view.

Directionality

Three questions

The three axes

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.

Read Part 2: Deep vs. Shallow

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

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

Depth × granularity

Four families emerge

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 + deep

Wholesale discovery

"Something changed, go find it." Least efficient, easiest to share across a platform.

Zone.js, wc-services

Coarse + shallow

Diffing

Swap the reference, re-render virtually, compare.

React, Preact, Redux, Lit

See the interactive chart in Part 1.

Where each one lands

Framework by framework

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.

If you remember four things

The takeaways

1

Detection and response are separate.

Re-rendering everything doesn't make a system deep. Depth is about what triggers the update, not what the update touches.

Part 2
2

Every system has an escape hatch.

No detection scheme catches everything, so they all let you poke it manually, usually by reassigning the top-level reference.

Part 2
3

Fine-grained frameworks converge.

Angular, Solid, Svelte 5, and Preact signals all read to subscribe and write to notify. The API spelling is the main difference.

Part 3
4

The diamond problem decides push vs. pull.

Once dependencies are wired ahead of time, you need scheduling and topological ordering to avoid glitches. Pull frameworks dodge this entirely.

Part 4

Read the whole thing

The JavaScript Reactivity series

By Jim Schofield.

  1. 1A Global Look
  2. 2Deep vs. Shallow Reactivity
  3. 3Coarse vs. Fine-Grained Reactivity
  4. 4Push vs. Pull Reactivity