2025

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

SANDOR_DARGO_ROUND.JPGWhile 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_cast and I discouraged you from using it. In general, it makes code worse in terms of readability. When you get rid of dynamic_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_cast

They 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

cpponsea2025-folkestone-to-dover.jpgAnother 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.

2025-08 Mailing Available

The 2025-08 mailing of new standards papers is now available.

 

WG21 Number Title Author Document Date Mailing Date Previous Version Subgroup
N5013 Programming Languages - C++ Thomas Köppe 2025-08-11 2025-08   All of WG21
N5014 Working Draft, Standard for Programming Language C++ Thomas Köppe 2025-08-05 2025-08   All of WG21
N5015 Editors' Report - Programming Languages - C++ Thomas Köppe 2025-08-14 2025-08   All of WG21
N5019 Business Plan and Convener's Report: ISO/IEC JTC1/SC22/WG21 (C++) Herb Sutter 2025-08-05 2025-08   All of WG21
P2414R10 Pointer lifetime-end zap proposed solutions Paul E. McKenney 2025-08-08 2025-08 P2414R9 EWG Evolution,LEWG Library Evolution
P2843R3 Preprocessing is never undefined Alisdair Meredith 2025-07-18 2025-08 P2843R2 CWG Core
P3100R4 Implicit contract assertions Timur Doumler 2025-08-13 2025-08 P3100R3 EWG Evolution
P3337R0 Graph Library: Library Comparisons Phil Ratzloff 2025-07-30 2025-08   SG19 Machine Learning
P3347R4 Invalid/Prospective Pointer Operations Paul E. McKenney 2025-08-08 2025-08 P3347R3 CWG Core
P3427R2 Hazard Pointer Synchronous Reclamation Maged Michael 2025-08-11 2025-08 P3427R1 LEWG Library Evolution
P3428R2 Hazard Pointer Batches Maged Michael 2025-08-11 2025-08 P3428R1 LEWG Library Evolution
P3643R1 std::to_signed and std::to_unsigned Jan Schultke 2025-08-13 2025-08 P3643R0 LEWG Library Evolution
P3688R2 ASCII character utilities Jan Schultke 2025-08-14 2025-08 P3688R1 SG16 Unicode
P3692R2 How to Avoid OOTA Without Really Trying Paul E. McKenney 2025-08-08 2025-08 P3692R1 SG1 Concurrency and Parallelism
P3702R1 Stricter requirements for document submissions (SD-7) Jan Schultke 2025-08-14 2025-08 P3702R0 All of WG21
P3719R1 std::is_vector_bool_reference Yuxuan Chen 2025-08-01 2025-08 P3719R0 LEWGI SG18: LEWG Incubator,LEWG Library Evolution
P3739R2 Standard Library Hardening - using std::optional Jarrad J Waterloo 2025-08-10 2025-08 P3739R1 LWG Library
P3774R1 Rename std::nontype, and make it broadly useful Jan Schultke 2025-08-14 2025-08 P3774R0 LEWG Library Evolution
P3775R0 Slides for P3774R0 - Rename std::nontype Jan Schultke 2025-08-12 2025-08   LEWG Library Evolution
P3779R0 reserve() and capacity() for flat containers Nicolai Josuttis 2025-08-01 2025-08   LEWG Library Evolution,LWG Library
P3790R1 Pointer lifetime-end zap proposed solutions: Bag-of-bits pointer class Paul E. McKenney 2025-08-08 2025-08 P3790R0 LEWG Library Evolution
P3796R1 Coroutine Task Issues Dietmar Kühl 2025-08-15 2025-08 P3796R0 SG1 Concurrency and Parallelism,LEWG Library Evolution,LWG Library
P3798R1 The unexpected in std::expected Alex Kremer 2025-08-12 2025-08 P3798R0 SG10 Feature Test,LEWG Library Evolution,LWG Library
P3806R0 views::cycle Hewill Kang 2025-08-03 2025-08   SG9 Ranges,LEWG Library Evolution,LWG Library
P3809R0 Should we make std::linalg reductions deduce return types like fold algorithms? Mark Hoemmen 2025-08-07 2025-08   LEWG Library Evolution
P3810R0 hardened memory safety guarantees Jarrad J Waterloo 2025-08-14 2025-08   SG23 Safety and Security

A virtual destructor in C++, when? -- Andreas Fertig

2025-07-01-when-to-not-use-a-virtual-dtor-tw.pngWhen should a destructor be virtual in C++? In this post, we’ll explore a real-world example from smart pointer implementation to illustrate when virtual destructors are necessary — and when they’re not.

A virtual destructor in C++, when?

by Andreas Fertig

From the article:

In today's post, I would like to explain a design rationale used in my post Understanding the inner workings of C++ smart pointers - The shared_ptr.

Keen readers spotted that in my implementation of ctrl_blk_base, I didn't make the destructor virtual. Here is the original code for easy reference:


PVS-Studio 7.38: new C++ analyzer core

PVS-Studio 7.38 has been released. This version brings the new core for the C and C++ analyzer, the user annotation mechanism in the Java analyzer, enhanced taint analysis, and that's not all! See more details in this note.

PVS-Studio 7.38: new C++ analyzer core, user annotations in Java, enhanced taint analysis, and more

by Aleksandra Uvarova

From the article:

The C and C++ analyzer got a new core with completely redesigned components like a parser, a semantic analyzer, and a type system. The new core provides more accurate handling of template constructs and better parsing of the standard library and code based on modern C++ standards. During the extended testing period (EAP), the new core demonstrated stable performance across a wide range of real-world projects.

CppCon 2025 Missing Step: Making Data Oriented Design One Million Times Faster -- Andrew Drakeford

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!

The Missing Step: Making Data Oriented Design One Million Times Faster

Tuesday, September 16 09:00 - 10:00 MDT

by Andrew Drakeford

Summary of the talk:

Data-oriented design (DOD) has gained traction for its practical approach to solving real-world problems. Refactoring data into an Entity-Component format sets the stage for cleaner, more efficient implementations, where lambdas process ranges and SIMD operations exploit the power of contiguous data layouts. DOD is widely recognised for addressing hardware-related performance challenges, but where do these challenges originate? The engineers behind our hardware platforms didn’t design performance bottlenecks; they created performance opportunities. By engineering how our code interacts with hardware, we can unlock these opportunities and achieve substantial speed-ups. The key lies in understanding and exploiting the state of the system. From the instruction cache and registers to the L1 cache and memory access patterns, the processor's statefulness plays a crucial role in performance. Writing "hardware-friendly" code is fundamentally about aligning with this state. But hardware is only part of the equation. What about the statefulness of our software? By carefully engineering the sequence of operations and algorithms to align with both hardware and software states, we can achieve unparalleled optimization. This is the missing step. Engaging with the design problem in full can be very difficult. We leverage George Polya’s problem-solving process and heuristics to guide our approach. This presentation explores these principles through real-world examples in machine learning and mathematical finance, demonstrating how addressing both sides of the problem can improve performance by orders of magnitude. (Yes, even six orders of magnitude.) Attendees will leave with insights into the exploration process and actionable techniques that might lead to achieving similar gains in their own work. It has been noted that some attendees might start drawing more diagrams when problem-solving and have an overwhelming urge to get Polya’s book.


Andrew Drakeford A Physics PhD who started developing C++ applications in the early 90s at British Telecom labs. For the last two decades, he has worked in finance developing efficient calculation libraries and trading systems in C++. His current focus is on making quant libraries more ecologically sound. He is a member of the BSI C++ panel.