When a reactive computation becomes asynchronous, the runtime must manage more than a value: it must decide which overlapping execution is still allowed to publish a result. A synchronous computation can usually read its dependencies, calculate, and cache within one call stack. An async computation can pause while those dependencies change, leaving older and newer work in flight at the same time.
Why async changes the reactive model
A synchronous computed value has a compact lifecycle: it reads dependencies, computes a result, caches it, then becomes stale when a dependency changes and recomputes when needed. Since the work ordinarily finishes in the same call stack, the runtime can associate the reads and result with one immediate computation.
As an Amazon Associate I earn from qualifying purchases.
An async callback introduces a time gap. It may read a dependency, pause at an await, and resume after the dependency has changed. The runtime must now account for both the graph state that started the work and the possibility that another execution has already begun.
Free tools Windows power users keep installed
One-click scans. No signup required.
Luciano0322’s DEV Community article, “When Computed Becomes Async”, frames the shift this way: “Once an async computation enters the reactive graph, the runtime is no longer managing only values. It is managing executions.” This is the author’s conceptual explanation, not an official Solid specification.
#1 Best Overall
How overlapping executions can publish stale data
Imagine an async computation that fetches a user record based on a user ID. The ID begins as 1, so execution A starts. Before A finishes, the ID changes to 2 and execution B starts. If B resolves first, it can produce the current user’s data. But A may resolve afterward.
A Promise reports that its work finished; it does not know whether its result is still current. As the article puts it, “A normal Promise has no concept of I am outdated. It only knows: I finished.” If a runtime accepts whichever result completes last, A’s late result could replace B’s newer data.
That means settlement alone is not enough to establish validity. The runtime needs a rule connecting a result to the execution or graph state that produced it, and it needs to decide whether that execution remains eligible to publish.
Quick wins for a faster PC:
Scan for outdated or missing drivers - takes under a minuteDriver Scan →Repair Windows errors before they cause bigger problemsFix Now →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →What a runtime has to decide
- Execution identity: How does the runtime distinguish one run from another when dependency changes trigger new work?
- Pending work after invalidation: When a dependency changes, does the earlier execution continue, get cancelled, or simply lose permission to publish?
- Publication validity: What check prevents an obsolete result from overwriting a result from a newer execution?
- Tracking across suspension: Do dependency reads after an
awaitbelong to the same tracked computation?
The article sketches revision checking as one way to think about validity: associate work with a revision and compare it before accepting a result. That is an illustrative concept, not a claim that Solid uses that exact mechanism. A runtime could address the same problem differently.
Rank #3
Why await complicates dependency tracking
Reactive tracking often relies on knowing which computation is active while dependencies are read. A synchronous callback provides a clear interval for that context. An async callback can suspend and resume later, when other work may also be running.
This leaves a design question rather than a settled rule: should reads after an await still be tracked as dependencies of the original computation? If tracking ends at suspension, later reads may not contribute to that computation’s dependency set. If a runtime keeps a shared tracking context active, separate asynchronous executions could risk being associated with the wrong context unless the runtime can keep them isolated.
Luciano0322 raises this as an open design challenge; the article does not establish how a released Solid version handles tracking across await.
Recommended Free Tools
What the article does—and does not—establish about Solid
The article uses Solid-style createMemo(async () => ...) as its motivating example and focuses on the reactive graph. It explains why asynchronous computations require rules for overlapping executions and result validity. It does not verify a Solid 2.0 release, identify an implementation version, or establish a particular stale-result policy, cancellation mechanism, dependency-tracking boundary, or UI and Suspense behavior.
Its central point is about the runtime model, not a specific framework guarantee: as Luciano0322 summarizes, “The runtime is no longer only deriving values. It is coordinating multiple computation executions over time.”
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
