Pushing and Pulling: Three reactivity algorithms

Jonathan Frere's article delves into the core mechanics of reactivity engines, essential for modern software development, particularly in UIs and data processing. Using the intuitive analogy of a spreadsheet, he outlines the fundamental problem and the common requirements for reactive systems: efficiency (calculating each cell at most once), fine-grained updates (only affecting necessary cells), glitchlessness (avoiding inconsistent intermediate states), and dynamic dependencies.

The article then systematically explores three primary reactivity algorithms:

• Push-Based Reactivity: Updates are "pushed" from a changed node to its dependents. While naturally fine-grained, this approach struggles with efficiency if not carefully ordered and is prone to "glitches" (observable inconsistent states) without complex topological sorting. Examples include event systems and streams.
• Pull-Based Reactivity: Updates are "pulled" when a node requests its value, recursively triggering its dependencies. This offers inherent glitchlessness and dynamic dependencies but is inefficient as it recalculates everything by default, requiring sophisticated caching strategies to mitigate.
• Push-Pull Reactivity: A hybrid model that combines the strengths of both. A "push" phase first marks nodes as "dirty" without recalculating them, identifying exactly what needs updating. Then, a "pull" phase recalculates only these dirty nodes and their dependencies. This approach achieves efficiency (O(n) for dirty nodes), fine-grained updates, glitchlessness, and dynamic dependency handling.

Frere concludes that the push-pull model offers a robust and efficient solution for many reactive system needs, striking a balance between performance and correctness. The article sets the stage for further exploration of specific tangents in future posts.