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.
Chris Gearing
I’m a Principle Software Engineer at Mobileye who prefers the quiet satisfaction of solving problems through well-crafted code. I gravitate toward C++, where I enjoy the challenge of designing systems that are both expressive and maintainable. I take a certain pride in writing code that improves with age—becoming more malleable, less brittle, and ideally, less surprising.
These days, I spend more time trying to help others appreciate software as a form of engineering with artistic undertones. When done thoughtfully, it’s both powerful and rewarding—though “thoughtfully” is a vague term that defies precise definition, which is probably why I keep revisiting it.
When I’m not writing or refactoring code, I’m often on a motorcycle, enjoying the kind of speed that doesn’t involve a compiler.
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.
Eran Gilad
Eran Gilad is a software engineer at Regatta Data, where he works on one of the most fascinating areas of software development: database internals. Before diving deep into database engineering, Eran was a principal research engineer at Yahoo Research and a member of a systems research group. He holds a PhD in Computer Science from the Technion, where his work centered on various aspects of parallel programming and execution.
Beyond his professional work, Eran is passionate about developer communities. He co-organizes the Core C++ conference, the Haifa::C++ meetup group, and the Medabrim C++ WhatsApp group. His involvement in these communities stems from his first job experience, where he was the sole C++ developer at his company for several years.
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!
Andrei Zissu
Andrei Zissu is a veteran cross-industry C++ developer, notably having worked on low-level reverse engineering systems employing API hooking, DLL injection and other advanced techniques. Andrei is currently Windows Software Developer Tech Lead at Morphisec, an Israeli anti-ransomware provider utilizing bleeding edge Automated Moving Target Defense technology. In early 2022 Andrei joined the WG21 standards committee, where he has since been an active member in SG21 (the WG21 Contracts Subgroup) in its efforts to produce a Contracts MVP in time for C++26, and has also closely followed reflection progress into C++26./p>
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.
Inbal Levi
Inbal Levi is a Lead Software Engineer with an interest in code readability, compilers, language and software design. She is an active member of the ISO C++ Standards Committee as Library Evolution Work Group Chair, and as the ISO C++ Israeli NB Chair.
Inbal is also a director at ISO C++ Foundation and the Boost Foundation and puts effort into evolving both the local and international C++ communities, as an organizer of the CoreC++ conference and meetup group, and as the program chair of C++Now.
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 :)
Coral Kashri
A passionate C++ developer, author of C++Senioreas blog, and an active member of the ISO C++ committee.
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.
Noam Weiss
Working with C++ for over two decades. Still excited about a brilliant code.
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.
Amir Kirsh
Amir Kirsh is a C++ lecturer at the Academic College of Tel-Aviv-Yaffo and Tel-Aviv University, previously the Chief Programmer at Comverse, after being CTO and VP R&D at a startup acquired by Comverse. Amir is also co-organizer of the annual Core C++ conference and the Core C++ meetup group.
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.
Roi Barkan
Professional software developer and architect since 2000, Roi's main focus throughout his career was on high performance and distributed systems, implementing complex and innovative algorithms. Roi is the SVP technologies of Istra Research, where he helps creating low latency financial systems. Prior to working for Istra Research, Roi spent 12 years in software development, architecture and management in the IT Security field. Roi received his B.A in Computer Science with high honors from the Technion in Israel, and his executive MBA from Tel Aviv University.
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.
Alex Kushnir
Alex Kushnir, principal software engineer with Johnson & Johnson MedTech. Experienced in embedded software development, with focus on software infrastructures, tools and methodologies.
B.Sc. in Electronics and Computer engineering
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.
Maria Piterberg
Team lead at Habana Labs (an Intel company), specializing in AI training Runtime for custom accelerators (https://www.intel.com/content/www/us/en/products/details/processors/ai-accelerators/gaudi.html). An expert in large-scale deep learning infrastructure, including memory management, graph execution, and synchronization. Experienced in distributed training and communication libraries such as HCCL, deep technical background in performance optimization. Bachelor of Science in Computer Science. Semi-professional artist in digital and classic art.
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.
Ran Regev
Software and C++ Developer in the last 25+ years Active in the ISO C++ Committee
A B
BIO
A B
BIO
A B
BIO
A B
BIO
A B
BIO
A B
BIO