Events : Standard C++

Home » Blog » Categories » Events

« Prev Next »

Events

CppCon 2023 Visual Studio: Make Debugger, Diagnostics Improvements, Video Games, & More -- Li/Girmay

By Blog Staff | Sep 14, 2023 11:40 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!

What's New in Visual Studio: CMake Debugger, Diagnostics Improvements, Video Games, and More

Tuesday, October 3 • 15:15 - 16:15

by David Li and Mryam Girmay

Summary of the talk:

Another year of CppCon, another year of work on making Visual Studio a better IDE for everyone, no matter what platform you're targeting.

In this talk, we'll demonstrate the last year's work across the IDE, toolchain, vcpkg, and GitHub: leak sanitizer and advanced address sanitizer support for finding security holes, a host of tools for Unreal Engine, the new CMake Debugger, step-by-step macro expansion, and more. Catch up on improvements for highlights from previous years, such as Build Insights integration in Visual Studio and new tools for understanding complex template compilation errors

Come along to learn all about the latest in our tooling, and to get a peek into our future plans.

CppCon 2023 std::linalg: Linear Algebra Coming to Standard C++ -- Mark Hoemmen

By Blog Staff | Sep 14, 2023 08:37 AM | Tags: None

std::linalg: Linear Algebra Coming to Standard C++

Tuesday, October 3 • 15:15 - 16:15

by Mark Hoemmen

Summary of the talk:

Many fields depend on linear algebra computations, which include matrix-matrix and matrix-vector multiplies, triangular solves, dot products, and norms. It's hard to implement these fast and accurately for all kinds of number types and data layouts. Wouldn't it be nice if C++ had a built-in library for doing that? Wouldn't it be even nicer if this library used C++ idioms instead of what developers have to do now, which is write nonportable, unsafe, verbose code for calling into an optimized Fortran or C library?

The std::linalg library does just that. It uses the new C++23 feature mdspan to represent matrices and vectors. The library builds on the long history and solid theoretical foundation of the BLAS (Basic Linear Algebra Subroutines), a standard C and Fortran interface with many optimized implementations. The C++ Standard Committee is currently reviewing std::linalg for C++26. The library already has two implementations that work with C++17 or newer compilers, and can take advantage of vendor-specific optimizations. Developers will see how std::linalg can make their C++ safer and more concise without sacrificing performance for use cases that existing BLAS libraries already optimize, while opening up new use cases and potential optimizations.

CppCon 2023 Leveraging a Functional Approach for More Testable and Maintainable ROS 2 -- Bilal Gill

By Blog Staff | Sep 13, 2023 08:02 PM | Tags: None

Leveraging a Functional Approach for More Testable and Maintainable ROS 2 Code

Tuesday, October 3 • 15:15 - 16:15

by Bilal Gill

Summary of the talk:

In the field of robotics, Robot Operating System (ROS) is the de facto middleware of choice across academia and industry. As most code examples in ROS utilize an object-oriented approach, challenges can arise when writing tests for production code due to the boilerplate code ROS introduces, often leading to unexpected bugs or flaky tests. This talk explores ways to mitigate those issues by using a functional approach. By adopting this approach, we can minimize the impact that ROS or other middleware has on your code, preventing it from becoming tightly coupled and brittle.

Attendees can expect an overview of ROS 2 and the conventional programming approach typically associated with it. We'll delve into how tests are usually constructed and pinpoint potential sources of bugs and flakiness. Following this, we will introduce a functional approach to writing test code. By the end of this talk, attendees will learn an alternative method of architecting their ROS 2 code and also understand how this approach can lead to more robust, maintainable, and testable code.

CppCon 2023 The Au Library: Handling Physical Units Safely, Quickly, and Broadly -- Chip Hogg

By Blog Staff | Sep 13, 2023 04:29 PM | Tags: None

The Au Library: Handling Physical Units Safely, Quickly, and Broadly

Tuesday, October 3 • 14:00 - 15:00

by Chip Hogg

Summary of the talk:

We present Au: a new open-source C++ units library, by Aurora. If you've rejected other units libraries because they couldn't meet your needs, check out Au (pronounced, "ay yoo"). It combines cutting-edge developer experience (fast compilation, simple and readable compiler errors) with wide accessibility (C++14 compatibility, single-header delivery option). You can be up and running with Au in your project --- in any build system --- in less time than it takes to read this abstract!

We'll orient the viewer by providing a decision framework for choosing a units library, and using this framework to compare several leading options. We'll also see how these libraries influence each other. For example, Au has several compelling features inspired by other libraries, such as the concise and readable compiler errors of mp-units, and the frictionless single-header delivery of the nholthaus library --- in fact, Au is the first library to provide both these features at once. Au has also provided many new features of its own, including: fully unit-safe APIs; an adaptive "overflow safety surface" that governs unit conversions; on-the-fly composition for units and prefixes; smart, unit-aware rounding and inverse functions; and more.

Finally, Au has a notably low barrier to migration --- in either direction. We'll explain how to set up a correspondence between Au and any other units library. Even though neither library knows about the other, you'll be able to pass Au-typed variables to APIs which take the other library's types, and vice versa. This doesn't just make it easy to switch to Au; it promises a smooth upgrade path to any better library which comes along later (such as a future C++ standard units library). With such a low barrier to entry, give Au a try, and find out what it feels like to get effortlessly correct handling for all your physical quantities!

CppCon 2023 Back to Basics: Iterators -- Nicolai Josuttis

By Blog Staff | Sep 13, 2023 12:21 PM | Tags: None

Back to Basics: Iterators

Tuesday, October 3 • 14:00 - 15:00

by Nicolai Josuttis

Summary of the talk:

One key success factor of C++ was the introduction of the Standard Template Library (STL) bringing together containers/ranges and algorithms using iterators as glue API to iterate over elements of collections.

This talk will present the basics of the design of iterators, the various consequences, remarkable corner cases, and what this means when using ranges and views as introduced with C++20.

CppCon 2023 "Distributed Ranges": A Model for Building Distributed Data ... -- Benjamin Brock

By Blog Staff | Sep 13, 2023 07:54 AM | Tags: None

"Distributed Ranges": A Model for Building Distributed Data Structures, Algorithms, and Views

Monday, October 2 • 16:45 - 17:45

by Benjamin Brock

Summary of the talk:

Writing programs that run on clusters of computers is notoriously difficult. Distributed data structures can simplify this problem by automatically splitting up data across multiple memory spaces or nodes in a distributed memory program. Algorithms in most distributed data structures libraries, however, are not generic, but operate only on a specific data structure. In this work, we discuss how modern C++ features like concepts, customization points, and the ranges library can be used to support generic algorithms and views that can interoperate with multiple distributed data structures. We first discuss background in distributed computing and distributed data structures, including common techniques used to create high-level distributed data structures. We then show how customization point objects and concepts can be used to allow the implementation of generic algorithms that can be used with any distributed data structure as long as it fulfills a "distributed range" concept. We then show how to implement views that satisfy this concept, allowing algorithms to operate on lazily evaluated views of distributed data structures. Finally, we discuss two implementations of this model, for multi-GPU and multi-node programs, as well as performance considerations when running on state-of-the-art HPC systems.

CppCon 2023 Expressing Implementation Sameness and Similarity in Modern C++ -- Daisy Hollman

By Blog Staff | Sep 12, 2023 06:07 PM | Tags: None

Expressing Implementation Sameness and Similarity in Modern C++

Tuesday, October 3 • 14:00 - 15:00

by Daisy Hollman

Summary of the talk:

Polymorphism is among the most widely discussed introductory topics in software engineering. Often couched in a vague context of code reuse, much of this introductory focus nonetheless revolves around interface similarity. More advanced discussions of code reuse in software engineering typically revolve around general topics like the maintainability cost of code coupling, but usually avoid discussing the merits of advanced language-specific mechanisms for code reuse. Furthermore, very little is made of the information loss and cognitive load associated with poor expression of sameness in implementation, regardless of interface coupling concerns.

In this talk, we will examine the wide spectrum of tools for expressing “sameness” in modern C++. Beyond introductory “is-a” inheritance and runtime polymorphism, we will delve into templates, concepts, mixins, CRTP, C++23’s “deducing this,” and a number of more advanced techniques on the spectrum from generic programming to template metaprogramming. We will explore the long-term software engineering costs and benefits of each of these mechanisms. In each case, we will discuss important trade-offs, such as runtime and compile-time overhead, mechanistic complexity versus “sameness” information loss, code coupling, maintainability, and the ability to adapt to evolving implementation needs over time. Finally, we will discuss mechanisms for expressing “sameness” that are difficult or impossible in modern C++—such as dependency injection and aspect-oriented programming—but that are commonplace in other languages. We will delve into both the minimal and ideal language features that would enable these paradigms to become a part of the C++ toolbox, and we will discuss the outlook for the inclusion of such features in future versions of standard C++.

CppCon 2023 Open Content: C++ Conversation: Object Lifetime -- Jason Turner

By Blog Staff | Sep 12, 2023 12:49 PM | Tags: None

Open Content: C++ Conversation: Object Lifetime

Monday, October 2 • 12:30 - 13:30

by Jason Turner

Summary of the talk:

Want to learn more about C++ in a highly interactive way?

We will have a lunchtime group conversation about C++ Object Lifetime. We will discuss the types of Object Lifetime that exist in C++, and go through some fun puzzle-like exercises together.

Expect a casual, relaxed, fun, interactive setting to spend your lunch time!

CppCon 2023 Back to Basics: Debugging -- Greg Law

By Blog Staff | Sep 12, 2023 09:04 AM | Tags: None

Back to Basics: Debugging

Monday, October 2 • 11:00 - 12:00

by Greg Law

Summary of the talk:

Everyone knows that debugging is twice as hard as writing a program in the first place. Fortunately, there is more help available than you might have thought. GDB is much more powerful than most people realize; Valgrind and Address Sanitizer can catch many common bugs before they wreak havoc; time-travel debugging can turn even the most intractable nightmarish bugs into pussycats. This fast-paced talk is light on slides and heavy on demos to show you what's available and how to use it. Familiarity with the tools available to you is an essential part of being a great programmer; you will leave this talk at least one step closer to programming zen.

CppCon 2023 Cache-friendly Design in Robot Path Planning -- Brian Cairl

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

Cache-friendly Design in Robot Path Planning

Monday, October 2 • 17:20 - 17:55

by Brian Cairl

Summary of the talk:

Point-to-point planning is a major component in virtually all mobile robotic systems. These systems may require agents to generate paths over very large areas on demand; and sometimes several more times during their journey as part of intelligent recovery routines under dynamic environmental conditions. Since planning over large areas is a resource-intensive operation, particularly in higher-dimensional state-spaces, planning routines must be carefully tuned to execute as efficiently as possible so as to prevent perceptible delays in robot responsiveness.

Attendees can expect an overview of common planning algorithms used in robotics, such as Dijkstra's and A-star, to provide a motivating context. Rather than focus on time saving tricks specific to a particular environment or robot morphology, we will instead focus on getting the most out of these algorithms by way of leveraging cache-friendly design of requisite graph and memoization structures; and memory layouts. In particular, we will focus on achieving these results using common C++ STL facilities; and compile-time facilities to promote generic design, where possible. Finally, we will provide comparisons between naive and cache-optimized implementations; and guides for effectively profiling these algorithms for system-specific tuning purposes.