2012= : Standard C++

Home » Blog » 2012=

« Prev Next »

2012=

CppCon 2025 Keynote: More Speed & Simplicity:Practical Data-Oriented Design in C++ -- Vittorio Romeo

By Blog Staff | Aug 28, 2025 12:32 PM | Tags: None

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: More Speed & Simplicity:Practical Data-Oriented Design in C++

Thursday, September 18 10:30 - 12:00 MDT

by Vittorio Romeo

Summary of the talk:

Data-Oriented Design (DOD) presents a different way of thinking: prioritizing data layout not only unlocks significant performance gains via cache efficiency but can also lead to surprising simplicity in the code that actually processes the data.

This talk is a practical introduction for C++ developers familiar with OOP. Through a step-by-step refactoring of a conventional OOP design, we’ll both cover how data access patterns influence speed and how a data-first approach can clarify intent.

We’ll measure the performance impact with benchmarks and analyze how the refactored code, particularly the data processing loops, can become more direct and conceptually simpler.

Key techniques like Structure-of-Arrays (SoA) vs. Array-of-Structures (AoS) will be explained and benchmarked, considering their effects on both execution time and code clarity. We’ll pragmatically weigh the strengths (performance, simpler data logic) and weaknesses of DOD, highlighting how it can complement, not just replace, OOP.

We’ll also demonstrate that DOD doesn’t necessitate abandoning robust abstractions, showcasing C++ techniques for creating safe, expressive APIs that manage both complexity and performance.

Let’s learn how thinking “data-first” can make your C++ code faster and easier to reason about!

Vittorio Romeo (B.Sc. Computer Science, 9+ YoE at Bloomberg) works on mission-critical C++ infrastructure and provides Modern C++ training to hundreds of fellow employees. He began programming around the age of 8 and became a C++ enthusiast shortly after discovering the language. Vittorio created several open-source C++ libraries and games, published many video courses and tutorials, actively participates in the ISO C++ standardization process, and maintains the popular SFML library. He co-authored the acclaimed "Embracing Modern C++ Safely" book (published in January 2022) with J. Lakos, R. Khlebnikov, and A. Meredith. Vittorio is an active member of the C++ community with an ardent desire to share his knowledge and learn from others: he presented and offered workshops over 20 times at international C++ conferences (including CppCon, C++Now, ++it, ACCU, C++ On Sea, C++ Russia, and Meeting C++), covering topics of various nature. He also maintains a website with advanced C++ articles and a YouTube channel featuring well-received modern C++11/14 tutorials. Lastly, he's active on StackOverflow, taking great care in answering interesting C++ question (90k reputation). When he's not writing code, Vittorio enjoys weightlifting, playing volleyball, scuba diving, canyoning, gaming, and enjoying sci-fi content.

Boost version 1.89 released!

By Blog Staff | Aug 27, 2025 02:50 PM | Tags: None

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

By Blog Staff | Aug 26, 2025 12:27 PM | Tags: None

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

By Blog Staff | Aug 25, 2025 09:14 AM | Tags: None

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

By Blog Staff | Aug 24, 2025 08:45 AM | Tags: None

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

By Blog Staff | Aug 22, 2025 07:43 AM | Tags: None

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

By Blog Staff | Aug 21, 2025 08:13 AM | Tags: None

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_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

By Blog Staff | Aug 20, 2025 08:40 AM | Tags: None

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

By Blog Staff | Aug 19, 2025 07:10 AM | Tags: None

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

By Blog Staff | Aug 18, 2025 02:36 PM | Tags: None

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.