Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After spending 4.5 years in full stack web development he pivoted to financial infrastructure in late 2016 whereafter he spent nearly nine years at a start up working on next generation financial market data storage and retrieval mechanisms. In 2019 he became involved in the ISO C++ committee with a particular focus on library evolution. Since summer 2025 he has worked as a core developer at Hudson River Trading.
Asynchronous I/O in C++ has traditionally focused on performing operations such as reads and writes, while the acquisition and release of resources remain fundamentally synchronous. This mismatch becomes increasingly problematic as lower-level mechanisms, such as io_uring, make even the close syscall asynchronous. While asynchronous functions are well supported by std::execution, C++’s object model remains rooted in synchronous construction and destruction: Constructors and destructors cannot suspend. This raises a fundamental question: How can the deterministic cleanup central to modern C++ be expressed when it may require asynchronous work? This talk explores a model for asynchronous lifetime management based on scopes. By […]
Asynchronous I/O in C++ is typically expressed as high-level operations such as reads and writes, while their implementations are hidden behind a library or framework. This separation introduces both conceptual and performance overheads. The structure of the implementation may differ from the structure of the API, and the API itself may impose intrinsic performance pessimization. This talk explores an alternative: High-level operations which are the same in form as the lower-level operations they are implemented in terms of. Using io_uring as a motivating example, it walks through the implementation of low-level primitives directly in std::execution, which can then be composed […]
P2300 introduces `std::execution` and the Senders & Receivers (S&R) model as a new paradigm for expressing asynchronous computation. `std::execution` specifies a fixed set of algorithms that, in some sense, define the baseline DSL of S&R, but this set is not exhaustive. Extending it to cover new use cases is possible, but the standard provides no guide to doing so, because the standard is not a guide. This talk will detail the process of adding a new S&R algorithm by examining the implementation of `when_all_range`, a variation of `when_all` which is part of `std::execution`. Through this example, the audience will see […]
Library design used to seem easy: Model the problem domain with classes which sometimes inherit from one another, throw in a few free functions, and you’re done. Modern library design is unrecognizable from that frame of reference: Customization point objects, expression equivalence, perfect forwarding, a seemingly-endless list of edge cases and sharp edges understood only by experts. This journey from simple to complicated didn’t occur without reason. Putting complexity into libraries transfers that complexity into a single place where it can be dealt with once. Improving genericity by considering and handling edge cases and seemingly-obscure use cases furthers the concentration […]