CppCon 2024

Some of the best C++ instructors in the community will be available to answer your questions about how to convince your boss to bring them to you company.

When delving into Object-Oriented Programming (OOP) in C++, we encounter several pivotal decisions. Questions arise: which data members should be private, public, or protected? Should we solely inherit from a class, or is there a need to modify the base class behavior? And when do we necessitate a virtual destructor? Moreover, are there scenarios where certain member functions cannot be virtual?

Understanding the concept of a virtual member function is crucial as it allows polymorphic behavior. Delving deeper, one might wonder about the compiler's implementation of this mechanism.

Integrating virtual functions with other features, like default parameters, demands careful consideration. This talk will explain why that's the case.

Oh, and by the way, the classic question is, what is the difference between struct and class? Come to my talk to get answers to all these questions.

By the end of this talk, you will depart with a lucid comprehension of OOP subtleties in C++, along with an acute awareness of potential pitfalls.

This session will feature detailed case studies that measure the overhead associated with common programming abstractions in the context of embedded systems. By examining both compile-time and run-time implications, attendees will gain valuable insights into how these abstractions impact system resources like memory usage and execution speed.

Key areas of exploration will include:

- **Encapsulation**: Assessing the cost of data hiding and interface protection depending on implementation strategies.
- **Inheritance**: Evaluating the costs and benefits of using class hierarchies in environments where memory and processing power are limited.
- **Polymorphism**: Comparing run-time polymorphism via virtual functions to compile-time alternatives like templates and concepts, analyzing their respective impacts on performance and flexibility.

Through empirical data and performance metrics, participants will observe how traditional object-oriented techniques affect resource utilization. The discussion will also cover the advantages and trade-offs of these techniques, providing a balanced view of their impact on embedded systems.

Designed for developers and system architects working within the constraints of embedded systems, this talk aims to provide valuable insights into making informed decisions about when and how to use specific programming abstractions. Attendees will leave with a clearer perspective on optimizing their code for maximum efficiency, armed with practical knowledge about the trade-offs involved in adopting various software design paradigms.

Meta-programming is one of the most significant C++ superpowers. It enables seemingly impossible feats, but there is a considerable cost associated with it as well. Therefore, its applications have been limited to experts and cases where the benefits greatly outweigh the maintenance burden.

But what if that doesn't have to be the case? In this talk, we will explore an alternative approach to template meta-programming that does not require an understanding of the traditional 'angle bracket' technique.

We will also make the case that anyone who can write C++ can become a meta-programming guru! But what about compilation times and/or testing/debugging, you may ask? Well, we will cover those as well, and it might be surprising what modern C++ is actually capable of!

Additionally, we will cover how the static reflection proposal and C++20 ranges can further improve the ability to write meta-functions and how C++ compares to other languages such as circle. However, we will also show how to apply the technique with C++17 on all major compilers with a ready-to-go solution.

Finally, we will benchmark compilation times of different approaches, showcasing their strengths and weaknesses.

If you are interested in meta-programming or have always wanted to understand its practical use cases but never really grasped them, this talk is for you!

Session types are the next big thing that will ensure correctness of communication code, and thus make concurrent and distributed software more reliable and easier to construct... at least some people view them that way; although they might also be viewed as just a new weird thing from type theory realm ("functional programming stuff") devised by overly enthusiastic mathematicians, but which is too complicated and cumbersome to be of practical use. Whichever is your own point of view on the line between these two extremes, come to this journey through the first know implementation of session types in C++ if you want: to see the main idea of session types explained in practical programming terms, to understand how and when session types might be useful, or just to enjoy exploring the limits of C++.

The talk targets wider audience, and does not require any strong mathematical background. In the first part, it sets up a working definition of a type, discussing a few different perspectives, and gives a short overview of some models of asynchronous communication. In the second part, an implementation of session types is presented. The implementation is evaluated on an example, and some remaining challenges are described.

C++20 modules represent a significant advancement in the language, promising to improve compile times, enhance code organization, and streamline dependency management. This talk is tailored for developers eager to harness the power of C++20 modules in their projects. We will explore the fundamentals of building both shared and static libraries using CMake, the de facto build system for C++.

Attendees will gain practical insights into setting up build files and organizing source code with modules. We will dissect real-world open-source module projects, offering a concrete understanding of how modules are being used in the wild. A key focus will be on the "import std" model, demonstrating how to create a module interface for large, existing libraries, facilitating a smoother transition to modular codebases.

Significantly, CMake released non-experimental support for C++20 modules in October 2023, marking a pivotal moment for developers. Visual Studio, Clang and GCC all have some level of support for modules. However, the adoption of this feature is still in its early stages, with relatively few projects currently leveraging it. This session will bridge that gap, providing the essential knowledge and hands-on techniques to confidently integrate C++20 modules into your development workflow.

By the end of this session, participants will be equipped with the knowledge to effectively use CMake for building projects with C++20 modules, making the most of this cutting-edge feature to enhance their codebases. Whether you're maintaining legacy code or starting a new project, this talk will provide the essential tools and techniques to master C++20 modules.

This talk will highlight the key discussions in ISO C++ parallelism and concurrency related proposals since the last CppCon discussed in the Kona 2023, Tokyo 2024, and St. Louis 2024 C++ standard meetings. We aim to update CppCon attendees every year in this area. We focus on features that are close to standardization, and/or appear to be relatively non-controversial so that you get a look ahead on what is coming for the next C++ release.

This talk, by the Concurrency TS2 Editors will describe all the features and show how they can be used as well as give their motivation, background and how they fit within the overall framework of C++ parallelism and concurrency.

1. Atomic
2. Hazard pointer extensions
3. Pointer Tagging
4. Parallel Algorithms, Parallel Range algorithms

There are other features being discussed at these meetings, but they are still in development and could still change. So we focus on those features that seem close to approval, interesting, and/or are relatively non-controversial. We will show the use cases of each and describe how some of them are already heading to C++26 or beyond. This will help programmers in concurrency, lock-free programming, low-latency applications how to take advantage of each of these important facilities.

Rvalue references and move semantics, introduced in C++11, were an important addition for the way we manage resources and optimize performance in our code.
However, mastering these concepts can be challenging, leading to common pitfalls and misunderstandings.

In this session, we will demystify rvalue references and move semantics, covering their underlying principles, practical applications, and best practices. We will start with the fundamentals of what rvalues are, how to implement and use move semantics correctly, covering the delicate syntax rules, then discuss design considerations and guidelines. We will cover the rule-of-zero, rule-of-three and rule-of-five, the need for std::move and when to use it, as well as forwarding references and std::forward.

By focusing on the applicability of the subject, and with a clear and concise exploration of the fine details, participants would gain a solid understanding of how to master rvalue references and move semantics in their own codebase, with the ability to write more efficient and robust C++ code.

Ever wrestled with an embedded unit that had a mind of its own? That was my reality a few years ago.
This unit, built with Linux, C++, and QT, was designed to be a reliable middleman, handling RF frames from a multitude of endpoints.
But it was a bit of a wildcard - unexplained resets, occasional data loss, and all.
It was supposed to support 7500 endpoints, but once we hit 5000, it started to show signs of strain.

The software was a tough nut to crack - maintaining it was a challenge and it wasn't exactly a developer's favorite.
But here's where the plot thickens: after two years of relentless work, we transformed this underdog into a champion.
The unit now supports 10,000 endpoints, with zero resets or data loss.

Intrigued? Join me as I unravel the journey of this remarkable turnaround.
Let's dive into the world of embedded systems and explore how we turned the tide in our favor.
It's a tale of performance improvements, overcoming challenges, and making the impossible possible.
If you've ever wondered how to boost efficiency in embedded systems, or if you're just a fan of a good tech turnaround story, this talk is for you.

A practical guide to bridging the gap between C++ and Rust. We cover bindings, including a manual approach, and compare them with generated bindings using CXX.  We also show how to link CMake with Cargo and link with transitive C++ dependencies using Conan.

Code reflection is an extremely valuable feature for many areas in programming. By allowing you to reason about code as data. Reflection can be used for e.g. Serialization, Networking and content editors.

However, since reflection is not a C++ language feature yet. I will use a new tooling opportunity: ".ifc" Binary Module Interface files to implement a reflection library. Made possible by Gabriel Dos Reis‘s efforts to open source [the specification of MSVC’s Binary Module Interface](https://github.com/microsoft/ifc-spec).

This approach solves issues of current C++ reflection libraries. Which either rely on manual typeinfo registration, leading to constant work to keep them in sync. Or parsing C++ source code which is slow and needs deep integration into your desired build system.

Join Eduardo, Jon, and Kris for an open discussion of the Bitcoin protocol, including implementations and implications.

* Note: We will avoid any discussion of partisan politics and will not give legal, financial, or tax advice.

Come to one of my favorite talks to give! In this session we'll discuss the wide range of tools available to the modern C++ developer, why, and how to use them for the highest code quality.

For multiplayer games, deterministic simulations have been a Holy Grail for a long while. Indeed, if we have perfectly deterministic simulations - we can simply pass all the inputs to all the clients, and rely on each client to produce the same results, reducing network traffic by orders of magnitude. While especially important for RTS games, all kinds of multiplayer games would benefit from it.
However, while determinism was achieved in practice for single-platform, it is known to be a next-to-impossible to achieve for cross-platform clients. We will discuss the (well-known) reasons for it first - and will proceed into discussing our approach to the solution (with our open-source lib actually providing some implementations).
This talk is important for multiplayer gamedevs - and for anybody who is interested in deterministic calculations.

Have you ever wanted to run a Llama 2 model in C++? In this talk, we'll dive into C++ techniques for Llama 2 model inference. We'll start with a model trained in PyTorch and explore different ways to implement the inference solution for the Llama 2 language model, focusing on keeping things simple and minimal.

Llama 2 is a cutting-edge language model that's making waves in the field of natural language processing. It can generate human-like text, understand complex language tasks, and is used in everything from chatbots to content creation. Its efficiency and accuracy are setting new industry standards, making it an invaluable tool for developers and researchers.

Inspired by the awesome llama.cpp and llama2.c projects, this talk aims to show a simple and educational approach. We'll hard-code the Llama 2 architecture and create the inference in pure C++ with no dependencies. Join us to learn how to build Llama 2 models efficiently using a streamlined and dependency-free C++ solution. If time allows, we will also explore additional C++ techniques for fast Llama 2 model inference.

By the end of the talk, you'll have an understanding of what Llama 2 is and how it works. You'll also learn practical ways to implement the Llama 2 model inference in C++ and potential optimizations.

Could we revisit numerical integrators in the light of C++26 and bring more genericity, performance, and expressivity to the domain? In this talk, we will explore how modern C++ techniques can add something new and relevant to one of the oldest and most basic task of scientific computing: the integration of systems of equations. We will examine, in particular, how most numerical integrators can be derived from a small set of first principles that can be easily mapped onto C++ concepts and composable algorithmic building blocks. One of the goal of the approach introduced in this presentation will be to achieve as much as possible with the simplest and smallest amount of code. C++23 and C++26 programming techniques, including reflection, will be leveraged to transfer some of the burden of implementation to the compiler while still ensuring maximum performance.

In practice, the talk will combine aspects of high-performance computing, numerical methods, and software architecture. We will start by summarizing recent discoveries made in applied mathematics on Runge-Kutta methods, linear multistep methods, and general linear methods to see how it can help design better abstractions that can be translated into C++ concepts. We will then examine how a few carefully crafted algorithmic building blocks can be combined to generate the whole diversity of numerical integrators from first principles. The automation of this approach using C++23 and C++26's reflection to make the compiler generate highly efficient code will be then discussed in great length. Next, we will dive into parallelization strategies, including distributed ones as well as heterogenous computing. Some perspectives will also be given on the possibility for the compiler to branch on the best integrator given the mathematical properties of a system of equations as well as ways to derive new integrators at compile-time.

To illustrate our approach, we will examine the behavior and performance of numerous integrators on several real-world problems including a supercomputing N-body code for cosmology that simulates the gravitational dynamics of large scale astrophysical structures in an expanding Universe. A great care will be taken to make all the code and examples as reproducible and standalone as possible so that most of the presented content can simply be copied and pasted to make it work everywhere. Finally, even if the talk will focus on the particular case of numerical integration, the methodology presented in this talk will be applicable everywhere in scientific computing and beyond to achieve better software architecture in technical contexts.

This isn't a talk about why you shouldn't use ranges in your C++20 codebase—unless you work on one of the largest codebases in the world, you probably should. This is a talk about the differences between most programming tasks and software engineering at truly gargantuan scales—and about how it isn't always practical to use the same components of a language in such different contexts.

Ranges are perhaps the largest and most ambitious single feature ever added to the C++ standard library since its inception. They have modernized C++ to match the way the current generation of programmers thinks about iteration and loops, largely owing to the influence of dynamically typed languages like Python and Javascript. Every programming language feature comes with a set of trade-offs, though, and it's unreasonable to expect that those trade-offs will result in the same cost-benefit ratio in every context. At Google, the decision to ban the `<ranges>` header from our C++ codebase continues to be extremely controversial, with nuanced arguments on both sides of the discussion. This talk will summarize those arguments, from broad topics like the diffusion of functional programming paradigms in large codebases, to mutability of concept-driven designs over large time scales,  to technical deep-dives on the inner workings of range adapters and the consequences thereof at scale. We'll conclude with a discussion of what this means for the future of ranges and why Google continues to invest in the ranges study group of the C++ committee.

If you want to find out all the new features and improvements we've made to Visual Studio, MSVC, and vcpkg for C++ developers in the last year, this is the talk for you.

The last year has seen a huge explosion in AI tooling. In Visual Studio, this comes in the form of GitHub Copilot: an AI pair programmer for providing in-editor suggestions, answering questions through a chat interface, and more.

Outside of AI, we've continued to improve the core Visual Studio experience regardless of the platform you're targeting. For example, we've made improvements to our CMake and remote Linux support, our Unreal Engine experience, tools for memory layout visualization and #include cleanups, new visualizations for C++ Build Insights, in-editor support for GitHub pull requests. Of course, we've also continued work on C++ standards conformance and the code generation of the MSVC compiler.

You'll see all of these features in action in a real-world codebase to see how they can improve your day-to-day development by augmenting your existing workflows and giving you new utilities to add to your toolbelt.

The mandate for C++ is to deliver uncompromised performance and leave no room for a lower level language.
This presentation looks at C++’s superpower for delivering on this mandate. We explore this both to understand how to write better C++ code and to better understand how to evolve C++.
We’ll look at several examples showing how this superpower is applied in different ways, including one of the most controversial issues facing the C++ community today.

Modern video games are complex beasts that contains multiple systems interacting with one another storing, transferring and processing large sets of data in real time. While some data structures from the standard library such as the std::vector gets you by 90% of the time you need to store and process data, there will be the occasional 10% that requires a unique take.

This presentation aims to discuss the unique data structures that are commonly used in video games / game engines that caters to the occasional 10%. We will go over several systems outlining their requirements, constraints and present custom data structures that gets the job done.

Motion planning is a crucial capability for robots operating in unstructured environments, enabling them to navigate and interact with their surroundings safely and efficiently. However, motion planning algorithms are computationally expensive, often requiring hundreds of thousands or millions of evaluations of subroutines, such as forward kinematics, collision checking, and nearest neighbor lookup.

This talk will present an approach to accelerating motion planning subroutines, specifically focusing on forward kinematics calculations, through compile-time optimizations. The proposed method leverages code generation techniques to directly translate Unified Robot Description Format (URDF) into optimized C++ code. Additionally, by generating hardware-specific code, such as CUDA for parallel computations, significant performance gains can be achieved. Throughout the presentation, I will compare and benchmark the compiled URDF to a naive implementation of forward kinematics and evaluate the performance impact of certain design decisions, such as memory layout and compiler flags.

The presentation will demonstrate how the aforementioned code generation process can be seamlessly integrated into the C++ build process using CMake and Jinja templates, enabling easy adoption. Attendees will gain insights into the benefits of compile-time optimizations for performance-critical applications and learn how to leverage this approach to enhance the efficiency of their own robotics or computationally-intensive systems.

Standard C++ provides a few functions to convert a double or float value to string, namely, sprintf, stringstream::operator<<, snprintf, to_string, to_chars and format.

This talk concerns what goes on behind the scenes, i.e, the algorithms which these functions might use to do their job. Curiously, many of these algorithms have dragon-related names like Dragon, Grisu, Errol, Ryu and Dragonbox.

Here mythology meets technology and we shall introduce the new dragon that has just arrived in the den.

(Please leave your bows and arrows at home, they won't be necessary here.)

All code is legacy code, or so they say. Software engineers scoff at the idea of new code instantly becoming legacy code, however software is a time capsule holding the design trends of the time the code was written. As new code is written, new design trends are used and potentially overused, just like the legacy patterns. What if these new design trends have more in common with the original design trends than we initially thought. One example we will investigate is object oriented design through polymorphism and how it has been replaced in many cases with template metaprogramming. There are a variety of template metaprogramming strategies that achieve the object oriented design principles, however when overused you can encounter as many templates as there would be virtual functions in object oriented programming. Have we discovered that balance is the solution or are we still overusing the “fancy” new thing? In this talk, we will investigate various legacy design trends including further examining object oriented design, the singleton pattern, as well as other legacy anti-patterns to reveal the updated trends. We will address each legacy anti-pattern and their corresponding modern update to evaluate whether newer is better or if we have recreated the same legacy problem.

In less than a year since its original publication, the WG21 proposal “Reflection for C++26” (P2996) has made good progress towards its titular goal.  From its inception, we intended that design to offer a modest-but-useful set of features with a solid foundation on top of which we will be able to incrementally grow an easy-to-use, rich, and extensible C++ meta-programming framework.  This keynote will review some of the fundamental tools proposed in P2996 and follow up with a vision for some additional capabilities that we’re working on.