Title
A Unifying Abstraction for Async in C++
Abstract
Async in C++ is in a sad state. The standard tools — promises, futures, threads,
locks, and std::async — are either inefficient, broken, or both. Even worse,
there is no standard way to say _where_ work should happen. Parallel algorithms,
heterogeneous computing, networking & IO, reactive streams, and more: all
critically important foundational technologies that await a standard abstraction
for asynchronous computation.
In this talk, Eric Niebler digs into the Standard Committee’s search for the
basis operations that underpin all asynchronous computation: the long-sought
Executor concept. The latest iteration of Executors is based on the
Sender/Receiver programming model, which provides a generalization of many
existing paradigms in asynchronous programming, including future/promise,
message passing, continuation passing, channels, and the observer pattern from
reactive programming. It also has surprising and deep connections to coroutines,
which further demonstrates the model’s potential to be a truly unifying
abstraction for asynchronous programming in C++20 and beyond.
Eric will present the short-term and long-term directions for Executors in ISO
Standard C++, illustrating the design by walking through several implementation
examples. They will talk about the direct connection between coroutines and the
Sender/Receiver model and discuss what it means for the future of asynchronous
APIs in C++. Finally, he will cover how the restrictions imposed by the
Executors model should affect the way you write code today so your code is ready
for the next big revolution in parallel and concurrent C++ programming.
-- https://nwcpp.org/
---
Eric has worked with Andrei and I in the early days of D. He's one of the top
C++ people in the world, and it is well worth coming to hear him speak. Besides,
most importantly, we go out for a beer afterwards!
Come join us, it'll be fun!
