Boost version 1.89 released!
Release 1.89 of the Boost C++ Libraries is now available.
One new library and updates to 28 more.
Bloom, configurable filters for probabilistic lookup: https://boost.org/libs/bloom
CppCon 2025 Keynote: Crafting the Code You Don’t Write: Sculpting SW in an AI World -- Daisy Hollman
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
Crafting the Code You Don't Write: Sculpting Software in an AI World
Tuesday, September 16 10:30 - 12:00 MDT
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.
Dr. Daisy Hollman is a distinguished software engineer and programming language expert, known for her impactful contributions to the C++ standards committee since 2016. She has worked on C++ language and library design at Google, and more recently joined Anthropic, where she explores the intersection of programming languages and AI systems.
CppCon 2025 Keynote: Reflection: C++’s Decade-Defining Rocket Engine -- Herb Sutter
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
Keynote: Reflection: C++’s Decade-Defining Rocket Engine
Wednesday, September 17 10:30 - 12:00 MDT
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.
Herb is an author, designer of several Standard C++ features, and chair of the ISO C++ committee and the Standard C++ Foundation. His current interest is simplifying C++.
CppCon 2025 To Err is Human: Robust Error Handling in C++26 -- Sebastian Theophil
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
To Err is Human: Robust Error Handling in C++26
Wednesday, September 17 15:15 - 16:15 MDT
by Sebastian Theophil
Summary of the talk:
Every program may encounter errors, some originating from internal bugs in the program, others coming from the environment the program is operating in. Ignoring all errors will make the program utterly unreliable, while treating every conceivable one introduces lots of extra complexity with little benefit. So which errors should you handle? And how should you handle them? This talk describes our proven approach to error handling so that you can write more reliable software with less effort.
C++23 and C++26 have seen several improvements to C++ error handling: std::stacktrace, std::expected, contracts and library hardening. We will cover these features as well and how to best use them in practice to catch more errors, report them and fix them.
Sebastian has been working at think-cell since its founding in 2002. In the last few years, among many other things, he has ported think-cell to run on macOS. He is also the maintainer of the typescripten project which lets programmers call JavaScript libraries from C++ code compiled to WebAssembly in a convenient and type-safe way. He enjoys leaving his desk from time to time to talk at international C++ conferences.
CppCon 2025 Mastering the Code Review Process -- Peter Muldoon
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
Mastering the Code Review Process
Wednesday, September 17 15:15 - 16:15 MDT
by Peter Muldoon
Summary of the talk:
In software development, significant attention is given to writing clean, maintainable code. Yet, despite the best of intentions, many codebases drift from structured practices due to inconsistent or ineffective code reviews. This is a real problem as it is the last line of defense before merging and deploying changes to production.
Engineers spend far more time reading code than writing it. Even small changes demand a thorough understanding of the surrounding code to prevent errors and unintended consequences. An effective code review process significantly amplifies good coding practices, structured problem-solving, and overall code quality.
This talk outlines core principles for conducting impactful code reviews emphasizing methodologies that balance consistent evaluation with the flexibility for handling the inevitable unusual situations.
We will also explore practical ways to measure code review effectiveness , enabling teams to continuously improve their code review process. What would a code review checklist look like? What are the consequences and friction points of a poor code review process?
As the code review process matures within an organization, it can also be shown to act as an effective instructional tool and drive positive organizational change , enhancing both the quality of the codebase and the capability of individual teams.
Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases in a large number of companies both tech and finance. Such broad exposure has, over time, shown what works and what doesn't for large scale engineering projects. He's a proponent of applied engineering principles, elegant solutions and expressive code.
Once More About dynamic_cast, a Real Use Case -- Sandor Dargo
While dynamic_cast is often discouraged for its impact on readability and reliance on RTTI, there are rare situations where it can be the most practical and safe solution. In this post, we explore one such real-world case: using dynamic_cast for runtime versioning of plugin interfaces in a way that balances compatibility, safety, and extensibility.
Once More About dynamic_cast, a Real Use Case
by Sandor Dargo
From the article:
I wrote a couple of times about
dynamic_castand I discouraged you from using it. In general, it makes code worse in terms of readability. When you get rid ofdynamic_cast, either via self-discipline or by turning RTTI off, you’ll have to rely on dynamic dispatching and better abstractions.But there might be cases, when it’s not possible or at least it’s not meaningful to remove
dynamic_cast, here is one, sent by one of you.Versioning with the help of
dynamic_castThey have an SDK that anyone can implement. As there are new features added every now and then, the API keeps changing. Not surprisingly, the owners of the SDK want to prevent their users’ code from breaking. They achieve this by having different “versioned” interfaces for the same service where a new version inherits from the previous one.
Let’s see a simplified example.
CppCon 2025 Best Practices for AI Tool Use -- Jason Turner
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
Best Practices for AI Tool Use
Wednesday, September 17 09:00 - 10:00 MDT
by Jason Turner
Summary of the talk:
AI (LLMs) are becoming prolific in C++ tooling. Virtually everything has an AI bot built in or available to it. Common wisdom says that these tools simply regurgitate what they find on the internet. As we all know, the internet is full of terrible examples of outdated memory leaks, undefined behavior, and worse!
How do we effectively and safely use these tools while ensuring good code quality?!
Jason is host of the YouTube channel C++Weekly, co-host emeritus of the podcast CppCast, author of C++ Best Practices, and author of the first casual puzzle books designed to teach C++ fundamentals while having fun!
Trip report: C++ On Sea 2025 -- Sandor Dargo
Another year, another trip report from C++ On Sea!
Trip report: C++ On Sea 2025
by Sandor Dargo
From the article:
First, a heartfelt thank-you to the organizers for inviting me to speak, and an equally big thank-you to my wife for taking care of the kids while I spent three days in Folkestone — plus a few more in London to visit the Spotify office and catch up with some bandmates.
If you have the chance, try to arrive early or stay around Folkestone for an extra day. It’s a lovely town and it’s worth exploring it. The conference program is very busy even in the evenings, so don’t count on the after hours.
This year, I arrived an half a day in advance and I had a wonderful hike from Folkestone to Dover. It was totally worth it.
In this post I’ll share:
- Thoughts on the conference experience.
- Highlights from talks and ideas that resonated with me.
- Personal impressions, including reflections on my own sessions — both the main talk and the lightning talk.
CppCon 2025 std::optional --- Optional Over References -- Steve Downey
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
std::optional --- Optional Over References
Tuesday, September 16 15:15 - 16:15 MDT
by Steve Downey
Summary of the talk:
Optionals were first proposed for C++ in 2005.
Optional , where T is constrained not to be a reference, was added in 2017.
Optionals for lvalue references are on track to be added in C++ 26.
What are we getting and what design choices were made? This talk will show the results.
This talk will discuss the early history of Optionals, starting with Boost.Optional and “N1878: A Proposal to Add an Utility Class to Represent Optional Objects (Revision 1)”, and what the early concerns were for the reference specialization. “P1175R0: A Simple and Practical Optional Reference for C++” then re-proposed reference support for C++20, which was not adopted. In 2020, “P1683R0: References for Standard Library Vocabulary Types - an optional<> case study” surveyed existing behavior of optional references in the wild, and pointed out the trap of assignment behavior being state dependent. In 2023, “P2988R0: Std:Optional” picked up the torch again, and Revision 10 of that is the proposal that is approved by the Library Working Group.
In 2024, “P3168R0: Give Std:Optional Range Support”, the proposal to make optional a range -- as opposed to having a separate range of zero or one -- was adopted. The reference implementation for optional
Steve Downey has been a programmer for more than 30 years. Steve graduated from SUNY Purchase with a BS in Mathematics. A Computer Science degree would have involved two classes before 11:00 am, so was impossible.
He has worked at Bloomberg since 2003, and is currently working as an Engineer on the C++ Infrastructure team.
CppCon 2025 Back to Basics: Refactoring -- Amir Kirsh
Registration is now open for CppCon 2025! The conference starts on September 13 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting some upcoming talks that you will be able to attend this year. Here’s another CppCon future talk we hope you will enjoy – and register today for CppCon 2025!
Back to Basics: Refactoring
Tuesday, September 16 09:00 - 10:00 MDT
by Amir Kirsh
Summary of the talk:
Writing C++ code is one thing, keeping it clean, readable and maintainable over time is another. In this talk, we'll review the basics of refactoring C++ code, focusing on strategies to improve code clarity, reduce duplication, and make your code easier to maintain. You'll learn how to identify code smells, recognize when refactoring is needed, and apply techniques to improve readability. We will also explore how to modernize your code by leveraging new C++ features when relevant, ensuring that your code not only adheres to best practices but is also aligned with the evolving standards of the language. Participants will gain practical knowledge on how to refactor C++ code to enhance clarity, reduce complexity, and improve long-term maintainability, a skill that becomes even more essential as AI starts generating parts of our codebase. This talk is part of the Back to Basics track and is designed for C++ beginners, but it can also be useful for intermediate and experienced developers who want to revisit the fundamentals of maintaining clean, well-structured C++ code through effective refactoring.
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. He is also a co-organizer of the annual Core C++ conference and a member of the ISO C++ Israeli National Body.