A Design Space Exploration of Async/Await

Modern programming languages universally embrace async/await to simplify concurrent programming by making it resemble straight-line code. However, as this paper (and blog post) reveals, the specific semantics and behaviors of async/await differ dramatically across languages, leading to unexpected outcomes for even basic examples.

The authors highlight this divergence with a pseudocode example where a 'fire-and-forget' background task yields four different outputs across seven modern async runtimes, and crucially, no two runtimes produce identical results for variations of the program. To demystify these discrepancies, the paper introduces a framework of nine 'design dimensions'—such as 'Eagerness' (hot vs. cold start), 'Extent' (task lifetime), and 'Destruction' (cleanup)—that categorize the fundamental choices made by language designers.

Key takeaways include:

• A simple background task can behave entirely differently depending on the language's specific async/await implementation.
• Nine distinct design dimensions, grouped by task lifetime (Start of Life, End of Life, Cancellation), govern these semantic variations.
• Choices like 'Dynamic Extent' (tasks cannot outlive their spawning scope) combined with different 'Destruction' methods (e.g., Cancelled vs. Awaited) explain behavioral differences, such as why Swift prints "AC" while Python+Trio prints "ABC" for the example.
• Each design choice involves trade-offs in performance, memory, and ergonomics, emphasizing that there's no single 'right' answer.
• The research translates this design space into a formal semantics, allowing for precise modeling and explanation of execution traces.

This work provides an invaluable map for navigating the complex and often counter-intuitive landscape of async/await implementations, offering clarity to developers and language designers alike.