Incremental Computation Graphs

A closer look at Incremental Computation Graphs

What Incremental Computation Graphs page is about

This post explains a computation-graph style approach used while building Yabu. It describes how inputs and memoized computations are organized into a runtime dependency graph so the system can avoid redoing work when only parts of the program change. The implementation the author worked from is based on Salsa and the write-up focuses on how memoization, dependencies and revision tracking interact.

What you can actually do after reading it

You can understand the algorithmic idea: treat external values as inputs and pure functions as memoized computations that record their dependencies. The text walks through how parsing, typechecking and compiling are represented as computations that create a runtime graph, how the system walks that graph to validate or invalidate memoized entries, and how :verified-at and :changed-at revisions are used to decide freshness. It also gives a concrete example of redefinition causing invalidation and how upward validation short-circuits later work.

Who will find this useful

People working on incremental build or typechecking systems, or anyone implementing memoization with dependency tracking, will find the description directly relevant. It is particularly aimed at readers curious how an interactive system like Yabu keeps typechecking and compilation fast by selectively invalidating dependent computations.

Questions people ask about Incremental Computation Graphs

Does the post include code I can copy and run?

The page discusses the algorithm and points to the Yabu Incremental Typesystem for the real algorithm, but it does not present a complete, runnable compile function for Yabu.

How does the system decide a memoized value is still fresh?

A memoized entry is fresh if its :verified-at equals the current revision, or when its dependencies are inputs whose :changed-at is less than the current revision, after walking the dependency chain to inputs or already-validated subtrees.

Is this approach specific to Yabu?

The implementation is described in the context of Yabu and is based on Salsa, but the concepts - inputs, memoized computations, dependency graphs and revision-based validation - are general and applicable to similar interactive systems.

Incremental Computation Graphs was shared on NexURLs by Nexis on October 24, 2026, in Tech & AI.