{
  "id": 8865611,
  "title": "When Computed Becomes Async",
  "url": "https://urgent.news/2026/09/21/when-computed-becomes-async",
  "topic": "tech",
  "section": "Tech",
  "published": "2026-09-21T06:44:34.000Z",
  "source": {
    "name": "Dev.to",
    "slug": "dev-to",
    "url": "https://dev.to/luciano0322/when-computed-becomes-async-2f96"
  },
  "original_language": "en",
  "account": "Async programming introduces significant complexities when dealing with reactive systems. When looking at Solid 2.0's approach to async reactivity, one API that stands out is `createMemo`, which can accept an async function. However, the real challenge lies not just in supporting a new return type, but in how the runtime manages executions instead of just values.\n\nIn synchronous computations, the process is relatively straightforward: read dependencies, compute value, cache value, and recompute when needed. The runtime primarily needs to answer questions about dependencies, staleness, cached values, and when to recompute. This model revolves around the value lifecycle, with dependency changes marking the computed as stale, followed by recomputation and caching the new value.\n\nThe key difference with async computations is that they are no longer simple value operations. Instead, they involve executing, suspending, and potentially resuming. This introduces a new concept: a computation execution may still be in progress, requiring the runtime to track multiple, potentially overlapping executions. Traditional Promise handling lacks mechanisms to differentiate between a finished Promise and a valid result. The runtime must determine if a completed execution is still valid or has been superseded by a newer one.\n\nMoreover, async computations pose challenges in dependency tracking. When a synchronous computation encounters an await boundary, it's clear whether dependency tracking should continue. However, with async computations, it's unclear whether dependencies should be re-evaluated once an await completes. This complicates the task of identifying valid results and maintaining accurate dependency tracking.\n\nIn summary, async computations fundamentally change the model of reactive systems by introducing execution identity, managing multiple simultaneous executions, and complicating dependency tracking. These complexities make async reactivity a more intricate and challenging area compared to synchronous computations.",
  "summary": "While looking at how Solid 2.0 approaches async reactivity, one API in particular stood out to me because of how easy it is to underestimate the amount of machinery behind it: const user = createMemo ( async () => { return fetchUser ( id ()); }); From the API alone, it looks like a small extension: createMemo , which normally takes a synchronous callback, can now accept an async function . But…",
  "key_points": [],
  "editors_take": null,
  "illustration": null,
  "coverage": {
    "outlets": 1,
    "also_reported_by": []
  },
  "ai_generated": true,
  "disclaimer": "Summaries, key points and the editor’s take are written by software from other outlets’ reporting and may contain errors — always check the linked original."
}