Speakers

Typing++ for C++ - Making the Compiler Do the Thinking

C++ lets us write powerful systems-and equally powerful bugs. Its weak typing gives us freedom, but not always safety.

In this talk I'll argue that typing not a computing concept, but a linguistic one. By designing expressive types-from basic ints to rich class structures-we can shift from "I think this is right" to "I know this is right," catching errors at compile time instead of runtime.

Expect practical examples, a few missteps (mine, mostly), and techniques to make your compiler a partner in correctness-not just a passive syntax checker.

Parallel Paths: From SIMD Lanes to Memory Highways in C++

In this talk, we will take a journey through two complementary ways to utilize hardware parallelism in C++. 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 libraries, 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.

C++ Contracts – a Meaningfully Viable Product

After 2 full decades of multiple efforts aimed at introducing a contracts feature into the C++ language, contracts have finally been voted into C++26 at the February 2026 C++ Standards Committee (WG21) meeting in Hagenberg, Austria. To be more precise – confirmation into the standard was given to the Contracts MVP – Minimal Viable Product. This talk will bring you the highlights of the MVP and if time allows also some forecasted features beyond it. We will shift our focus away from the theoretical background behind contracts and more into some select minutiae and pitfalls encountered along the tortuous process of developing this MVP, while also inspecting the most important things future contracts users should be aware of. And you can also expect some am(a/u)sement along the way!

Code Smarter: Harnessing AI tools for C++ Development

AI is everywhere. But how can we use it to make an impact?

In this talk, we'll dive into how AI tools are changing the game for C++ developers. Drawing from real-world deployment experience within Microsoft, I’ll introduce you to a framework developed to rigorously analyze AI tools, and introduce practical use cases, unexpected challenges, and their applicability to C++ workflows.

During the talk we’ll explore and get familiar with the latest available tools. We’ll also address limitations, best practices, and learn how to integrate these tools into production-level development environments.

Whether you're skeptical or excited, this session will leave you with a grounded understanding of where AI tooling stands today, what it can (and can't) do for your C++ projects, and how to prepare for the next wave of innovation.

Who's Afraid of the Big Bad Template?

Many C++ developers can spend years, sometimes even a decade, without ever touching templates. In some workplaces, templates are even forbidden, treated as a dangerous curse requiring rare expertise.

This fun talk takes that “terrifying” subject and shows that templates are not as scary as they seem, and can even become your friend. We’ll start with something seemingly intimidating like NTTPs (Non-Type Template Parameters) and slowly dive into more “monstrous” code examples. Step by step, every piece will be broken down and explained in detail, turning fear into understanding.

This talk has only one requirement for attendance: a smile, so bring one with you :)

We got reflection - now what?

C++26 introduces new reflection capabilities into the language. In this talk we will explore some of the things that we can already do with these new capabilities, as well as some future enhancements that might prove useful.

Hiring in the age of LLMs

The rise of large language models in recent years is having a big impact on our everyday lives as developers - and that includes the hiring process. In this talk we will explore what are the qualities that are (or should) be looked for in a candidate today, and we can test and demonstrate them.

C++ Pitfalls and Sharp Edges to Avoid

C++ is a powerful language, but with great power comes… plenty of pitfalls. Memory management quirks (even when using smart pointers), subtle undefined behaviors, and bug-prone code can silently introduce dangerous behaviors, only to surface at the worst possible moment in production. In this talk, we’ll explore some notorious C++ real life pitfalls and sharp edges, discussing strategies to avoid them and write safer, more resilient code.

Refactoring towards Structured Concurrency

The addition of "Senders and Receivers" (a.k.a execution) to C++26 is a nudge for C++ practitioners to consider utilizing Structured Concurrency princinples when designing and implementing concurrent systems. Structured Concurrency is a well reasoned methodology, described by various C++ experts in the past, focused on composability, wide applicability, error tollerance and on correct fit with the rest of the language, most notably C++20 coroutines. The challenge that we'll face in this talk is that of taking existing concurrent and systems which were not originally designed with Structured Concurrency in mind, and making the gradual changes towards that design and towards more natural use of senders, receivers and coroutines. Join me in a tour of various techniques and tips for modernizing legacy concurrent systems, as we prepare for adopting the C++26 standard.

Managing dependencies with CMake

As modern C++ projects grow in complexity, effective dependency management becomes essential for maintaining code quality and ensuring seamless integration of external libraries.

We will explore various strategies for defining, locating, and linking dependencies within CMake. Attendees will gain insights into best practices for organizing dependencies.

We will highlight common pitfalls and provide solutions to streamline the dependency management process. By the end of the session, participants will be equipped with the knowledge and tools to effectively manage dependencies in their CMake-based projects, leading to improved build reliability and enhanced collaboration within development teams.

Welcome to the Museum of AI Hallucinations

We are going to explore the surprising creative potential of AI hallucinations in generative AI models like DALL-E. While typically viewed as flaws in deep learning, these "errors" can produce unexpected artistic brilliance. By comparing human imagination with AI’s pattern-based logic, the piece questions whether AI's falsehoods might actually be a new kind of creativity. It challenges how we define truth, error and inspiration in the age of artificial intelligence.

C++26 Contracts: Pitfalls to Watch

In this talk I'll describe a few already-known pitfalls in the new C++26 feature named contracts.

While the Contract facility gives a good way to find bugs, still it bears a few already known pitfalls. The talk shows theoretical alongside practical pitfalls when using contracts. All examples in the talk are taken from existing compiler implementations and exiting code which is open sourced and can be further investigated by the audience.

Disaggregated memory with the advent of low latency fabrics

Memory remains the last piece of hardware that cannot be scaled on-demand. Researchers and practitioners alike have been chasing the idea of disaggregated memory but no practical solution was possible until the recent introduction of the memory fabric protocols such as CAPI, CCIX, and CXL. A new era is beginning in which shared memory with hardware coherency is on the horizon. This is a game changer that has been anticipated for decades but only recently became possible.

The new technology impacts the whole software stack from operating systems to APIs and applications. I describe some of the exciting features that can now be implemented and outline the main issues that must be addressed before the dream can be fully realized.

C++20 Ranges for Beginners

C++20’s ranges library brings a fresh, expressive way to work with sequences, letting you write declarative and efficient code. If you already know what an iterator is and have used std::vector and std::for_each, or similar, you’re ready to level up.

In this session, we’ll explore the “plain vanilla” of ranges: what's new compared to the traditional iterator-based algorithms, how views enable elegant data transformations without unnecessary copies, and how to compose operations in a clean, pipeline-like style. The talk is aimed for beginners and will focus on the simple scenarios, no deep dives into obscure corners or tricky pitfalls, just the core ideas you need, to start using ranges effectively and with confidence.

Order! Order!

Atomics give us a somewhat clear API for concurrency-safe shared values. But how does the hardware work? Are there any other things we should be wary of? How can we--as C++ enthusiasts--use concurrency safely?

Are there Time-Bombs in your Realtime Code?

Synchronizing tasks and actions on realtime, and especially Hard-RT systems, is crucial. On the other hand, time constraints, together with limited resources, make programmers sweat trying not to waste a single unnecessary processor cycle.

Here comes a problem: most of the RT-Embedded programmers are not just any programmers. They know more about memory, CPUs, buses, OS, I/O, especially those they are working with. And they try to harness this knowledge to their efforts.

Careful crafting of the mechanisms might indeed serve the goal and keep the system within boundaries. Sometimes, however, trying to find clever and lightweight solutions might lead to a broken system. In other cases, the code might perfectly work at the moment, but be very fragile so that future changes might break it in a way that the programmer might miss. And synchronization problems are the nastiest of them all: they pretend to be nice and sweet when you test them, and only love to explode in production.

In this talk, we will go over common real-world RT synchronization practices that might put the current or future code in danger.

Coroutines 101

In this talk we will introduce coroutines. What they are, what they're not, and how to use them.

We wil go over why use coroutines: * Co-operative scheduling: You have control when to work and when to yield * No locking necessary * Each co-routing has its own natural control flow - no state machine needed

And show some example use-cases: * Real-time calculation (e.g., in games, mathematics libraries) * Co-operative multitasking, e.g., in a web server * Generators (e.g., infinite lists)

And have some real code examples.

When the Structs Align ... and When They Don't

Compilers like objects in memory to be aligned, and may even add padding to make it so. But why? And what happens if your objects are not aligned? And if aligning is so good, maybe we should add more? In this talk we'll discuss the rules of alignment and the relevant tools C++ provides, what happens if you break alignment rules and how to make sure your code always stays on the safe side. ABI will be mentioned and briefly discussed, as well as other relevant C++ topics. We will even encounter a curious connection of alignment rules with musical notation. Join us for a journey that will, hopefully, end with all structs aligned.

Order! Order!

Atomics give us a somewhat clear API for concurrency-safe shared values. But how does the hardware work? Are there any other things we should be wary of? How can we--as C++ enthusiasts--use concurrency safely?

The effects of C++ evolvement on Design Patterns

The book Design Patterns: Elements of Reusable Object-Oriented Software by the "Gang of Four" is regarded as one of the important sources for object-oriented design theory. However, since it was published in the 1990s C++ language has evolved, and the code samples given in the book looks outdated from a modern C++ perspective. In this presentation, I'll go through the most useful patterns and show the effects of various features of C++ language versions. Ranging from small features that make your code more readable and maintainable, to total code rewrites that keeps the original patterns.

AI Close Encounters of the Third Kind

"AI can write code for you" has become a ubiquitous claim in today's tech landscape. But how does this promise hold up in practice?

This presentation examines real-world encounters with AI chatbots in coding scenarios, exploring curious phenomena including emojis, flattery, SOOP, and other surprising, sometimes amusing, patterns in AI-generated code. Drawing from these practical encounters, I'll present key findings about the current state of AI-assisted programming and what these interactions reveal about both the capabilities and quirks of today's coding AI systems.

Less Boilerplate, More Business Logic – Features in 20/23 that makes our code better

For years, writing C++ code has often required hundreds of lines of boilerplate—templates, definitions, and technical syntax—just to express the core business logic. However, recent innovations in C++20 and C++23 are transforming the landscape. Features like the Ranges library, designated initializers, extended constexpr, deducing this, and std::expected finally allow developers to focus on what their code does, not on the mechanics of getting it to compile. This talk will explore how these modern C++ features significantly reduce boilerplate, enabling more efficient and concise code. We will demonstrate how to refactor legacy code, showcasing how the transition to a more expressive and modern language improves readability, reduces bugs, and ultimately saves valuable development time.

Abstraction Addiction: When Good C++ Design Goes Bad

As software developers we love elegant code. We use templates, polymorphism and type erasure; We slice and dice our classes to maintain SRP (Single Responsibility Principle) and we generalize for every conceivable future scenario. We are responsible engineers after all and we most definitely know what’s coming, so naturally we lay the groundwork, sometimes for things that won’t happen until the heat death of the universe.

I’m guessing you’ve all been there: you dive into a codebase and suddenly it’s less “reading code” and more “archeological expedition”. You’re carefully brushing away layers of inheritance and indirection to figure out what a function actually does, who implemented it, and on particularly fun days trying to guess which one of the three different implementations is actually called at runtime.

In this talk I’ll play devil’s advocate to ask “Do we really need all of this?”. We’ll examine examples inspired by real-world C++ code where well-intentioned design using language features such as inheritance hierarchies, deep template metaprogramming and generalized abstractions ended up adding more friction than flexibility.

Attendees will leave with a handy checklist to help spot over-engineered designs and strategy suggestions for balancing flexibility with maintainability in modern C++.

Whether you’ve inherited a complex legacy codebase or built one yourself, this session will give you tools (and cautionary tales) to keep your future codebase clean, clear and kind to whoever comes next – including you.

(Intel)ligent Verification: Applying AI to Tame Microprocessor Complexity

In modern microprocessor R&D cycle, verification teams face a relentless challenge: exploding design complexity, shrinking schedules, and ever-tighter compute budgets.

This talk reveals how Intel’s verification organization integrates AI-driven tooling into the heart of the verification cycle - boosting efficiency and quality.

This presentation showcases how classic AI tools developed at Intel enhance four key areas of the verification cycle: 1. optimizing gating tests for specific branches 2. improving weekly regression coverage within strict compute budgets 3. targeting failure clusters through intelligent stimuli generation 4. reproducing rare failures by tracking historically-hit but currently-missed behaviors

C++23 Tools you will actually use

Last year, we explored why C++20 is not just a “future standard,” but a powerful and practical tool you should already be using. If you haven’t adopted it yet, now’s the time.

But the C++ journey doesn’t stop there—C++23 is here, it’s maturing, and it’s packed with new features that deserve your attention. In this session, we’ll explore the most practical, accessible, and impactful additions in C++23—features that you can actually start using, not just in toy projects but in real-world codebases.

We’ll compare C++23 to its predecessors, highlight key language and library improvements, and see how these tools can simplify your development, improve readability, and bring more joy to modern C++.

Whether you're already deep in C++20 or still catching up, this talk will help you chart your course into C++23 with confidence and clarity.

From GPU Bottlenecks to Smooth Chat: Cost-Efficient Architectures for LLM Inference

What does it take to serve a chatbot with billions of parameters in real time - without burning a hole in your data-center budget? Large Language Models (LLMs) are powering the next wave of AI applications but serving them efficiently at scale brings unique performance and cost challenges. This talk offers a systems-level look at the main bottlenecks in LLM inference, from GPU memory limits to inter-node communication, and the architectural innovations addressing them.

We’ll cover three key techniques: KV-cache offloading to relieve GPU pressure, prefill-decode disaggregation to boost throughput, and speculative decoding to speed generation in inference engines like vLLM and SGLang. We’ll also explore the tradeoffs between user experience and system efficiency, such as latency versus hardware utilization.

While often implemented in Python and CUDA, these performance principles: memory hierarchy awareness, data movement optimization, and throughput–latency balancing, are directly relevant to C++ developers building high-performance systems.

Adventures with Bazel

Key Takeaways from the Transition to the Bazel Build System at Mobileye.

Lock me up, Scotty!

Mutual exclusion (mutex) locks are among the most common building blocks in multi-threaded programming. While building concurrent systems, we don't often consider how they actually work - but sometimes there are big gains to be had by looking under the covers.

At Fireblocks, we recently had the opportunity to unlock major performance improvements by designing our own locking primitive optimized for the unique constraints of the Intel(R) SGX environment. This talk will cover why and how we did this, and will give you an idea of when such a project could make sense for you.

Lock me up, Scotty!

Mutual exclusion (mutex) locks are among the most common building blocks in multi-threaded programming. While building concurrent systems, we don't often consider how they actually work - but sometimes there are big gains to be had by looking under the covers.

At Fireblocks, we recently had the opportunity to unlock major performance improvements by designing our own locking primitive optimized for the unique constraints of the Intel(R) SGX environment. This talk will cover why and how we did this, and will give you an idea of when such a project could make sense for you.

C++ in Early Boot

We all know C++ can be used everywhere? It can go as low level as assembly and as high level as pythonic pseudocode. But how does it bode with early boot code of embedded systems?

Virtual Table Security: Basic Exploitation and Protection with CTF Example

This beginner-friendly presentation introduces virtual table vulnerabilities in C++ through a practical CTF challenge walkthrough. We explore how virtual function calls work in memory, demonstrate a real CTF problem involving vtable corruption, and show basic protection methods. The talk covers step-by-step exploitation of a vulnerable program, explains how attackers redirect virtual function calls, and demonstrates modern defensive techniques. Attendees will learn fundamental security concepts through a hands-on CTF example without requiring prior exploitation experience.

const correctly in C++

Const-correctness is one of the basic features of C++. It can make your interfaces safer, your intent clearer, and your code more maintainable.

We start with the fundamentals: top- and low-level const on variables and pointers — then explore how const applies to member functions, parameters, and interfaces. Along the way we’ll discuss when (and when not) to reach for const_cast, and show how tools like mutable and std::experimental::propagate_const can improve real-world APIs.

By the end of this short, beginner-friendly session you will have a clear mental model of “const-correctness” and concrete rules to apply in your own code.