







If you expected std::async to be just syntactic sugar over thread creation, you can stop reading right now, because that’s what it is. If you expected more, read on. Don’t get me wrong,…
async/await: It’s Good and Bad
This might be controversial, as most people I know are huge fans of async/await. If you’re not familiar, it’s this nifty little syntax…

397 - Challenges with async/await in the control plane | RFD | Oxide
Very early in the development of the control plane, we considered whether to build our big new distributed system using Rust’s async/await or more traditional synchronous threaded code. [RFD 79] discussed this issue and came to the weak conclusion to prefer async/await, in no small part because much of the ecosystem we wanted to use (e.g., low-level http crates) was already async and seemed to be moving further in that direction, and we’d already written some async code.
A tutorial on modern multithreading and concurrency in C++
Multithreading and concurrency skills are important for solving complex problems. Here, we'll get you familiar with these conepts in C++.
Async from scratch 1: What's in a Future, anyway? | natkr's ramblings
There are a lot of guides about how to use async Rust from a "user's perspective", but I think it's also worth understanding how it works, what those async blocks actually mean. Why you get all those weird pinning errors.
Async: What is blocking? – Alice Ryhl
The async/await feature in Rust is implemented using a mechanism known as cooperative scheduling, and this has some important consequences for people who write asynchronous Rust code.
A Design Space Exploration of Async/Await
Many modern programming languages include some form of asynchronous programming. In particular, a growing number now have what we call straight-line asynchrony: attempts to provide asynchronous functions that look similar to synchronous functions, thereby enabling asynchrony without introducing complex control. These languages often share construct names like "async" and "await," which suggests that they have deep semantic similarities. Yet, a close examination reveals that these languages are quite different along several dimensions, often subtly. These differences have real semantic consequences: similar-looking programs can exhibit divergent behavior, confusing developers and language designers alike. This paper therefore presents a design space exploration of straight-line asynchrony. We dissect several existing languages, and show how no two of them agree as a whole on design decisions that affect the presence and ordering of execution. We articulate a design space with nine dimensions covering the full lifecycle of an asynchronous computation, covering questions such as: What precise guarantees does a language give upon calling an asynchronous function? What happens at the end of a task's life? How can a task handle being cancelled? We explore these questions through concrete examples, informal design discussion, and a formal semantics. Our ultimate goal is to help programmers, language designers, and language theorists all better understand the emerging landscape of straight-line asynchrony.

Building a mental model for async programs
In my experience writing async programs in Dart and Rust, I have built up a model in my head to avoid bugs caused by async. These bugs are usually hard to find and reproduce, so there is a lot of value in taking preventive measures to avoid them. I hope to improve this model in my head by writing this post and to share them with anyone who might find it helpful.
Composing Time: Compositional Async in Solid 2.0
Async/await on the GPU
GPU code can now use Rust's async/await. We share the reasons why and what this unlocks for GPU programming.
Async/await on the GPU
GPU code can now use Rust's async/await. We share the reasons why and what this unlocks for GPU programming.
Concurrency is not Parallelism by Rob Pike
using C++ to exploit the C++ that is building the C++
today you’re going to segfault your compiler.

Fucking Approachable Swift Concurrency
A no-bullshit guide to Swift concurrency. Learn async/await, actors, Sendable, and MainActor with simple mental models. No jargon, just clear explanations.

C Is Not a Low-level Language: Your computer is not a fast PDP-11.: Queue: Vol 16, No 2
In the wake of the recent Meltdown and Spectre vulnerabilities, it’s worth spending some time looking at root causes. Both of these vulnerabilities involved processors speculatively executing instructions past some kind of access check and allowing the ...
