Wow, this is really helpful and timely!

I'm building a new language with async/await and had to make a lot of these decisions, but I didn't have this organized of a framework to ground myself in. I'm happy to see it clearly that I choose mostly Trio with a bit of JavaScript.

My language (Zena's) async docs page: https://zena-lang.dev/guide/async/ I think I might do a pass and try to call out the decision points more explicitly.

fwiw, I found this post on cancellation by the author of Trio to be vey compelling: https://vorpus.org/blog/timeouts-and-cancellation-for-humans... and I based the cancellation design of Zena on it.

Edit to add: I do wish this included JavaScript's AbortSignal in the Cancellation section. Not because it's good, but because passing cancel tokens is a pattern that exists. There's also the dimension of who can cancel and, like AbortSignal, whether tasks have to opt-in to cancellation checks.

• bufordsharkley

  today at 1:25 AM

  I definitely find trio (formerly curio) to be so thoughtfully designed at every turn; it's dispiriting that it never seemed to gain much of a user share over asyncio (whose main advantage appears to simply be inertia and stdlib privilege)

It's long been clear that there were fundamental implementation choices that mattered between async runtimes, but _nine_ design dimensions? Damn.

I think async is deceptive in that it seems like a self-contained and relatively straightforward aspect of a language. But there are many design choices to be made and they all have wide implications.

Plus I think the implications of many of these dimensions are not fully understood and that collectively we are still trying to understand how they are playing out in implementations. Add to this the subtle nature of some of the implications plus the combinations...

I think a good comparison is lexical vs dynamic scope in programming languages. This is a design dimension that was argued over for a decade or two in the early years of programming language design. It was only as time went by, and experience gained by working with concrete implementations that it became clear that lexical scoping should be the default choice and dynamic scoping should be restricted to various niches.

I was wondering "hopefully C++ allows you to pick across these axes so that you can build yourself the async primitives that work best for the problem at hand" and then: yes!

> We cannot attribute C++ to any particular design point in the taxonomy provided in Table 1 because each axis is configurable. Although elegant and neutral, the choice of full programmability makes each library an async dsl; knowledge transfer between projects within the same language becomes exceedingly difficult.

It is not if you think in terms of these axes and which solve your particular problem and not any particular specific design. Take for instance the simplest program one can imagine: a network video player. E.g. some server sends you RTP audio & video frames and you have to play them back correctly, with a nice GUI on top. If you want to do this in a way that is as efficient as possible you need to be aware of all possible ways of async interoperation:

- connecting & receiving packets from the network in a classic network state machine where coroutines shine

- handling vsync vs not-vsync for displaying the video frame

- conforming to whatever async paradigm the hardware video decoding system you want to use is going to provide you with, e.g. Intel QuickSync vs VideoToolbox vs NVDEC...

- handling the synchronous model of audio playback driven in pull mode

- handling the synchronisation between audio / video, and thus the async patterns that support multi-threading as your audio thread can't be your video or GUI thread

- handling the async model of your GUI library for your play / stop button's callbacks.

There's zero chance that a single async model fits all of these equally well without tradeoffs, so you have to have the knowledge anyways.

• bombela

  today at 2:24 AM

  Agree with your post except the adjective "simple" for a network video player.

  Decoding video/audio and talking to the right OS APIs and GPU is far from simple. It is reasonable to implement a http1 client from scratch by hand. For decoding, you need libraries/dependencies. And suddenly you have to find the intersection of dependencies that play nice in your async model of choice.

At last someone took the time to pore over all the tedious crap that I have been trying and failing to keep straight in my head since forever.

> You must be a JavaScript developer.

and i took that personally

The paper explores how async/await behaves across today's languages: https://arxiv.org/abs/2608.20677

I remember being so mad years ago, coming from a pure CS background, when it dawned on me that async await was “mere” control flow and not actual parallelism.

It’s why I feel go (with go routines being the norm) is one of the few imperative languages that was designed vs. filling out a bunch of historical constraints (apologies this is not meant to trigger a language debate, just an idiosyncratic thought)

• kccqzy

  today at 2:42 AM

  Being mere control flow is a good thing: some async/await implementations are just desugared into a state machine anyways, and it totally works on a single thread. Early async/await in Python was just a small generalization of its existing generator mechanism, and nobody would think generators in Python enables parallelism: it was always a control flow construct. This cleanly demonstrates the separation between the concepts of concurrency versus parallelism.

  And of course go routines and channels can also be desugared into mere control flow. That’s how ClojureScript does async.

• aw1621107

  today at 2:02 AM

  > vs. filling out a bunch of historical constraints

  Do you mind elaborating on this? I don't understand what you're trying to get at.

With these dimensions of design variance defined, you could also make a closeness measure in 9-dimensional space and identify the most or least similar combos.

Also a great teaching tool, if someone knows one async system, to be able to show them the differences on each axis from their prior one to a new one they’re learning.

I answered the quiz and it said "you must be a Javascript developer", which is true enough - that's probably my second-most-proficient language. In fact, I'm a Ruby developer partially because I hate the idea of async/await and I'm feeling very smug about my choice after reading this.

Some of these design decisions seem indefensible to me. For example, what the authors call "Suspension":

-> Static: Await points guaranteed to suspend -- JavaScript

-> Dynamic: No guarantees on awaiting tasks -- C# · Swift · Tokio · Smol · Asyncio · Trio

What is "await" if not a synonym for "suspend"?!?

async/await is one product of a long line of thought that says "threads are too hard for programmers to get right". Threads (really, shared memory) have real usability issues for developers, but once you grok the semantics (which largely map to the physical execution model in a CPU) that knowledge is transferrable across virtually all languages and runtimes.

• AdieuToLogic

  today at 2:37 AM

  > What is "await" if not a synonym for "suspend"?!?

  The `await` keyword in most languages is not a synonym for suspending thread execution so much as it is an effectual attempt to replicate the functionality of `coreturn`[0]. To wit, if an underlying `Future`/`Promise` has completed before the `await` instruction is evaluated, the thread executing same will not be suspended.

  0 - https://www.euclideanspace.com/maths/discrete/category/highe...

• toast0

  yesterday at 10:55 PM

  > async/await is one product of a long line of thought that says "threads are too hard for programmers to get right".

  Having used both threads and async/await and using them both in the same program, I don't see how async/await is supposed to make it easier to get right.

  In my experience, async/await seems to be a solution to avoid running too many threads. In Javascript, because you could only have one thread in browsers; in other languages because thread per X is too many threads and queuing to a thread pool might not be desirable either.

  Async/await always feels terrible to use though. Some other way to get thread like semantics without having to have OS threads for everything seems better (to me). Erlang processes, Java Loom Virtual Threads (which I haven't used), etc. If it avoids having all memory shared, even better.

  • jerf

    yesterday at 11:25 PM

    In the 1990s, threads were programmed with extensive use of semaphores and threads arbitrarily running around shared data structures. This is a disastrous approach to threading, and I agree with pretty much every scathing condemnation written about it.

    The problem is, the community collectively decided the problem was "threading" in general rather than "trying to have tons of threads running around shared data structures controlled via piles of simultaneously-held semaphores" specifically.

    If you don't structure your threads on that basis, but instead default to something that looks more like actors and message passing, even if it isn't strictly speaking actors and message passing, the complexity comes down. Add some later elaborations like structured concurrency and a few other pre-canned design patterns for threading like a parallel map or worker pools being issued work items and it becomes merely something difficult rather than insane. When you program with threads sanely, it takes very little for async/await to actually be the substantially more complicated and difficult-to-understand choice when you have a workflow more interesting than "always await everything immediately" to implement, to say nothing of how nice it is to have things actually running on multiple cores simultaneously without having to carefully arrange for it.

    • rerdavies

      today at 12:49 AM

      The principal difference between dispatching in a thread-based framework and async/await is that async/await allows you to program sequences of asynchronous operations much more easily. No more separation of code that initiates an async operation and the code that handles the result!

      • switchbak

        today at 2:42 AM

        These higher level primitives that they mention provide the primitives for exactly that. This can be found in other paradigms besides async/await.

        I do find that the ergonomics of this are highly dependent on a few features of a language runtime, without which it all falls apart. Or you need language specific syntax and typically a single standard implementation.

• nxc18

  yesterday at 10:23 PM

  > What is "await" if not a synonym for "suspend"?!?

  There are scenarios where something might need to await and might not. Why take the hit if you are able to do something synchronously? Edit: this is especially important given the “viral” nature of colored functions.

  It does make it hard to reason about, but this kind of problem is all over the place - e.g. very similar-looking code can have very different semantics depending on your framework if you’re using jsx or a particular decorator means one thing in one project and something else in another. That’s just part of the game at this point.

  • bmm6o

    yesterday at 10:35 PM

    C# has Task.FromResult(), which is useful if you are implementing an interface that allows async work but your implementation doesn't require it. I believe the runtime will check for this case and continue execution. It's better for the cache to keep executing the current task on the current thread.

    I don't really understand gp's point. From inside the code, you can't tell if there was a pause or not. Clock time or thread id are heuristics, but you can't really be sure.

• biorach

  yesterday at 10:16 PM

  > What is "await" if not a synonym for "suspend"?!?

  it's a question of whether the runtime is guaranteed to suspend at an await point or if it may choose not to

  > async/await is one product of a long line of thought that says "threads are too hard for programmers to get right".

  what? no! concurrency vs parallelism etc etc

• danilocesar

  yesterday at 10:20 PM

  I'm teaching async calls in makearcade to my 10yo son, to bypass a platform bug. He said he doesn't get it. My answer was: Don't worry, adults don't get it either.

C# is my primary, but the quiz tells me I'm a JS dev.

Feel like I should assign myself a couple dozen Jon Skeet posts to read now, to make up for this embarrassment.

• jameshart

  today at 1:16 AM

  To be fair to yourself, the fact that C# terminates pending tasks when the main method exits is something most C# devs don’t have to deal with because they’re mostly working in the context of long running servers and apps.

Amazing work. It's one thing to say "async is complex". It's another to parse that statement so carefully as to have a cross-language theory of async execution. Looking forward to digging into this!

It would be a fun coding agent benchmark to have them translate such a program between the different languages and see whether they preserve the respective semantics.

Love it. I wish it included zig.

• ameliaquining

  today at 1:37 AM

  Zig doesn't currently have async/await in the sense that this post is about (i.e., async/await based on stackless coroutines). It previously had this, but it was removed last year (https://ziglang.org/download/0.15.1/release-notes.html#async...).

  The 0.16 release earlier this year introduced a much-heralded userland API (https://ziglang.org/documentation/master/std/#std.Io) that can be used to implement various asynchrony and concurrency patterns, including green threads, but it can't do stackless coroutines because support for those has to be baked into the compiler.

  There is currently an open proposal to bring back stackless coroutines without dedicated syntax (instead offering low-level bring-your-own-buffer APIs for interacting with suspended coroutines), which could be combined with the aforementioned userland API to produce something more like how async/await works in other languages (https://github.com/ziglang/zig/issues/23446).

Great work. Must read for anyone working with this type of concurrency.

Maybe it’s cuz I started with async/await instead of threads but I cannot relate to people saying it’s harder than threading. To me it’s substantially easier to understand than threads, goroutines, or structured concurrency in Kotlin.

or, Java Virtual Threads and chill.

• biorach

  yesterday at 10:52 PM

  No. Because concurrency vs parallelism

  • MichaelNolan

    today at 12:34 AM

    How does parallelism come into play for this conversation? Async/await is a concurrency construct. And Java’s virtual threads are also a concurrency construct. Neither of them have anything to do with parallelism. Or am I misunderstanding something?

>You must be a C#, Swift, Asyncio, or Tokio developer — hard to narrow down, you all agree on this one.

I think that's definitely right. Knowing the semantics of the language you mainly use is important.

Beautiful

Nine dimensions proves it: async isn't a feature, it's a set of tradeoffs. C++ configurable on all of them is why every codebase reinvents its own semantics.

• switchbak

  today at 2:46 AM

  Why do people bother with this llm stuff? Is it to mine the karma system? It’s so obvious and clearly dumb, I don’t understand the point otherwise.