Events : Standard C++

Home » Blog » Categories » Events

« Prev Next »

Events

CppCon 2023 Building Consensus on a Set of Rules for Our Massive C++ Codebase -- Sherry Sontag

By Blog Staff | Sep 23, 2023 08:00 AM | Tags: None

Registration is now open for CppCon 2023! The conference starts on October 1 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 2023!

Building Consensus on a Set of Rules for Our Massive C++ Codebase

Friday, October 6 • 09:35 - 10:05

by Sherry Sontag

Summary of the talk:

In this talk, we will trace our efforts to build consensus across our Engineering department on how we use C++ at Bloomberg. We will use the example of how we are introducing broader naming conventions across the company’s massive C++ codebase, impacting our package management infrastructure and build tools. We will describe the lessons we’ve learned and the pitfalls we fell into as we were trying to achieve that goal, so that attendees can apply these lessons within their own organizations when introducing their own set of C++ rules.

This will also highlight the value of journalism skills in approaching engineering questions. Most important are the willingness to seek out all sides of a question; being humble enough to truly listen to even your loudest critics; and the endurance to keep asking questions until the issues become completely clear.

Our effort involved input from more than 150 people across many different application and infrastructure teams, many with different needs and coding styles. We then developed a set of rules that worked, though we also realize that the right answer will likely require ongoing flexibility.

CppCon 2023 Undefined Behavior: What Every Programmer Should Know and Fear -- Fedor Pikus

By Blog Staff | Sep 22, 2023 06:20 PM | Tags: None

Undefined Behavior: What Every Programmer Should Know and Fear

Thursday, October 5 • 09:00 - 09:30

by Fedor Pikus

Summary of the talk:

This talk is about You-Know-What, the thing in our programs we don’t mention by name.

What is this undefined behavior every C++ programmer has grown to fear? Just as importantly, what it isn’t? If it’s so scary, why is it allowed to exist in the language?

The aim of this talk is to approach undefined behavior rationally: without fear but with due caution. We will learn why the standard allows undefined behavior in the first place, what actually happens when a program does something the standard calls “undefined,” and why it must be taken seriously even when the program “works as-is.” As this is a practical talk, we will have live demos of programs with undefined behavior and sometimes unexpected outcomes (if you are very lucky, you might see demons fly out of the speaker’s nose). Also, as this is a practical talk, we will learn how to detect undefined behavior in one’s programs, and how to take advantage of the undefined behavior to gain better performance.

CppCon 2023 Problems and Solutions Using Coroutines In a Modern Codebase -- Francesco Zoffoli

By Blog Staff | Sep 22, 2023 11:18 AM | Tags: None

Coroutine Patterns and How to Use Them: Problems and Solutions Using Coroutines In a Modern Codebase

Thursday, October 5 • 09:00 - 09:30

by Francesco Zoffoli

Summary of the talk:

In over 30 years of experience the C++ community have developed patterns that are effective in writing complex systems. The introduction of coroutines introduced a brand new paradigm, but it changes many of the assumptions of the past. In this talk we'll see common patterns and pitfals that arise using coroutines, and what solutions are needed to address them.

Based on the experience working with a heavily coroutinized codebase, this talk will show a collection of common patterns that arise using coroutines. The patterns will cover from code that the compilers today block, to effectively managing resources with RAII, to the need and risks of synchronization. It will present ways to make the code correct, workarounds to obtain the same outcome, or will warn about potential issues that can arise from such patterns.

The code shown is going to be based on Facebook's Folly implementation of coroutines, but the concepts presented are common across other implementations as well (no previous knowledge of Folly is required).

This talk is perfect for practitioners that already are trying coroutines in their codebase and want to ensure the code they're writing doesn't contain hidden bugs, but also for people that haven't used coroutines yet and they are evaluating introducing them in their codebase.

Do you want to discover the new patterns to write correct code with coroutines? Join us for this exciting talk!

CppCon 2023 Symbolic Calculus for High-performance Computing Using C++23 -- Vincent Reverdy

By Blog Staff | Sep 21, 2023 06:14 PM | Tags: None

Symbolic Calculus for High-performance Computing From Scratch Using C++23

Wednesday, October 4 • 16:45 - 17:45

by Vincent Reverdy

Summary of the talk:

Wouldn't it be nice to be able to type and manipulate symbolic mathematical formulas directly in C++? On top of providing a much more natural interface for scientists to express their ideas in code, it would constitute a particularly relevant approach to disentangle scientific application domains on one side, and high-performance computing and low-level optimizations on the other side. In this talk, we will see how building symbolic calculus tools can be achieved in plain C++23 without any compiler magic. We will see how symbolic derivatives and integrals can be computed at compile-time and we will see how the technique can be leveraged to speed-up linear algebra computations. A particular focus will be given to the concepts and to the building blocks so that the approach can be easily tweaked and adjusted to other problems, and it will be shown that the decoupling of concerns allows to combine genericity, expressivity, and high-performance in code.

In practice, we will dive into a new take on expression templates that modern C++ makes much easier to handle. In particular, we will introduce stateless formulas as a way to avoid some of the complexities that use to make traditional expression templates especially difficult to manage in codebases. We will see how Class Template Argument Deduction and unevaluated lambdas as template parameters can be combined to produce uniquely typed symbolic variables that will serve as the atoms of symbolic formulas. Implementation strategies to optimize both compile-time and runtime performance will be discussed. The talk will be illustrated with numerous examples together with their corresponding generated assembly code to show that the zero-cost abstraction principle is ensured by the set of presented techniques. Beyond the technical aspects, a broader discussion will be opened on how this approach can be combined with existing and upcoming linear algebra components of the C++ standard library (mdspan, mdarray, BLAS...) to ensure the highest level of performance when it comes to scientific computing.

The goal of this talk is really to highlight the overall strategy of implementation and the set of techniques necessary to bring symbolic calculus into high-performance code and make it as accessible as possible so that everyone can play with it. The evolution of C++ has made it much simpler to implement such things.

CppCon 2023 Optimizing Robotics Algorithms With C++'s Compile-Time Features -- Stephen Brawner

By Blog Staff | Sep 21, 2023 02:11 PM | Tags: None

Robotics at Compile Time: Optimizing Robotics Algorithms With C++'s Compile-Time Features

Wednesday, October 4 • 16:45 - 17:45

by Stephen Brawner

Summary of the talk:

Development of real-time software for robots allows for strategic use of compile-time programming techniques to optimize performance, latency, and memory usage. The speaker will present how template metaprogramming, the constexpr family of features, concepts and std::enable_if can benefit robotics algorithms and code through concrete examples. Beyond optimization, the speaker will discuss how these features can also enable many safety-critical checks before run-time. The speaker's goal of this talk is for attendees both in robotics and outside to learn how they may be able to move more of their software's evaluation to the compiler.

The speaker's examples will include common robotics programming tasks like kinematics, collision checking, and cartesian control. Historically, robot-agnostic software for these tasks was written to be compiled once and deployed across numerous robotics platforms. This necessitated hardware description files to be ingested on startup and then verified before operating the robot. These approaches require dynamic memory allocation, run-time polymorphism and other approaches that prevent compiler optimizations, static analysis and are not compatible with real-time operation. For many applications in robotics, however, the requirements of the robotics platform are known well in advance and can be leveraged to generate software heavily optimized by the compiler.

CppCon 2023 How to Build and Deploy Your First C++ Automated Refactoring Tool -- Kristen Shaker

By Blog Staff | Sep 21, 2023 10:03 AM | Tags: None

How to Build and Deploy Your First C++ Automated Refactoring Tool

Wednesday, October 4 • 16:45 - 17:45

by Kristen Shaker

Summary of the talk:

Your company is large; You have a lot of C++ code and a lot of engineers writing C++, but you have a limited number of C++ experts. How do you ensure new developers follow C++ best practices and your company’s style guide? How can you scale the knowledge of your C++ experts as your company and code base grows?

Clang provides a rich assortment of tools that can proactively identify and improve problematic code. What are these tools? How can you use them?

This talk introduces the fundamentals of clang refactoring capabilities and discusses their practical applications as they relate to your code base, ensuring only correct, idiomatic C++ lands without excessive toil.

Highlighting the program for Meeting C++ 2023

By Meeting C++ | Sep 21, 2023 09:23 AM | Tags: meetingcpp events community

The first version of the schedule of Meeting C++ 2023 is live!

Highlighting the program for Meeting C++ 2023

by Jens Weller

From the article:

While there is still some changes coming, I wanted to highlight the released schedule of Meeting C++ 2023. The conference it self is less than 2 months away (12th - 14th November).

The program will feature 3 keynotes (1 per day) by Kevlin Henney, Lydia Pintscher and Ivan Čukić...

CppCon 2023 Object Introspection: A Revolutionary Memory Profiler for C++ Objects -- Haslam/Sarwade

By Blog Staff | Sep 20, 2023 05:59 PM | Tags: None

Object Introspection: A Revolutionary Memory Profiler for C++ Objects

Wednesday, October 4 • 15:15 - 16:15

by Jonathan Haslam and Aditya Sarwade

Summary of the talk:

This talk presents a new open source technology for the Linux platform that we have developed and deployed at Meta. It enables you to observe the precise memory footprint and composition of your C++ objects in live applications including their containers (even user-defined ones!) and all dynamic memory allocations. This is achieved with no code modification or recompilation using regular DWARF debug data.

We provide two different approaches for introspecting objects, (1) a profiler that operates on a target process and (2) APIs that allow you to introspect objects directly from within your application code. We describe the core technology underlying both mechanisms followed by details of how the two approaches work and how they can be used. We will give code examples demonstrating the types of efficiency improvements made in our C++ source base and demonstrate just how easy it is to make significant efficiency improvements in your code when you have the data in hand. As this technology is open source we hope it will inspire you to leave here fired up to introspect every object that is now in sight!

Understanding the detailed memory footprint of your C++ objects in live applications allows you to develop code to more efficiently utilize memory and CPU. Existing tools and techniques in this space are extremely thin on the ground and tend to be prohibitively intrusive for real world applications in production environments and provide partial information at best. We are on a mission to elevate the observability of data to the same level as code.

https://github.com/facebookexperimental/object-introspection

CppCon 2023 Coping With Other People's Code -- Laura Savino

By Blog Staff | Sep 20, 2023 01:56 PM | Tags: None

Coping With Other People's Code

Wednesday, October 4 • 16:45 - 17:45

by Laura Savino

Summary of the talk:

Sometimes we're fortunate enough to work with a small group of devs who share our coding values, and when we see their PRs come in, we nod along and say, "Yup, that's what I would have done. Oh, nice, that one's even better than my usual approach, I'd better tuck that idea away for next time."

This perfect alignment is precious... and particularly elusive in C++. Most of us are living in codebases that are profitable, complex, and updated in ways with which we have legitimate beef. How can we keep a sense of curiosity, progress, and satisfaction amidst patterns we would never have chosen?

This presentation explores the often-overlooked social aspects of C++ development, offering both practical tools and light-hearted commiseration. We'll draw from the field of behavior science to build strategies that address conflicting design patterns and the strong opinions that come with them.

CppCon 2023 Is std::mdspan a Zero-overhead Abstraction? -- Oleksandr Bacherikov

By Blog Staff | Sep 20, 2023 09:54 AM | Tags: None

Is std::mdspan a Zero-overhead Abstraction?

Wednesday, October 4 • 15:15 - 16:15

by Oleksandr Bacherikov

Summary of the talk:

C++23 introduces std::mdspan into the standard library as a view over multi-dimensional arrays. This talk will try to establish some of the best practices for using mdspan, and highlight subtleties to be aware of. Taking some basic matrix and image operations, we'll compare the generated assembly to low-level implementations similar to BLAS, and check if mdspan can be used in a way to avoid any overhead. We'll discuss how the results are affected by mdspan design decisions and ABI limitations.