CppCon 2024

Our C++ code often contains violations of "Don't Repeat Yourself" (DRY). You write down enums, but then you also have to write their stringified version. You write down a class, but you have to expose every method / member in the class separately to be able to bind your class to a Python program (for example).

Reflection is (potentially / hopefully) showing up for C++26, having already been design approved by EWG, its chances are looking promising! This talk will discuss everything the basics of reflection, and we will lead up to three library ideas based on reflection, as a way to understand the massive impact this might have on the kind of libraries our ecosystem can provide, without relying on the core language to provide such abilities. The examples we will go through are:

Automatic python bindings
ABI hashing (hashing a type for efficient compatibility checking)
A better std::any variant type that brings duck typing to C++

Come attend this talk if you'd like to hear about cool new library possibilities that have opened up with reflection!

When a C++ compiler encounters an expression like f(x, y), it must consider several language mechanisms to decide which function f the program will call. These mechanisms include name lookup, overload resolution, default function arguments, and template processing. Having a firm understanding of these mechanisms and how they interact will help you write user-friendly interfaces for you and your team.

This session begins by reviewing each of these mechanisms individually. It then examines how those mechanisms interact, focusing on situations that are most likely to occur in practice. Some of the questions that we’ll consider are:

 
• How does the compiler resolve calls on overloaded functions with implicit conversions on multiple arguments?

 
• Why does the compiler apply implicit conversions when resolving calls to overloaded functions, but not when making calls to function templates?>/li>
  

After this session, you’ll have a clearer understanding of how the compiler makes sense out of your code. With this knowledge, you’ll find it easier to craft interfaces that are easy to use correctly and hard to use incorrectly. You’ll also be better able to steer the compiler in your intended direction when necessary.

This presentation introduces a multi-producer, multi-consumer, lock-free queue with unique characteristics. We will cover the C++17 implementation and the std::atomic features required for this queue based on the CPU atomic instructions and discuss the queue's portability across various CPU architectures, beyond just X86_64 and runtime environments.

Efficient message queue-based communication between threads is crucial for optimal performance in multi-threaded applications. Queues are fundamental data structures that interact with various aspects of the application environment, including schedulers, memory allocation systems, and CPU hardware architectures.

Many use cases such as trading platforms, games, audio processing and other fields have strict latency and scaling requirements and this queue implementation has proved to reduce system latencies.

The presentation will feature the design of the queue, the required template language features, bandwidth and latency consideration, and multiple demo applications. Comparing this queue implementation’s benchmark results with other existing queues will follow. Finally, we will discuss potential future work and areas for improvement.

Join us to explore how this innovative queue implementation can improve your multi-threaded application performance.

All presentation materials, including the C++17 source code, slides, benchmarks, and demo applications are available on GitHub.

Programming normal C++ leads to the use of dynamic memory, pointer chasing, and other issues that zap performance. Because there haven’t been practical solutions to those problems we seldom discuss them, creating the impression that they are unavoidable. Fortunately, the same C++ that binds us frees us to devise techniques centered around the concept of “relocatability” to solve those issues. We will explain what relocatability is and how to achieve it.

Consider the example of runtime polymorphism. You may want to have interfaces and implementations of interfaces. If your object refers to a “polymorphic” member, it normally cannot be implemented as a concrete sub-object, only as a base class pointer that points to a dynamically allocated instance of a derived class. This leads to millions of small objects dispersed throughout memory, all referencing one another. This is already very expensive and other issues around object layout makes things worse. One presenter witnessed 7% of Google Search Qrewrite CPU spent on dealloc, which must chase pointers to finish!

When we want to save the state of such programs, we must traverse those complex object graphs and encode them in complex file formats: serialization is required. Restore is further complicated by needing millions of small allocations which are often ephemeral. In general, working with data architected in this way is error prone and has abysmal performance. Our alternative to these complex object graphs is to lay out program data according to program design objectives, in our case allowing object moves. This is the essence of relocation. The set of techniques we will share with you is complete. Now that we can represent program state as simple, relocatable data, save and restore is simply memory mapping buffers.

For runtime polymorphism, we can use “Type Erasure”, the Design Pattern behind `std::function`, tailored for relocatability. Our Type Erasure performs better than normal polymorphism. We get better performance, we have no allocations, no deallocations, and no pointer chasing; resulting in happier programming. For other issues we get benefits of the same magnitude.

We will explain both well known and novel relocation techniques. The novel techniques have required the formulation of Generic Programming concepts including what we call “Value Manager”. We are presenting these for the first time.

Efficient memory utilization is a critical aspect of software running in a multi-tenant environment, where resources are shared amongst different processes. Unlike languages with automatic memory management, C++ allows for manual memory management. Developers have control over when memory is allocated and released, which can lead to more efficient resource usage, but also can lead to mistakes causing problems in memory. 

You plugged new code in for a fancy feature and all functional tests were green! You clicked the deploy button, but 10 minutes later an alarm came -- machine memory usage had reached 90%! Things can get even more complicated when you work on a project with numerous contributors. How do you know which of the latest commits resulted in your process eating up all the memory of the OS and never releasing it back?

In this talk, I will try to put together some useful pieces from the real world in order to paint a comprehensive picture from the perspective of a novice C++ developer. By the end of the presentation, you'll have a basic understanding of C++ memory allocation, an awareness of potential memory issues, and the know-how to leverage tools for profiling and analyzing your C++ applications.

For years, developers have overlooked a powerful tool for reducing binary size: C++ exceptions. Join me on a deep dive into the world of exceptions and discover how they can be harnessed to create more space efficient firmware. We’ll explore the requirements and best practices of embedded development, and show what is required to use exceptions in that environment. By the end of this talk, you’ll have a thorough understanding of how exceptions are handled, what their space costs are, and how exceptions compare to functional errors as values.

Play is FUNdamental. This session looks at some more odd corners of C++ where we try to do out-of-the-ordinary things just to see what's possible. Should we do these things in production code? Maybe not today, but in the future, who knows? 20-odd years of C++ has taught me that it's a hop and a skip from "ugh, that's really nasty" to "that's an established technique now".

Whatever you think of the things in this presentation, it's fun to learn. And things which we don't use in code today are still useful to know about when they crop up.

Software engineers have an astounding opportunity to benefit from programmable money: now we can program directly with value, introducing the objectivity, auditability, and neutrality of Open Source Code, instead of the opaqueness, ambiguities, biases, and other issues of conventional monetary processes.

Bitcoin is arguably the simplest of all cryptocurrencies, giving us a real opportunity to learn it at this conference. We’ll show examples of money programmability to demonstrate what is truly possible…

In this session, we will leverage our skill as programmers by describing Bitcoin's design as a Software Engineering project, using the white paper as the primary source material with the updates running today ("SegWit", "Taproot", Schnorr Signatures…), aiming to acquire an intuitive understanding of its programming language, Bitcoin Script. Wednesday, you’ll have the opportunity to see the details of Bitcoin Script at Kris Jusiak’s presentation, and on Thursday, we’ll discuss higher abstraction level protocols such as Lightning.

–

In Kris Jusiak’s presentation, Bitcoin Script: Implementation Details and Use Cases, scheduled for Wednesday, he will present the details which make programmable money possible.

In Eduardo Madrid’s presentation, Role Playing Bitcoin Protocols Including the Lightning Network, scheduled for Thursday, with just an intuitive understanding of Bitcoin Script he will describe the higher abstraction level protocols, such as the Lightning Network.

Join us on Friday for a panel in which Eduardo, Jon, and Kris will answer Bitcoin questions.

In this session we will look at what it means to be moved-from, what impact being moved-from can have on code correctness, and we'll consider if some types should simply just be non-moveable for the sake of safe, correct code!

In this session, the hosts of CppCast, Timur Doumler and Phil Nash, will be recording CppCast Episode 390: CppCon Special at CppCon in front of a live audience. The guest for this episode is... you! This will be an interactive episode in which the audience can ask us questions directly on the show – about the podcast, our work, or anything else in the world of C++ and beyond!

Join us as we explore the cutting-edge advancements of C++26, covering both small tweaks and large-scale additions. Despite C++23 not being officially released from ISO, the C++ committee is already two-thirds through the design phase of C++26 - with less than a year left until feature freeze. In this session, we'll dive into the new features slated for inclusion in C++26, with a focus on those already present in the working draft. And particularly those already making their way into compilers and standard libraries. For sure we'll cover contracts, reflection, format, and many smaller improvements. But given the large amount of material available, we'll customize the content based on audience requests.

We'll cover a variety of topics briefly, but with enough depth to get you started. From enhanced language capabilities to powerful library additions, this session will equip you with the knowledge to leverage these upcoming features in your projects.  The session will be up to date with the latest from the summer C++ Committee meeting.

Your code is not working -- PANIC! Well, not quite! In this session we are going to show you how to write tests to uncover bugs in the first place (and to guard against regressions when they’re fixed) and how to identify the bugs’ root causes with a debugger. These two fundamental software engineering skills (debugging and testing) in combination helps us write better software by improving our confidence that bugs do not reappear -- especially as software scales and changes over time. Debugging and testing are two related skillsets, and in this talk we will provide an introduction and concrete tools showing by example how to utilize each skill together. If you have never used a debugger and think ‘if it compiles it must work’ then this is the talk for you.

Low level interactions are a core part of embedded implementations. All too often, C++ developers rely on C constructs and interactions due to prior biases around language support.  Herein we present effective leveraging of C++20 and C++23 constructs in an embedded driver code base. From using an existing C driver more effectively with modern C++ smart pointers to leveraging constexprs for bit and byte manipulation in the standard library, we will go over how you can stay on the cutting edge of the C++ language evolution in the embedded space.

C++ is well known to be used, especially when efficiency matters and you want complete control of the resulting binary.

In this talk, you will learn about tricks the Standard Template Library uses to keep data storage size small. Are you familiar with Small String Optimization? Brace yourself for uncovering yet another ingenious strategy that might surprise you.

Everybody, including me, tells you how great `constexpr` is, but do you truly believe its potential? Embark on a journey with me as we delve into a compelling example demonstrating the transformative impact of constexpr, which enhances runtime performance while reducing memory overhead.

Furthermore, I'll unveil C++ Insights' capabilities and demonstrate how it can assist your approach to designing class data member layouts, ultimately optimizing the size of your data types.

Are you leveraging uniform initialization for your data types? Let's delve into the implications, especially when initialization necessitates a std::initializer_list. C++23 has an interesting change that might help you.

I am confident that this session will equip you with invaluable insights and practical techniques that can be readily applied to improve your codebase.

P.S: You miss lambdas from the description? Well, I promise I will show you a C++23 improvement to lambdas.

Most C++ developers are familiar with the type of errors that arise when a shared library is not found. If they are really unlucky, they are have also faced a situation where the the wrong version of a library is loaded. However, a lot of us resort to suboptimal solutions just to get going, without fully addressing the root causes.

A lot of the time, we focus on the “build” process, that is, producing our binaries and executables. But getting the runtime linker/loader to locate the right libraries (and the right versions!) has a unique set of challenges that  should not be overlooked - after all, running the executables is critical for running tests, continuous integration, and obviously end-users running our apps and services.

Managing dependencies continues to be one of the top frustrations of C++ developers as per the most recents ISO C++ Developer Surveys. When it comes to shared libraries - different applications try to locate them at different times: the build system (e.g. CMake or Autotools) when configuring the build, the linker at build time, and the dynamic linker/loader at runtime.

This talk will cover in detail the different scenarios in which shared libraries need to be located, and how this is handled by package managers, build systems, and the the OS level. Emphasis will be placed on familiarizing the developer with the relevant tooling across multiple platforms, as well as associated concepts (e.g. RPATHs).

An often overlooked aspect will also be covered: how to create a self-contained, relocatable bundle for our user-facing applications, decoupled from the developer environment, as opposed to “works on my machine”.

The jump from a theoretical algorithm to a high-performant real-world implementation is non-trivial. Factors that impact performance not reflected in an academic paper must be resolved in practice, including and not limited to cache misses, machine word size limits, parallelism overheads, and differing instruction speeds.

The Ontario Research Centre for Computer Algebra (ORCCA) performs fundamental research and development in computer algebra. Part of our work involves researching and implementing high-performance, parallel algorithms in C++. In this talk, we discuss a state-of-the-art algorithm for polynomial multiplication that beats leading computer algebra systems, such as Maple (our own library) and FLINT. We focus on our experience implementing the algorithm in CUDA C++, the challenges we faced, and our solutions.

In the world of C++, efficient string handling is crucial for performance-critical applications. Enter string_view, a lightweight view into character sequences. In this talk, we’ll explore the fundamentals of string_view, its advantages over traditional string, how it compares to std::span, common pitfalls to avoid, and practical case studies for using it effectively. Whether you’re a beginner or an intermediate developer, join us to enhance your code’s performance and adopt better practices.

In game development the building and optimisation of data for the game is an important but resource intensive and time consuming process. In this talk I will describe techniques used to improve the performance and efficiency of a data build system that was developed as part of a AAA game project.

I will briefly describe the differences between how the game code and data building code operate, how those differences impact processing performance, how a profiler can be used to identify trouble spots, and describe techniques I used to improve multithreaded processing performance.

While this is coming from a game development perspective the techniques can be applied to any task based parallel data processing system.

Design patterns are everywhere, as they are the key to managing dependencies between software entities. But despite their fundamental importance, there are some common misconceptions about them, in particular about several of the most often used design patterns:

* The modern form of the Visitor design pattern, std::variant, is often considered a replacement of virtual functions
* The Decorator design pattern is sometimes mistaken as the Adapter design pattern
* The Chain of Responsibility design pattern is often confused with Decorators
* Explicit object parameters (“deducing this”) is often considered as a modern, better form of CRTP

In this talk I'll shed some light on these misconceptions and explain how to properly distinguish between the different design patterns.

C++ is often criticized for its lack of inherent memory safety, but the spectrum of potential program validations extends far beyond just memory concerns. This talk delves into the necessity of early validation, emphasizing the benefits of compile-time checks in C++. By leveraging compile-time validation, developers can catch errors and enforce constraints before the code is even executed, enhancing both safety and correctness.

A functional programming approach to compile-time validation will be discussed, highlighting its benefits and demonstrating its application in ensuring code correctness.

Moreover, the talk will delve into the realm of compile-time unit tests, showcasing how they enable developers to validate code behavior at compile time, paving the way for more efficient debugging and maintenance.

Exploring advanced features, we'll discuss existing compile-time techniques to implement lifetimes, borrow checker, and other validation rules by leveraging template metaprogramming for memory safety and how they can be improved with the upcoming C++26 reflection proposal.

Additionally, we will review language extensions and compiler-specific features that augment compile-time validation capabilities. Finally, the talk will cover the role of static analysis tools in detecting potential issues early in the development process, thus complementing compile-time techniques. Attendees will gain a comprehensive understanding of the various strategies available for enhancing program reliability through compile-time validation in C++.

Cancer research involves simulating "pseudo tumors" by sampling stochastic processes. Beginning with C++11, there were new features introduced in both the language and Standard Library that proved to be highly beneficial for simulating stochastic processes and analyzing the results. In addition, the linear algebra library Eigen, comprised of template code, makes it simple to perform matrix and vector operations in C++. Using an application in colorectal cancer research, the presentation will feature three topics in C++, namely random number generation, parallel computing, and leveraging the Eigen library.

One of the main attractions of Eigen is that it simplifies the code implementation for people who think mathematically, as the + and * operators are clearly defined in the mathematical sense of matrix addition and row-by-column matrix multiplication.  This talk highlights this aspect by demonstrating how to express the simulation of a stochastic cancer modeling process in C++, a problem that is well formulated in terms of matrix operations.

Simulating these stochastic processes also requires drawing random numbers. Before the new <random> capabilities in C++11, users typically needed to patch together their own uniform random number generators, as well as transformations to their desired distributions such as the Poisson and exponential distributions, which required a large amount of time for implementation and testing. This talk will show that by using methods such as std::discrete_distribution and std::exponential_distribution in <random>, constructing a random process simulator is technically simple in C++.

Cancers with seemingly similar initial conditions may develop into drastically different conditions. Much attention has been paid to events with high variability. To test a theoretical model, a huge number of simulations needs to be done to capture this variability. Therefore, concurrency is in reality a requirement rather than an option. In this application, parallel versions of certain STL algorithms introduced in C++17 are used to obtain descriptive statistics on the simulated data. In addition, an application of task-based concurrency will be used for replacing multithreaded computing formerly based on the pthread library.

In sum, this talk provides an example of using modern C++ in computational biology, with a goal of showing the C++ community that computational biology is a growing domain for applying modern C++ to general science.

C++20 introduced "views" as easy-to-use building blocks for processing the elements and values of containers and ranges.
The filter view is one of the key views, because filtering collections of data to process only elements that satisfy a specific constraint or requirement is one of the most important use cases of dealing with ranges and views.

Unfortunately, the filter view is also one of the most surprising C++ standard views. Even for simple use cases, you can easily get:
- Unexpected functional behavior
- Surprising compile-time errors with cryptic error messages
- Fatal runtime errors (without even noticing them)

There are reasons for the design of the filter view. For a successful filtering of elements you should know and understand the design and all of its consequences.

The talk will demonstrate all the issues with simple real-work examples and explain both the motivation and consequences if this design in practice. Listen and learn aspects you would not expect but have to know when using the filter views and views in general.

XOffsetDatastructure is a serialization library designed to reduce or even eliminate the performance consumption of serialization and deserialization in the game industry by utilizing zero-encoding and zero-decoding. It is also a collection of high-performance data structures designed for efficient read and in-place/non-in-place write, with performance comparable to STL. 

Custom allocators are used to keep fields in contiguous memory, enabling them to be sent directly. Offset pointers are used to maintain pointer validity after buffer resizing and memory movement caused by modifications to variable-size fields. Some other techniques, such as containers that support offset pointers and auto-resizing mechanisms, are involved.

The performance statistics demonstrate that XOffsetDatastructure is a high-performance library, offering advantages in terms of encoding and decoding time, read and write performance, and message size compared to other modern C++ serialization libraries.

This is the story of a design collaboration between a member of our code governance team and a C++ developer leading the effort to update tools that generate C++ code from schema. Through a two year collaboration, we crafted guardrails to a complex system that allowed maximum flexibility to exist alongside common sense restrictions in a single system. We did so successfully thanks to the input and consensus of our huge C++ developer community.

Bloomberg's C++ code generator was created 18 years ago to simplify the task of writing services and code to call those services, freeing up engineers from writing boilerplate code and allowing them to concentrate on writing code that provides business value. The code generator is so popular that it is used beyond services, with hundreds of developers relying on it to also create C++ value semantic types. As a long-lived project, the generator has evolved over the years to support many scenarios and options. While this versatility has been hugely valuable, having so much additional flexibility also created a huge support surface for the tool owners and also burdened users with questions about which options are optimal for their use cases.

Two teams began exploring this problem separately. One focused on updating the code generator while the other looked into how the generator was being used across the company. Progress sped up appreciably when we realized we could combine our expertise in outreach and design. We began a focused conversation with the firm's broader engineering community, which led to key changes to the code generator, the creation of directed CMake modules, the introduction of new rules and validations, and the development of clearer documentation. We put an end to longstanding misunderstandings that had been causing users to make mistakes. Finally, we gave our engineers  a clear outreach path to request new features.


Key takeaways:
* Development and outreach teams working together can make targeted technical improvements to a C++ codebase, and to the developer experience.
* An outreach team can bring existing community relationships, as well as dedicated time, to research larger issues. This gives developers a chance to have a say in designing best practices, in addition to allowing infrastructure teams to make improvements, without bringing other important work to a stop.
* Creating a well-lit path for a tool's usage avoids pressure on developers to craft ad hoc solutions that are unintended and inadequately tested by the tool's creators and maintainers.
* People will do the right thing when everyone involved understands what the right thing should be. Your organization's codebase will benefit.

Computational Fluid Dynamics (CFD) codes are ubiquitous in high performance computing. Their computational demands require the use of all levels of parallelism provided by the hardware. This includes the SIMD units of today's processors, which provide one level of data parallelism. With `std::simd`, it becomes possible to address these units directly from C++.

The talk reports on our work on the vectorization of a CFD code. The focus will be primarily on the way we have expressed vectorization using `std::experimental::simd` and less on the achieved performance gains. In this context, we have developed a library that complements `std::simd`. The goal of this library is to make loading and saving `std::simd` variables syntactically equivalent
to loading and saving their scalar counterparts. Loop bodies written for scalar variables can then be used for `std::simd` variables without modification. The talk also discusses some possible improvements to C++, since this goal can currently only be achieved by using a macro.

It is no secret that managing C++ dependencies is a serious challenge, especially for larger projects. It is consistently cited as a top pain point in ISO C++ developer surveys. The C++ community has been asking for a standard C++ build system and package manager, but we need solutions that we can put into practice today. So, what do we do, especially at larger companies with complex needs? C++ package managers exist and are growing, but there are still many companies hesitant to adopt them.

In this talk I will present what I learned from talking to over 15 large software teams working with C++. Some had already adopted a package manager, many had not. I will go over their challenges with managing C++ dependencies and how they overcame them. The goal is to share some learnings and hopefully generate a discussion in our community about how we can make our development experience less painful.

Bring your questions for our annual panel of C++ standards committee members! Here are this year’s panelists, and some of the key current features they’re actively involved with that are aiming for C++26 and other near-future ISO C++ evolution:

• Andrei Alexandrescu (reflection, parallelism)
• Daisy Hollman (ranges, library)
• Dietmar Kühl (std::execution, concurrency, parallelism)
• Gabriel Dos Reis (contracts, type and memory safety)
• Khalil Estell (making exceptions affordable including in firmware/embedded)
• Lisa Lippincott (contracts, numerics)
• Michael Wong (AI, ML, parallelism)
• Nina Ranns (C and C++ evolution coordination, committee secretary)
• Timur Doumler (contracts)
• Panel moderator: Herb Sutter (committee chair)

Some are long-serving attendees and national/subgroup chairs, some are newer attendees with fresh perspectives, and all have firsthand information about current progress in the C++ standard.

Come join us to ask and hear about these and more things to look forward to in Standard C++!