June 8-13, Brno, Czechia
June 17-20, Folkestone, UK
September 12-18, Aurora, CO, USA
November 16-21, Búzios, Rio De Janeiro, Brazil
November 26-28, Berlin, Germany
By Meeting C++ | May 21, 2026 08:11 AM | Tags: performance meetingcpp intermediate c++11 advanced
Recently I've been wondering about ref qualifiers in C++.
Exploring ref qualifiers in C++
by Jens Weller
From the article:
Ref qualifiers are today an old C++11 feature, and recently I wanted to know more about them. Especially their potential use cases.
Thats a particular point with this feature, I've seen examples - but often without a compelling use case. This feature is a great way to achieve very specific things in C++...
By Blog Staff | May 20, 2026 03:50 PM | Tags: None
C++20 modules have been in the standard for more than 5 years already. They promise to deliver a big change to how we write C++, but their adoption hasn't been as widespread as one would have expected. This talk is a deep dive into the practical aspects of C++20 modules, exploring the reality of the ecosystem as it is today.
The road to 'import boost': a library developer's journey into C++20 modules
Rubén Pérez Hidalgo
Watch now:
By Blog Staff | May 19, 2026 02:38 PM | Tags: None
Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!
Concept-based Generic Programming
by Bjarne Stroustrup
Summary of the talk:
This talk presents programming techniques to illustrate the facilities and principles of C++ generic programming using concepts. Concepts are C++’s way to express constraints on generic code. As an initial example, it provides a simple type system that eliminate narrowing conversions and provides range checking.
Concepts are used throughout to provide user-defined extensions to the type system. The aim is to show their utility and the fundamental ideas behind them, rather than to provide a detailed or complete explanation of C++’s language support for generic programming or the extensive support provided by the standard library.
The final sections briefly present design rationales and origins for key parts of the concept design, including use patterns, the relationship to Object-Oriented Programming, value arguments, syntax, concept type-matching, and definition checking. They also mention static reflection, a C++26 improvements in the support of general programming.
By Meeting C++ | May 19, 2026 07:47 AM | Tags: meetingcpp events community
This years Meeting C++ conference is on the 26th - 28th November!
Meeting C++ 2026: Call for Sponsors
by Jens Weller
from the article:
Have you thought about the possibilty that you could have your employer sponsor Meeting C++ 2026?
Maybe your employer is interested in being present as a sponsor at this years Meeting C++ conference? With the call for talks closing on June 4th, now is the ideal time to talk about sponsorships for Meeting C++!
The 15th Meeting C++ conference is looking for sponsors! Come to Berlin in late November and be part of a large gathering of the C++ community!
By Blog Staff | May 18, 2026 03:45 PM | Tags: None
In today's post, I will explain one of C++'s biggest pitfalls: reinterpret_cast. Another title for this post could be: This is not the cast you're looking for!
What reinterpret_cast doesn't do
Andreas Fertig
From the article:
My motivation for this blog post comes from multiple training classes I thought over the past several months and a couple of talks I gave. Since C++23, you have a new facility in the Standard Library:
std::start_lifetime_as. When teaching class with a focus on embedded environments or presenting talks with such a focus, I started to addstd::start_lifetime_asto the material. With an interesting outcome.The feedback I get is roughly:
- why do I need
std::start_lifetime_as, I already havereinterpret_cast?- why can I use
reinterpret_cast?If you never heard of
start_lifetime_asplease consider reading my post, The correct way to do type punning in C++ - The second act.
By Blog Staff | May 15, 2026 03:41 PM | Tags: None
Even experienced C++ developers sometimes stumble on a deceptively simple question: what actually happens when a destructor throws an exception? This post breaks down the mechanics behind stack unwinding, noexcept, and why throwing from destructors is almost always a bad idea
What Happens When a Destructor Throws
by Sandor Dargo
From the article:
Recently I wrote about the importance of finding joy in our jobs on The Dev Ladder. Mastery and deep understanding are key elements in finding that joy, especially now that generating code is cheap and increasingly done better by AI than by us.
Then a memory surfaced. I frequently ask during interviews — as part of a code review exercise — what happens when a destructor throws. Way too many candidates, even those interviewing for senior positions, cannot answer the question. Most say it’s bad practice, but cannot explain why. Some say the program might terminate. Getting an elaborate answer is rare.
I’m not saying it’s a dealbreaker, but it definitely doesn’t help.
Let’s see what actually happens.
The role of a destructor
A destructor is the key to implementing the RAII idiom. RAII matters because after you acquire a resource, things might go south. A function might need to return early, or it might throw. Making sure resources are released is cumbersome, and the cleanest way to achieve it is to wrap both acquisition and release in an object that handles this automatically.
But what if the release itself is not successful?
Destructors have no return value, so error reporting is limited. Typical options include logging, storing error state, or (discouraged) throwing.
Why did I mark throwing an exception discouraged?
By Blog Staff | May 14, 2026 08:00 AM | Tags: None
Sponsored by HRT and produced by CultRepo, we're pleased to share the official trailer for C++: The Documentary.
The trailer premieres today at 19:00 UTC. Click Notify me on the YouTube Premiere page to get a reminder when it goes live.
The film will have its world premiere on May 28 at a special live event in New York City’s Financial District, followed by a panel discussion that will be recorded for later release. C++: The Documentary will be released worldwide on YouTube on June 4, with the panel recording following a few days later.
By Blog Staff | May 13, 2026 02:35 PM | Tags: None
Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!
Crafting the Code You Don’t Write: Sculpting Software in an AI World
by Daisy Hollman
Summary of the talk:
It’s shockingly uncontroversial to say that the fields of developer experience and developer productivity have changed more in the past six months than in the 25 years before that.
As part of the Claude Code team at Anthropic, I’ve had the privilege of witnessing the evolution of agentic coding from proof-of-concept experiments to nearly autonomous software engineers in just six months. In this keynote, I’ll share some of my experiences and learnings from that journey, talk about how LLMs work more generally, attempt some live demonstrations of the latest functionality, explore the future of agentic programming, and tie all of this back to what it means for your workflow as a software engineer.
When I agreed to give this talk earlier this year, there was some portion of the narrative that involved “why you should be using agents to accelerate your development process.” Since then, the world of software engineering has evolved such that the interesting question is no longer “why” but “how.” Like sculptors facing the invention of power tools, or painters around the invention of photography, we now live in a world where vast quantities of rough-draft code can be generated with a very low barrier to entry. How does the role of a software engineer evolve when AI can autonomously implement features from requirements? How do we build safety features into the power tools we’re chiseling away at our codebases with? What aspects of software craftsmanship become more important, not less, in an age of abundant code generation? And critically for the C++ community: how do we leverage these tools where correctness and performance are non-negotiable? The future isn’t about AI replacing programmers, but about a fundamental shift in how we think about software creation. And surprisingly, you might not miss the old way of doing things.
By Blog Staff | May 12, 2026 03:39 PM | Tags: None
A nice example of C++26 reflection moving from theory into something practical.
Evolving a Translation System with Reflection in C++
By GitHub user: friedkeenan
From the post:
Lately, I’ve been using C++26 reflection to create some crazy and cursed stuff. But even though I quite enjoy that work, it is as well quite far from the norm of what reflection is going to offer us in our everyday code.
Reflection is definitely not just that craziness, and so I want to present reflection in a more grounded environment, and in a way that will probably land as more typical usage as our codebases gradually come into contact with it.
So then, in this blogpost, I will be exploring a spectrum of options for how reflection can upgrade a translation system that I already use in one of my projects. We’ll look at where it’s at now without reflection, identify places in which reflection could plausibly help, and then explore a series of modifications we could make to soothe those problem points.
The purpose of looking at each of these options will not be to declare that one is clearly the best option or the one that makes the most sense, but rather to get a better feel for what could make sense to do, and whether some things are really worth the effort. We’re trying to gauge the benefits that reflection can bring to our code.
And who knows, even if one option is less appealing for this particular situation, maybe in a different situation it could be the perfect fit.
By Blog Staff | May 11, 2026 02:32 PM | Tags: None
Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!
Reflection: C++’s Decade-Defining Rocket Engine
by Herb Sutter
Summary of the talk:
In June 2025, C++ crossed a Rubicon: it handed us the keys to its own machinery. For the first time, C++ can describe itself—and generate more. The first compile-time reflection features in draft C++26 mark the most transformative turning point in our language’s history by giving us the most powerful new engine for expressing efficient abstractions that C++ has ever had, and we’ll need the next decade to discover what this rocket can do.
This session is a high-velocity tour through what reflection enables today in C++26, and what it will enable next. We’ll start with live compiler demos (Godbolt, of course) to show how much the initial C++26 feature set can already do. Then we’ll jump a few years ahead, using Dan Katz’s Clang extensions and my own cppfront reflection implementation to preview future capabilities that could reshape not just C++, but the way we think about programming itself.
We’ll see how reflection can simplify C++’s future evolution by reducing the need for as many bespoke new language features, since many can now be expressed as reusable compile-time libraries—faster to design, easier to test, and portable from day one. We’ll even glimpse how it might solve a problem that has long eluded the entire software industry, in a way that benefits every language.
The point of this talk isn’t to immediately grok any given technique or example. The takeaway is bigger: to leave all of us dizzy from the sheer volume of different examples, asking again and again, “Wait, we can do that now?!”—to fire up our imaginations to discover and develop this enormous new frontier together, and chart the strange new worlds C++ reflection has just opened for us to explore.
Reflection has arrived, more is coming, and the frontier is open. Let’s go.