Name: November Twofer - smarter exceptions, parallel directions
Start: 2025-11-20T17:30:00+02:00
End: 2025-11-20T19:00:00+02:00
Location: Tech&Talk MATAM

​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](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.

Eran Gilad

Alex Dathskovsky

Haifa::C++

Technology

Concurrent Programming

Software Development

Programming Languages

Computer Programming

C & C++

New Technology

Open Source

High Performance Computing

Low-Latency

Embedded Systems

Real-Time

November Twofer - smarter exceptions, parallel directions

Parallel Programming

Tech&Talk MATAM

Share

Haifa::C++

November Twofer - smarter exceptions, parallel directions

Haifa::C++

Details

Members are also interested in