November Twofer - smarter exceptions, parallel directions

​The November Haifa::C++ meetup will take place on Thursday, 20/11, at Matam's Tech&Talk venue. And this time, we have a twofer! First, Erez Strauss will introduce a new approach to exception handling using C++23 std::stacktrace, making debugging faster and easier without code changes. Then, Eran Gilad will explain how serial C++ can be parallel too using SIMD operations and memory-level parallelism.

Agenda
17:30 - Gathering and mingling @ Tech&Talk
18:00 - Enhancing exception handling and debugging using C++23 std::stacktrace by Erez Strauss
18:30 - Serial C++ can be parallel too by Eran Gilad
19:00 - Wrap-up and mingling

Exception handling talk abstract
This talk explores a novel approach to exception handling and debugging in C++23, introducing a method to capture the full stacktrace at the throw statement with minimal overhead and no code changes. By providing developers with clear insights into who threw an exception and why, this approach simplifies debugging and enhances code visibility. We will discuss the challenges of capturing stacktrace information from the throw location, techniques for differentiating between error handling and flow-control exceptions, and per-thread control over stacktrace capture. The talk also covers integration with the C++23 \ header, adaptation for both development and production environments, and the use of a shared library (as an LD_PRELOAD module) to extend these capabilities to external libraries, including benefits for asynchronous programming with coroutines.
A more detailed abstract is available here - https://cppcon2025.sched.com/event/27bOE

Serial C++ can be parallel talk abstract
In this talk, we will see how serial C++ can utilize hardware parallelism. We will begin with SIMD (Single Instruction, Multiple Data), where one instruction processes a whole batch of values at once. The path will run from hand-written vectorized assembly, to compiler intrinsics, to C++26 std::simd, and finally to auto-parallelization, with examples of what works, what doesn’t, and how to verify the compiler’s choices. We will see why SIMD shines in structured compute-bound code, and why it sometimes falls short.

We will then broaden the scope to memory-level parallelism (MLP) - a hardware feature that overlaps multiple independent memory accesses to reduce overall latency. We will discuss how to take advantage of MLP in C++ through bulk operations and APIs, and show how this approach can bring substantial benefits even in less structured code with irregular memory access patterns.

Erez Strauss bio
Erez Strauss is a senior software engineer at Eisler Capital. Erez has worked in various banks and hedge funds, focusing on low latency systems.

Eran Gilad bio
Eran Gilad is a software engineer at Regatta Data, where he works on one of the most fascinating areas of software development: database internals. Eran is the co-organizer of the Haifa::C++ meetup group, the co-organizer of the Core C++ conference, and the creator of the Medabrim C++ WhatsApp group.