2012= : Standard C++

Home » Blog » 2012=

« Prev Next »

2012=

CppCon 2025 The Pattern Matching We Already Have -- Braden Ganetsky

By Blog Staff | Sep 7, 2025 01: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!

The Pattern Matching We Already Have

Friday, September 19 09:00 - 10:00 MDT

by Braden Ganetsky

Summary of the talk:

All the way since C++98, we have already had pattern matching in C++! It's limited to specific places, but it's there. Template argument deduction, function overload resolution, and class template specializations are all instances of pattern matching in the C++ language, dating all the way back to the original standard.

The C++11 additions to the language also require library constructs to help deal with type deduction in forwarding references, namely std::forward, among others. Even experienced C++ developers may run into unexpected situations using it, especially in newer scenarios like concepts from C++20. This talk will lay clear the rules of forwarding and std::forward, and how you can forward your arguments properly every time.

This interactive talk is a deep dive into template argument deduction, helping you to understand it at deeper level across all of C++'s lifespan. Almost all that applies in C++98 still applies today, so a foundational understanding is important. Additionally, newer language standards have introduced further wrinkles, like C++11's move semantics and variadic template parameters, as well as C++17's class template argument deduction. By the end of this talk, you will have a solid understanding of how C++ deduces the types used in your code.

Braden Ganetsky graduated from the University of Manitoba with a degree in mechanical engineering, fueled by his passion for mechanical puzzles. During his final year of school, when all classes and activities were remote, he discovered C++ and has been hooked ever since. He interned as a C++ developer, which turned into a full time job, completing a successful pivot of his career. Now he spend his nights working on fun projects like parser combinators, and getting involved in the C++ community. Since 2023, Braden sits on the ISO C++ Committee as a representative of Canada.

CppCon 2025 Using Distributed Trace for End-to-End Latency Metrics -- Kusha Maharshi

By Blog Staff | Sep 5, 2025 01:27 PM | Tags: None

Using Distributed Trace for End-to-End Latency Metrics

Thursday, September 18 15:15 - 16:15 MDT

by Kusha Maharshi

Summary of the talk:

In this talk, we'll delve into how we utilized distributed trace to address a prevalent need at a large technology company that serves the finance industry: timing requests from point A to point Z in a complex system, where a whole alphabet's worth of steps occur in between. We'll show how tracing, an open source telemetry standard, helped us generate insights from tracking requests in a complicated, microservices-driven architecture. We'll discuss the challenges faced and lessons learned while building a C++ solution that turns trace data into end-to-end latency metrics. We hope to inspire attendees to apply these lessons to telemetry solutions tailored to their own firms' needs.

Distributed tracing was introduced within our company before it was a stable, open standard. We saw its potential and invested in solutions that utilized its rich, cross-service information. However, existing open source or commercial products didn't fit the complexity and scale of our trace data. Our engineers, incident responders, and managers wanted end-to-end latency metrics to observe complex workflows, so we built our own solution! The resulting metrics now drive service level objectives (SLOs) that set measurable targets that define a system's quality and reliability. When these targets are not met, teams are alerted, thus driving quick remediation. Furthermore, the traces corresponding to any degradation in system health can be used to pinpoint faulty components, as well as aid in the development and testing phases when building new solutions.

From a technical point of view, trace data is represented as directed acyclic graphs (DAGs), and our challenge was processing more than 50 billion daily nodes, with deep fan-outs and fan-ins. These graphical structures mirror real-world scenarios like queuing systems for high-volume messaging, order processing or batched email notifications, and present concurrency choke points at scale. In this talk, we'll break down the design of the C++ microservices we built to process large-scale streaming graphs into metrics, while also addressing scalability bottlenecks. We'll also highlight why we chose C++ and its libraries, powerful profiling tools, and efficient data structures. If you're into building low-latency, high-throughput distributed systems, want to build telemetry solutions that best suit your needs, or just enjoy geeking over graphs, this talk is for you!

Kusha Maharshi is a Senior Software Engineer at Bloomberg, where she passionately works on distributed tracing and observability infrastructure. An avid public speaker, she loves breaking down complex technical challenges with clarity – and a dose of humor. Kusha holds a degree in Computer Science from Carnegie Mellon University, where she specialized in computer systems. Her favorite programming language? Assembly.

A Library Approach to Constant Template Parameters -- Barry Revzin

By Blog Staff | Sep 4, 2025 02:55 PM | Tags: None

C++26 has brought big advances, especially with reflection making its way into the working draft, but one long-standing challenge remains: supporting richer class types as constant template parameters. Although the language solution isn’t here yet, we can get surprisingly far with a library approach that uses reflection and static objects to extend what’s possible today.

A Library Approach to Constant Template Parameters

by Barry Revzin

From the article:

This library achieves two things.

First, it is just, in general, very useful. I’m hoping to make it more of a Real Library™️ once Reflection gets implemented in more than just the Bloomberg fork of Clang that Dan Katz implemented.

Second, I think it demonstrates the power of Reflection. There are so many problems that were not possible in C++23 that become solvable in C++26. We’re going to spend the next several years discovering more of those, and that makes it a pretty exciting time for C++.

CppCon 2025 C++ Parallel Programming Models -- Eran Gilad

By Blog Staff | Sep 3, 2025 01:24 PM | Tags: None

C++ Parallel Programming Models

Thursday, September 18 14:00 - 15:00 MDT

by Eran Gilad

Summary of the talk:

Modern C++ offers a wealth of parallel programming features. Those features belong to four different programming models: low-level, a-sync, cooperative multitasking, and data parallel. The low-level model (or rather, non-model) contains the basic building blocks – threads, atomics, mutex etc. The a-sync model contains async, future and related classes. The cooperative multitasking model relies on coroutines. Lastly, the data parallel model contains the parallel algorithms. The four models aren’t just different abstraction levels – each is appropriate for a different program structure. This talk will review the four models, describe the central features used by each model, and discuss the expected use case for each one. Since many of the parallelism features are not new to the language at this point, the talk will not focus on the details of the features themselves. Instead, the talk will put them in the context of a programming model and make the choice of parallel programming features easier for C++ developers.

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.

C++26: std::format improvements (Part 2) -- Sandor Dargo

By Blog Staff | Sep 2, 2025 02:54 PM | Tags: None

In Part 1, we explored the improvements C++26 brings to std::format — from better to_string behavior to compile-time safety checks. In this part, we look at runtime formatting, defect fixes, and support for new types like std::filesystem::path.

C++26: std::format improvements (Part 2)

by Sandor Dargo

From the article:

Runtime format strings

P2216R3 brought quite some improvements to std::format, including compile-time checking for format strings. Sadly, in use cases where format strings were only available at runtime, users had to go with the type-erased formatting version, std::vformat:

std::vformat(str, std::make_format_args(42));

Using two different APIs is not a great user experience, moreover, std::vformat was designed to be used by formatting function writers and not by end users. In addition, you might run into undefined behaviour, detailed in the next section.

To overcome this situation, P2918R2 adds std::runtime_format so you can mark format strings that are only available at run-time. As such you can opt out of compile-time format strings checks. This makes the API cleaner and the user code will read better as it shows better the intentions.

CppCon 2025 Back to Basics: static, inline, const, and constexpr -- Andreas Fertig

By Blog Staff | Sep 1, 2025 12:54 PM | Tags: None

Back to Basics: static, inline, const, and constexpr

Thursday, September 18 09:00 - 10:00 MDT

by Andreas Fertig

Summary of the talk:

C++ comes with a whole toolbox of keywords you can apply to types and functions. You think it's straightforward? My experience says otherwise. There are false-friends like static , which I often see misapplied.

In this talk, I will demystify those tricky little keywords. You'll learn what they really mean, how they behave in different contexts, and — most importantly — when to use them (and when not to). Think const, constexpr, consteval, constinit: yes, C++ has more flavors of constness than your local ice cream shop. We'll explore them all.

We'll go beyond syntax and dive into what's actually happening in the language.

While the talk includes some features from C++23, most of what we cover is rooted in C++11 or even classic C++98. We'll touch on important concepts like the One Definition Rule (ODR) and top-level qualifiers, giving you a deeper understanding of how these keywords shape your code.

After this session, you'll walk away knowing exactly where each keyword belongs. No more guesswork. Just the right keyword in the right place.

Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and consultant for C++ for standards 11 to 23. Andreas is involved in the C++ standardization committee, developing the new standards. At international conferences, he presents how code can be written better. He publishes specialist articles, e.g., for iX magazine, and has published several textbooks on C++. With C++ Insights (https://cppinsights.io), Andreas has created an internationally recognized tool that enables users to look behind the scenes of C++ and thus understand constructs even better. Before training and consulting, he worked for Philips Medizin Systeme GmbH for ten years as a C++ software developer and architect focusing on embedded systems. You can find Andreas online at andreasfertig.com.

CppCon 2025 Welcome to v1.0 of the meta::[[verse]]! -- Inbal Levi

By Blog Staff | Aug 30, 2025 12:50 PM | Tags: None

Welcome to v1.0 of the meta::[[verse]]!

Wednesday, September 17 16:45 - 17:45 MDT

by Inbal Levi

Summary of the talk:

This talk will introduce what is (likely) the final version of the "Reflection" feature targeting C++26.

With a proposal to introduce reflection to C++26 (including the “std::meta” namespace) slated to be voted into the standard in June 2025, we can already start imagining a whole new world of possibilities.

In this session, we will dive into reflection and its transformative potential within our codebases. We will start with a brief history of "reflection" history. We'll continue with an introduction of utilities from the latest reflection proposal. Then, we delve deeper into practical applications and demonstrate solutions to problems that commonly use reflection and the power it holds. For the last part, we will explore the possibilities within “Reflection Libraries”. This includes both “traditional” libraries which provide functionality, and more “novel” approaches which reshape users’ code. We will look at examples of what such libraries can cover, and demonstrate potential directions the future holds. Last but not least, we will discuss how "Reflection" may impact the way we manage our codebases and the delivery process.

Join us as we traverse the meta::[[verse]]!

Inbal Levi is a Lead Software Engineer at Millennium (MPGC Services Ltd) with a passion for high performance, 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.

C++26: std::format improvement (Part 1) -- Sandor Dargo

By Blog Staff | Aug 29, 2025 02:54 PM | Tags: None

C++26 brings a series of improvements to std::format, continuing the work started in C++20 and refined in C++23. These changes improve formatting consistency, runtime safety, and user ergonomics. There are so many of these updates, that I decided to divide them into two articles.

C++26: std::format improvement (Part 1)

by Sandor Dargo

From the article:

Arithmetic overloads of std::to_string and std::to_wstring use std::format

P2587R3 by Victor Zverovich proposes replacing sprintf with std::format in the arithmetic overloads of std::to_string and std::to_wstring.

The motivation?

std::to_string has long been known to produce not-so-great and misleading results (differing from iostreams), especially with floating-point values. std::to_string uses the global C locale. In practice, it’s unlocalized. Also, it often places the decimal points to suboptimal places:
std::cout << std::to_string(-1e-7); // prints: -0.000000 
std::cout << std::to_string(0.42); // prints: 0.420000
These outputs are imprecise and often unnecessary. By leveraging std::format (and ultimately std::to_chars), we now get clearer, shorter representations. The representations of floating-point overloads become also unlocalized and use the shortest decimal representations.

As a result, the above outputs would change as follow:

    std::cout << std::to_string(-1e-7);  // prints: -1e-7
    std::cout << std::to_string(0.42); // prints: 0.42

CppCon 2025 Keynote: C++: Some Assembly Required -- Matt Godbolt

By Blog Staff | Aug 29, 2025 12:39 PM | Tags: None

C++: Some Assembly Required

Friday, September 19 16:15 - 18:00 MDT

by Matt Godbolt

Summary of the talk:

Join Matt in exploring how the C++ ecosystem has evolved through the interplay of intentional design and emergent collaboration. Standards committees craft language features and compiler teams implement them, but something amazing happens in the spaces between: tools appear, communities form, and solutions emerge that nobody quite planned for. What started as individual developers solving their own problems has grown into an interconnected ecosystem that shapes how we all write C++.

From documentation to testing, from build systems to package managers, we'll examine how the C++ community has assembled itself around shared pain points and accidental standards. Using examples and perhaps too many rainforest metaphors, this talk celebrates not just the language we've built, but the organic ecosystem that's grown up around it. Come discover why C++'s greatest strength might be that it's always required some assembly.
Presenters

Matt Godbolt is the creator of the Compiler Explorer website. He is passionate about writing efficient code. He has previously worked at a trading firm, on mobile apps at Google, run his own C++ tools company and spent more than a decade making console games. When he's not hacking on Compiler Explorer, Matt enjoys writing emulators for old 8-bit computer hardware.

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

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.