Jonathan is a Software Engineer at LSEG. There he develops low-latency market data feed handlers in C++ for high-frequency trading applications. Previously, he maintained think-cell’s core C++ libraries built around a custom range implementation.
He is also the chair of the std::ranges study group in the C++ standardization committee, a frequent speaker at conferences and universities, and the author of multiple open-source C++ libraries.
Functional programming is all about composing functions. If the output of one and the input of the other line up exactly, that's trivial. If they don't, you need some way to apply a function over some sort of structure data in the way you want. Monads are one way you can do that, but just like there are many different kinds of structures, there are also many different ways to compose functions. In this talk, we'll look at the more obscure functional composition patterns and cover applicatives, alternatives, traversables, and many more. We'll talk about the different ways you can […]
max is a function that returns the maximum of two numbers. While it seems simple on the surface, there are some nuances if you want to make max fully generic. For starters, what is max(-1, 1u) or max(lvalue, prvalue)?Let's go on a journey of overengineering max. We'll implement better mixed comparison functions, discuss common types and common references, wish for time machines to correct language semantics, and end up implementing Rust-style lifetime annotations using template metaprogramming and lots and lots of macros. The end result is a true work of art that we may or may not be using in […]
Iterators and ranges have been essential parts of the C++ standard library since its inception. With C++20, they were brought to the next level in the form of `std::ranges`: We now have formalized requirements on the algorithms, lazy views to enable pipelines, and much more powerful iterators. Since then, more and more views and algorithms have been added in C++23. However, the fundamental concepts have mostly been left unchanged, even though there are still some rough edges. This talk explores new kinds of ranges that are not possible with the existing C++ range concepts. We will first look at compile-time-sized, […]
A C++ program manipulate objects, but it is undefined behavior if you attempt to manipulate them while they are not alive. So let's do a deep dive into object lifetime. When are objects created and when are they destroyed? How does temporary lifetime extension come into play and what changed there recently? What happens when you std::malloc memory and just pretend objects are there without creating anything? Or worse: You use mmap() to read shared memory. How do unions interact with constructors, strict aliasing, or the "common initial sequence"? What when you explicitly call the destructor and later re-use the […]
We have given many conceptual talks about iterators, ranges, string formatting, and generic programming in the past. Now, we would like to present the library that is the foundation of our code base and that lets us write code the way we like it: Short, elegant, and to the point. Did you know that std::move can be called on a const reference? And that you cannot move out of that const reference but will silently copy? Wouldn't it be nice to get a compiler error in that case? Our range implementation is more powerful and easier to use than std::ranges. […]
At the core of an interpreter is a loop that iterates over instructions and executes them in order. This requires dispatching: based on the current instruction it needs to select different code. A fast interpreter requires a fast instruction dispatcher, but so does everything else that needs to switch over a fixed set of different options. This talk investigates at various dispatching techniques, from simple switch statements to jump tables. We'll look at performance analysis tools, benchmarks, and lots and lots of assembly code, in order to learn ways to trick the compiler into generating the assembly code that we […]