Menu

[ _Start ]

[ About ]

[ Bio ]

[ Blog ]

[ Contact ]

[ Experiments ]

[ Links ]

...

There and Back Again: How Reactivity Won the Hearts of Modern Web Developers

There were some detours and experimentation, but in the end we just reinvented VisiCalc again.

Reactive what?

At its core, reactivity is about declaring relationships between values rather than imperatively orchestrating updates. Instead of manually pushing changes every time a variable mutates, you define how derived state depends on its sources and let the runtime propagate updates automatically.

The Evolution of Reactive Architectures: A Historical Timeline

Reactive programming has evolved over six decades, moving from theoretical dataflow models to native browser primitives. Below is a chronological-ish overview of the major milestones that shaped modern reactive systems.

1960s: Dataflow Theory and Kahn Process Networks

Computer scientists Jack Dennis and Gilles Kahn formalized dataflow architectures and Kahn Process Networks (KPN). Rather than executing instructions sequentially, programs were modeled as directed graphs where nodes react and process data as soon as inputs arrive.

1979: VisiCalc and Spreadsheet Reactivity

The release of VisiCalc introduced practical reactive programming to personal computing. By defining cell formulas such as =A1+B1, users implicitly constructed dependency graphs where state mutations automatically propagated to dependent cells without manual imperative triggers.

1980s: Synchronous Reactive Languages

French researchers developed synchronous reactive languages, like Esterel, Lustre, and Signal, designed for safety-critical, real-time embedded little things, such as avionics and nuclear power plant controllers, requiring deterministic reactions to physical sensor inputs.

1997: Functional Reactive Programming (FRP)

Conal Elliott and Paul Hudak published Functional Reactive Animation, introducing the quite funny Fran library in Haskell. This work established the formal mathematical foundation for FRP by distinguishing between Behaviors (continuous time-varying values) and Events (discrete occurrences over time).

The thing was pretty much solved in this ground-breaking work.

2006โ€“2007: Rich Internet Applications and Declarative Binding

Oh yes, remember RIA?

Enterprise UI frameworks popularized declarative data binding on the desktop and early web. Adobe Flex ([Bindable]) and Microsoft WPF/Silverlight (INotifyPropertyChanged) standardized observer-based property notifications, while Flapjax brought academic FRP concepts directly to JavaScript.

2009: .NET Reactive Extensions (Rx)

Erik Meijer created Rx.NET at Microsoft, which soon inspired RxJS. By unifying the Observer and Iterator patterns with functional composition, Reactive Extensions established asynchronous event streams as a primary abstraction for handling complex, time-based workflows.

A valid question, even today, is: it was complex due to the involved workflows or the involved workflows got complex because of it? Who knows.

2010: KnockoutJS and AngularJS

A pivotal year for web reactivity saw two contrasting approaches emerge. Steve Sanderson released KnockoutJS, pioneering fine-grained reactivity in the JavaScript badlands. It did automatic dependency tracking (observable and computed) and was elegant as hell. Months later, Google released AngularJS, opting instead for dirty-checking cycles to synchronize model and view state. Clean and elegant to use, ugly and poor performance under the hood, but hey, it's Google, how could they possibly be wrong about this?

2011: JavaFX 2.0

Oracle replaced the standalone JavaFX Script language with a pure Java API in JavaFX 2.0. This release introduced observable properties (ObservableValue) and fluent bindings, bringing fine-grained reactive state graphs to standard JVM desktop applications.

2013: React and the Virtual DOM Paradigm

Facebook introduced React, shifting industry consensus away from fine-grained mutable state tracking. React promoted declarative UI rendering backed by a Virtual DOM diffing algorithm, trading granular updates for predictable, top-down component re-renders.

As a side note, they also introduced JSX, which is something between a declarative language, a javascript/typescript extension and a mental disease that frontend developers never fully recovered from.

2014: Vue.js

Evan You launched Vue.js, combining component-based architecture with automatic dependency tracking. By intercepting property access via Object.defineProperty (and later ES6 Proxies), Vue preserved fine-grained state reactivity alongside a Virtual DOM renderer.

2015: MobX

Michel Weststrate released MobX, reintroducing transparent, fine-grained reactive state management (observable, computed, and autorun) into the React ecosystem as an alternative to immutable, reducer-based architectures.

In short, Michel tried to fix React early on.

2018โ€“2020: SolidJS and the Signals Renaissance

Ryan Carniato created SolidJS, demonstrating that Knockout-style fine-grained reactivityโ€”paired with modern push-pull algorithms to prevent unnecessary recalculations and glitchesโ€”could outperform Virtual DOM frameworks in runtime speed and memory efficiency.

Ryan fixed React.

2020โ€“2026: Industry Convergence and TC39 Standardization

Fine-grained reactivity became the unifying paradigm across frontend frameworks. Vue 3 refs (2020) and Vue Vapor (2026), Angular Signals (2023), and Svelte 5 Runes (2023โ€“2024) adopted signal-based primitives, culminating in a formal TC39 proposal to standardize Signals natively in ECMAScript.

Conclusion

Modern abstractions rarely appear out of thin air; they stand on decades of deep roots. Today's reactive primitives are the meeting point between early academic formalism and years of wild, trial-and-error experimentation on the web. As Signals move toward native browser standardization, one can only wonder what comes next: are we on the verge of a genuine paradigm shift, or will software engineering simply keep spiraling back to its foundational ideas?

Will someone fix React again?

 

2026-11-21 misc software architecture