Loading…
Attending this event?

Log in to bookmark your favorites and sync them to your phone or calendar.

Sunday, October 24
 

10:45am MDT

Field Trip Meetup
For those who've registered for this year's Field Trip, let's meet up at Rockies Square.

Moderators
avatar for Nick Gully

Nick Gully

Field Trip Coordinator

Sunday October 24, 2021 10:45am - 11:00am MDT
Registration

11:00am MDT

Field Trip

Moderators
avatar for Nick Gully

Nick Gully

Field Trip Coordinator

Sunday October 24, 2021 11:00am - 5:10pm MDT
Idaho Springs, CO

8:00pm MDT

Registration Reception
Come for the registration and stay for the reception.

Get your badge.

Stick around and get acquainted with new friends and reacquainted with old friends.

Sunday October 24, 2021 8:00pm - 10:00pm MDT
Registration
 
Monday, October 25
 

6:45am MDT

Six Impossible Things
"Why, sometimes I've believed as many as six impossible things before breakfast," the Queen told Alice on her adventures through the looking glass. Only six? In software development we believe impossible things all the time, no matter the time of day!

In this talk, however, we are going to take a look at six specific impossible things that shape the limits of what we can develop, all the way from the smallest detail of integer representation to the minefield of task estimation and prioritisation, via the uncertainty of distributed systems and the limits of computability. Once we know our limits, we can work within them to create solutions rather than problems.

Speakers
avatar for Kevlin Henney

Kevlin Henney

Thought Provoker
Kevlin is an independent consultant and trainer based in the UK. His development interests are in patterns, programming, practice, and process. He has been a columnist for various magazines and websites, including Better Software, The Register, Java Report and the C/C++ Users Journal... Read More →


Monday October 25, 2021 6:45am - 8:30am MDT
`Online

8:45am MDT

C++20: Reaching for the Aims of C++
Out of necessity C++ has been an evolving language. I outline some early ideals for C++, some techniques for keeping the evolution directed, and show how C++20 comes close to many of those ideals. Specific topics includes type-and-resource safe code, generic programming, modularity, and the elimination of the preprocessor. Naturally, over the years, C++ has acquired many “barnacles” that can become obstacles to developing elegant and efficient code. That has been a recognized problem since the early days of C – Dennis Ritchie and I talked about it – so we must distinguish between what can be done and what should be done. The C++ Core Guidelines is the current best effort in that direction.

Speakers
avatar for Bjarne Stroustrup

Bjarne Stroustrup

technical fellow, morgan stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education;distributed systemsBio: www.stroustrup.com/bio.html


Monday October 25, 2021 8:45am - 10:30am MDT
Aurora C/D

9:00am MDT

Sums, Products, Exponents, Monoids, Functors, Oh My!
This talk will outline various algebraic types and structures, such as sum product and exponential types, structures such as monoids and groups, and higher order structures such as functors and monads. In particular, we'll look at why an API designer should be aware of them and supply operations that respect these structures' laws. Doing so will help you provide predictable APIs that can be reused more widely.

Speakers
avatar for Steve Downey

Steve Downey

Bloomberg LP


Monday October 25, 2021 9:00am - 10:00am MDT
`Online _4

9:00am MDT

Heterogeneous Modern C++ with SYCL 2020
Heterogeneous programming in C++ used to be hard and low-level. Today, Khronos SYCL for Modern C ++ works with different libraries, ML frameworks and Standard C++ code on top of template libraries with lambda functions that separate host and accelerate device code in a single source, but still enables separate compilation of host and device code. The device SYCL compiler may employ kernel fusion for better performance and the host CPU compiler can be any C++ compiler, from clang, gcc, VS C++, or IBM XL compiler. SYCL enables accelerated code to pass into device OpenCL compilers or other backends to dispatch to any variety of devices.

This talk from members of the SYCL community will talk about highlighted features from the latest SYCL 2020. SYCL 2020 is released after 3 years of intense work with significant adoption in Embedded, Desktop and HPC markets. It offers improved programmability, smaller code size, faster performance and is based on C++17 whilst maintaining backwards compatibility with SYCL 1.2.1.
It simplifies porting of standard C++ applications to SYCL with closer alignment and integration to ISO C++ and allows multiple back-end acceleration and API independence. There are already a number of backends including CUDA, PTX, OpenMP, AMD, NEC, and TBB in addition to OpenCL.

This talk will showcase these features and show how SYCL 2020 has increased expressiveness and simplicity for modern C++ heterogeneous programming.
There will also be a 3-day tutorial for those interested in learning how to use SYCL on various architectures, led by the experts from each company in hands-on tutorial.

Speakers
avatar for Gordon Brown

Gordon Brown

Principal Software Engineer, Codeplay Software
Gordon Brown is a principal software engineer at Codeplay Software specializing in heterogeneous programming models for C++. He has been involved in the standardization of the Khronos standard SYCL and the development of Codeplay’s implementation of the standard; ComputeCpp, from... Read More →
avatar for Tom Deakin

Tom Deakin

Senior Research Associate, University of Bristol
Tom Deakin is a Senior Research Associate in the High Performance Computing Research Group at the University of Bristol, where he works on performance portability of massively parallel High Performance simulation codes. Tom is the Chair of the Khronos SYCL Advisory Panel and has been... Read More →
avatar for Nevin Liber

Nevin Liber

Nevin “:-)” Liber is a Computer Scientist in the ALCF (Argonne Leadership Computing Facility) division of Argonne National Laboratory, where he works on the oneAPI/DPC++/SYCL backend for Kokkos for Aurora. He also represents Argonne on the SYCL and C++ Committees, the latter as... Read More →
avatar for Michael Wong

Michael Wong

DE, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups... Read More →


Monday October 25, 2021 9:00am - 10:00am MDT
`Online _1

9:00am MDT

Concurrency Patterns
This session is part of the Software Design Track.

The main concern when you deal with concurrency is shared, mutable state or as Tony Van Eerd put it in his CppCon 2014 talk “Lock-free by Example”: “Forget what you learned in Kindergarten (i.e., stop Sharing).”

I present in theory and praxis proven patterns such as thread-safe storage, strategized locking, thread-safe interface, or guarded suspension to deal with the enemies of thread-safe programming: shared state and mutation.

To synchronize and schedule member function invocations in a concurrent architecture, the classics such as active object, or monitor object provide valuable services.

Speakers
avatar for Rainer Grimm

Rainer Grimm

C++ trainer, Modernes C++
Rainer works as a software architect, team lead, and instructor since 1999. In 2002, he created a further education round at his company. He gives seminars since 2002. Rainer's first seminars were about proprietary management software, but seminars for Python and C++ followed immediately... Read More →


Monday October 25, 2021 9:00am - 10:00am MDT
`Online _3
  • Software Design, Online

9:00am MDT

C++20 Templates: The next level: Concepts and more
C++20 is probably the biggest change to the language since ever. In this session, we will look into some changes that templates received with C++20. The biggest change is the introduction of Concepts.

We don’t stop there. We will also talk about improvements to CTAD and NTTP. Of course, we will also look into how templated lambdas work in C++20.

By the end of the talk, attendees have learned about the newest C++20 template updates and how to apply them.

Speakers
avatar for Andreas Fertig

Andreas Fertig

Unique Code
Andreas Fertig, CEO of Unique Code GmbH, is an experienced trainer and lecturer for C++ for standards 11 to 20.Andreas is involved in the C++ standardization committee, in which the new standards are developed. At international conferences, he presents how code can be written better... Read More →


Monday October 25, 2021 9:00am - 10:00am MDT
`Online _2
  • Templates/Concepts, Online

11:00am MDT

From Eager Futures/Promises to Lazy Continuations: Evolving an Actor Library Based on Lessons Learned from Large-Scale Deployments
To meet the performance demands of a large-scale container orchestrator (Apache Mesos) we built a pre-C++11 library that, in 2009, was the first library we knew of that combined an actor programming model with futures/promises. In the first part of this talk we'll discuss why we chose to use futures/promises to build a large-scale distributed system and why actors are the perfect complementary programming model. The library served us well, helping to scale Mesos to clusters larger than 75,000 physical machines, but not without numerous bouts of optimizations and introductions of new, more efficient, constructs. We'll discuss what we learned along the way, in particular that while the intention and interface of the library was good, the underlying implementation of the library performed tons of unnecessary synchronization and dynamic memory allocation.

Now 10 years later we've rebuilt the library from scratch as part of ongoing research into distributed systems at UC Berkeley. We'll discuss how the new library focuses on *continuations* rather than futures/promises while providing the same simplicity as before when composing code. We'll walk through how programmers can use low-level constructs of the library to explicitly compose continuations together, or how they can use higher-level constructs that they can compose without using continuations at all.

The library is coroutine friendly and has some overlap with 'A Unified Executors Proposal for C++' (P0443R13), in particular that both approaches are lazy vs the eager approach of futures/promises. However, our library has a particular focus on supporting actors. This has some important design implications with respect to scheduling and memory allocation that we'll discuss in depth during this presentation, highlighting some of the differences with outstanding proposals.

Speakers
avatar for Benjamin Hindman

Benjamin Hindman

Twitter
Benjamin Hindman is one of the creators of Apache Mesos. He began working on the project as a PhD student at UC Berkeley, and it followed him to Twitter where he is currently employed. Mesos now runs on thousands of machines at Twitter, Airbnb, etc. -- even when Ben is away skiing... Read More →


Monday October 25, 2021 11:00am - 12:00pm MDT
_3

11:00am MDT

Your New Mental Model of constexpr
In my experience as a trainer, YouTuber, and speaker, I find that many people have a mistaken impression of what constexpr is and for what it is suited. I see people over-complicate constexpr by conflating it with meta programming and template-related topics. Students will often fail to recognize where and when constexpr could be used. Experts will get concerned about the "contract" you are making with the user of your library by marking functions as constexpr.

In this talk, I will present a mention model for how you should consider constexpr. I will explain what constexpr is (less mechanically and more metaphorically), give practical applications for constexpr, and help you figure out where constexpr fits into your application or library.

In the most straightforward sense, constexpr is moving work from runtime to compile-time. This mental model that I will present will ask, "what work would you rather do at compile-time?" We will find this answer by looking at constexpr as a continuum. On one end of the continuum is the use case of moving a runtime fixed-size vector into a compile-time fixed-size constexpr array, and on the far end is executing your entire program at compile-time and simply outputting the results at runtime.

Speakers
avatar for Jason Turner

Jason Turner

Owner, Jason Turner
Host of C++Weekly https://www.youtube.com/c/JasonTurner-lefticus, Co-host of CppCast http://cppcast.com, Co-creator and maintainer of the embedded scripting language for C++, ChaiScript http://chaiscript.com, and author and curator of the forkable coding standards document http://cppbestpractices.com.I'm... Read More →


Monday October 25, 2021 11:00am - 12:00pm MDT
_2
  • const/Units/Time, Hybrid

11:00am MDT

Understanding and Mastering C++'s Complexity
This is the Opening Keynote for the Back to Basics Track.

You probably write in C++ not because it is the simplest available language. There are other attributes C++ brings: efficiency, low footprint, direct memory access, enhanced control over runtime behavior, and more. In "The Design and Evolution of C++", Bjarne Stroustrup explains the design decisions taken since the language was conceived and during its evolution. What makes C++ powerful? How has C++ survived more than 4 decades, while other languages have disappeared into oblivion? Why do we still use C++ (and will we still be using it in a decade from now)? And most importantly, why it is not so complicated after all, and even becomes easier to use over time! Being both a teacher and a practitioner, seeing beginners struggle at first with the language but then turn to love it, my goal is to assure you that mastering C++ is doable, then motivate you to do so.

Speakers
avatar for Amir Kirsh

Amir Kirsh

Teacher, Dev Advocate, Academic College of Tel-Aviv-Yafo and Incredibuild
Amir Kirsh is both a Lecturer and a practitioner. Teaching at the Academic College of Tel-Aviv-Yaffo and at Tel-Aviv University while keeping hands on, mainly on C++, as a Dev Advocate at Incredibuild and previously as the Chief Programmer at Comverse. Amir is also one of the organizers... Read More →


Monday October 25, 2021 11:00am - 12:00pm MDT
_1

11:00am MDT

Law of Demeter: A Practical Guide to Loose Coupling
This session is part of the Software Design Track

In this practical session, we will go through examples that follow and/or violate the Law of Demeter principle (LoD) [1].

We will take a deep dive into what kind of design issues that exposes and how to fix them.
Additionally, we will focus on the testing aspect of following the LoD principle together with Single Responsibility and Dependency Inversion principles.

At the end of this session, the audience will have a better understanding of how to write a loosely coupled code, how to easily test it and why the Law of Demeter principle is so important in Software Design.

Let's !"only talk to our immediate friends" at CppCon-2021!

[1] https://en.wikipedia.org/wiki/Law_of_Demeter

Speakers
avatar for Kris Jusiak

Kris Jusiak

Software Architect, Quantlab Financial
Kris is a Software Architect passionate about programming and who has worked in different industries over the years including telecommunications, games and most recently finance for Quantlab Financial, LLC. He has an interest in modern C++ development with a focus on performance and... Read More →


Monday October 25, 2021 11:00am - 12:00pm MDT
_4

11:00am MDT

Discovering a User-Facing Concept
How do we wield concepts to get effective usage? There's a lot of presentations talking about the technical details of concepts over the past few years, but far fewer delve into how to derive a concept in detail. Simply understanding how language features work isn't good enough: we need to know how to use them in order to get maximum effectiveness out of a feature.

What are concepts supposed to describe? What are patterns to follow and patterns to avoid? What's the difference between a "constraint" and a "semantic requirement"? What's the difference between a concept that's applied to a function and a concept that's applied to a type?

In this session, we will answer all of these questions, by studying an algorithm, identifying its requirements, and discovering a concept.

This session builds off themes from Andrew Sutton's Concepts in 60: Everything You Need to Know and Nothing You Don't, and Sean Parent's Generic Programming.

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Software Engineer, Google LLC
Christopher Di Bella is a software engineer working on Google's Chrome OS toolchain team. In a nutshell, this means he's responsible for delivering a high-quality LLVM toolchain to Chrome OS developers, and some of that work includes libc++. Christopher is passionate about generic... Read More →


Monday October 25, 2021 11:00am - 12:00pm MDT
`Online _1
  • Templates/Concepts, Online

12:30pm MDT

Automatically Process Your Operations in Bulk With Coroutines
Performing bulk operations is more efficient than performing multiple single operations in many scenarios: memory allocations, I/O, IPC, etc.
At the same time, code that performs operations in bulk requires extra bookkeeping and boilerplate compared to equivalent code which operates on each individual item.
In this talk, we'll see how C++20 coroutines let us get the performance gains of executing operations in bulk, without the maintenance burden.

Often it’s easier to write code that executes on an item at a time rather than on multiple items: it’s easier to write an if condition than to call std::erase_if, it’s easier to call a function than calling std::transform.
When operating on an item at a time, it is also possible to use exceptions for error handling.
Once we change our code to operate on batches of items, the logic often looks completely different from the original one.

Could we keep our code as if we were processing an item at a time, but calling functions on multiple items behind the scenes?
What if we could aggregate all the arguments to a function into a collection, execute the function with the collection of arguments, and redistribute the results to each caller in a completely transparent way?

This talk will show how such a system could be implemented using coroutines.
It will show step by step how to implement a task and awaitable object which can suspend a function in a synchronous context and resume it once the underlying bulk operation has completed, and how to schedule such tasks.

Have you heard of coroutines but haven’t seen an application of them yet?
Did you read about all the new customization points introduced but haven’t still realized how to make use of them?
Are you looking for a practical and interesting use case for coroutines?
This talk is for you!
Join us to learn about a new way of creating powerful abstractions in modern C++.

Speakers
avatar for Francesco Zoffoli

Francesco Zoffoli

Software Engineer, Facebook
Francesco Zoffoli is a professional Software Engineer currently working for Facebook, building monitoring systems. Author of the book "C++ Fundamentals", passionate about programming languages and maintainable software, he has been using C++ throughout his career and personal projects... Read More →


Monday October 25, 2021 12:30pm - 1:30pm MDT
`Online _2
  • Async/Concurrency/Parallelism, Online

12:30pm MDT

C++11/14 at Scale: What Have We Learned?
Many years have passed since the release of C++11 and C++14. These standards brought many new features and idioms to the C++ language and revitalized its community.

Nowadays, with C++20 having one foot out the door, it is important to look back at the experience gained using C++11/14 at scale and re-evaluate their impact.
- What have we learned from 8 years of using Modern C++ in production at a large-scale corporation?
- What features were the most useful?
- Which ones were the most misused?

From unexpected benefits/drawbacks to teachability issues, this talk will discuss the most significant consequences of embracing C++11 and C++14 in a company with thousands of engineers. With some *healthy* skepticism, commonly used features and idioms will be reassessed to uncover some unexpected pitfalls or qualities.

Speakers
avatar for Vittorio Romeo

Vittorio Romeo

Software Engineer, Bloomberg
Vittorio Romeo (B.Sc. Computer Science) has been a Software Engineer at Bloomberg for more than 3 years, working on mission-critical company C++ infrastructure and providing Modern C++ training to hundreds of fellow employees.He began programming around the age of 8 and quickly became... Read More →


Monday October 25, 2021 12:30pm - 1:30pm MDT
`Online _3
  • Code Design, Online

12:30pm MDT

Exceptional C++
When writing code we usually focus our attention on the happy paths - that’s where the interesting stuff happens. But there are also plenty of exciting things happening on the error handling flow, too. Although not universally loved/used, exceptions are a powerful mechanism of maneuvering execution on the unhappy path.
Even if std::exception and related machinery are not your cup of tea, you might care about hardware faults or OS signals like access violations, page errors, ALU overflows.
Let’s take a deep dive and explore what happens when an exception occurs, both at the application level and the OS level. We’ll explore the unwind process, the compiler generated code, the CRT hooks available and other exception internals. As we’re taking the scenic Windows route, we’re also going to encounter async exceptions (structured exceptions) on our quest for a better crash. We’ll poke into these mechanisms and see how we can leverage them in our application error handling. Did I mention threads? Routing exceptions between threads… oh my!

Speakers
avatar for Victor Ciura

Victor Ciura

Principal Engineer, CAPHYON
Victor Ciura is a Principal Engineer at CAPHYON, Technical Lead on the Advanced Installer team and a Microsoft MVP (Developer Technologies).He’s a regular guest at Computer Science Department of his Alma Mater, University of Craiova, where he gives student lectures & workshops on... Read More →


Monday October 25, 2021 12:30pm - 1:30pm MDT
`Online _5

12:30pm MDT

Just Enough Assembly for Compiler Explorer
Every other conference talk these days seems to be showing off some code on Compiler Explorer. But what does all that Assembly actually mean?

In this talk you'll learn the very basics of X86 Assembly and the X86_64 calling convention, just enough to understand the full Assembly listing of simple functions on Compiler Explorer. No previous experience with Assembly is necessary, but a basic understanding of C or C++ is useful.

After this talk you will:
- Be able to paste code from your own project into Compiler Explorer, and either understand the Assembly output or know how to simplify it until you do.
- Have a solid understanding of the fundamentals, so you know what to search for and understand it when you need to know more.

(Compiler Explorer is an increasingly popular tool which allows you to see exactly what the compiler does with your code. Check it out at https://godbolt.org/.)

Speakers
avatar for Anders Schau Knatten

Anders Schau Knatten

Software Engineer, Zivid
Anders started programming in Turbo Pascal in 1995 and has worked as a software developer in various languages since 2001. He's currently a Senior Software Engineer at Zivid, where he's working on machine vision in C++. He's the author of https://cppquiz.org and the blog C++ on a... Read More →


Monday October 25, 2021 12:30pm - 1:30pm MDT
`Online _4
  • Tooling/Debugging, Online

12:30pm MDT

Back to Basics: Designing Classes (part 1 of 2)
Designing good, maintainable classes is a challenge. Sometimes it even feels like there is a decision to make in every single line of code. This talk will help you master this challenge. It will explain …

* … why small classes are beautiful;
* … why it is so important to encapsulate variation points;
* … why inheritance is rarely the answer for customization;
* … how to write good and maintainable constructors;
* … how to make sure class invariants are maintained;
* … how to handle member data;
* … how to write good member functions;
* … how to write good supporting functions;
* … why your private members are not private at all.

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

C++ Trainer/Consultant, Freelancer
Klaus Iglberger is a freelancing C++ trainer and consultant. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the... Read More →


Monday October 25, 2021 12:30pm - 1:30pm MDT
`Online _1
  • Type Design, Online

2:00pm MDT

Type-and-resource safety in modern C++
Complete type-and-resource safety have been an ideal (aim) of C++ from very early on (1979) and is achievable though a judicious programming technique enforced by language rules and static analysis. The basic model for achieving that was documented in 2014 and does not imply limitations of what can be expressed or run-time overheads compared to traditional C and C++ programming techniques.
Experience shows that this cannot be achieved without static analysis and minimal run-time support. For fundamental reasons this cannot be done even with such support if arbitrary legal language constructs are accepted while conventional good performance must be maintained.

The way out of this dilemma is a carefully crafted set of programming rules supported by library facilities and enforced by static analysis.

This presentation is based on the C++ Core Guidelines and their enforcement rules (e.g., as implemented by the Core Guidelines checker distributed with Microsoft Visual Studio). That is, the points made here are backed up by specific rules and supported by existing software.

Speakers
avatar for Bjarne Stroustrup

Bjarne Stroustrup

technical fellow, morgan stanley
C++: history, design, use, standardization, future; performance, reliability; software developer education;distributed systemsBio: www.stroustrup.com/bio.html


Monday October 25, 2021 2:00pm - 3:00pm MDT
_2
  • Code Design, Hybrid

2:00pm MDT

I See Your AUTOSAR and Raise You “Constexpr Everything”. No Seriously, Everything. The Standard Library, Microkernel, Apps, and Unit Tests.
This presentation will walk the audience through how we implemented an AUTOSAR compliant Hypervisor with all of it's code including the microkernel, apps and unit tests as a "constexpr" using C++20, all in open source. Are you worried about undefined behavior in your applications? Are you curious how far "constexpr everything" can be taken and how it benefits you, or what "constexpr everything" is? Do you work with AUTOSAR? Or are you curious how you would write a microkernel as a "constexpr"? If so, this presentation is for you.

The original goal of our project was to implement an AUTOSAR compliant hypervisor using a microkernel archeicture, designed specifically for US government and critical systems applications all in open source. The first problem we ran into was there were no, open source, AUTOSAR compliant implementations of the C++ standard library. There also were no static analysis tools in open source to verify AUTOSAR compliance. To solve this, we implemented our own AUTOSAR static analysis tool using Clang Tidy in open source as well as a portion of the C++ standard library (called the BSL) using C++20 to AUTOSAR specifications. Since C++20 was used, we decided to see just how far we could take the idea of "constexpr everything". To our surprise, we were able to implement everything as a "constexpr". The C++ code for the microkernel, the C++ code for the applications that run on top of this microkernel, and yes, all of the unit tests for everything with 100% code coverage. What this means is that our unit tests are executed at compile-time and they test everything from the page fault handler and ELF loader in the microkernel, to the tools that run on Windows or Linux. Not only does this ensure that undefined behavior is almost impossible for the entire project, it means that the compiler can verify both the syntax and the "logic" at compile time as the unit tests tell the compiler what the code is supposed to do.

"constexpr everything" will change the way you think about coding and C++. It's not just about performance and compile-time scripting. Its a way to tell the compiler what your application is supposed to do. Combined with Metaprogramming, the future of C++ in safety critical systems is boundless. This presentation will walk the audience through our experience of how we implemented everything as a "constexpr" and what the benefits of "constexpr everything" are to you and your projects from gaming and banking, to critical systems. This presentation will also cover how we overcame certain hurdles with "constexpr everything" in a real-world example, as well as how we implemented AUTOSAR compliance in open source. Think it's impossible to write a kernel as a "constexpr"? Be prepared to have some fun, learn some cool tricks and to have your mind blown!

Speakers
avatar for Rian Quinn

Rian Quinn

CTO, Assured Information Security, Inc.
Dr. Rian Quinn is a Senior Principal Investigator in the Trusted Information Systems Group at Assured Information Security, Inc. were he has focused on trusted computing and hypervisor related technologies for nearly 10 years. He holds a Ph.D. in Computer Engineering with specializations... Read More →


Monday October 25, 2021 2:00pm - 3:00pm MDT
_3
  • Embedded, Hybrid

2:00pm MDT

Failing Successfully: Reporting and Handling Errors
Writing code which successfully accomplishes a task is difficult. Four year software engineering degrees are, after all, spent learning something of substance. This difficulty only compounds as the code in question becomes less and less trivial. Successful accomplishment is not the only outcome of well written, real world software however: Tasks can fail for a variety of reasons.

From a certain point of view success is the least interesting outcome in software engineering. No one is woken up in the small hours of the morning because their software succeeded. Much gets said about the Ariane 5 but have you heard of the Ariane 4 or 6? It’s plausible that dealing with errors appropriately is the most important responsibility of a software engineer.

This talk will discuss errors and exceptions, how, when, and why they should be generated, how code should be structured to handle them, and what techniques can be used to ensure such situations are reported with sufficient context that the cause can be identified and addressed with minimal software engineer involvement.

Speakers
avatar for Robert Leahy

Robert Leahy

Lead Software Engineer, MayStreet Inc.
Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After 4.5 years in full stack web development he switched to financial infrastructure software development in early 2017. He’s since become involved in the... Read More →


Monday October 25, 2021 2:00pm - 3:00pm MDT
_1
  • Testing/Error Handling, Hybrid

2:00pm MDT

Back to Basics: Designing Classes (part 2 of 2)
Designing good, maintainable classes is a challenge. Sometimes it even feels like there is a decision to make in every single line of code. This talk will help you master this challenge. It will explain …

* … why small classes are beautiful;
* … why it is so important to encapsulate variation points;
* … why inheritance is rarely the answer for customization;
* … how to write good and maintainable constructors;
* … how to make sure class invariants are maintained;
* … how to handle member data;
* … how to write good member functions;
* … how to write good supporting functions;
* … why your private members are not private at all.

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

C++ Trainer/Consultant, Freelancer
Klaus Iglberger is a freelancing C++ trainer and consultant. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the... Read More →


Monday October 25, 2021 2:00pm - 3:00pm MDT
`Online _1
  • Type Design, Online

3:15pm MDT

GraphBLAS: Building a C++ Matrix API for Graph Algorithms
One of the most challenging issues in high-performance graph algorithms is dealing with bespoke graph data structures and algorithms, which can be difficult to optimize and maintain. The GraphBLAS is a mathematical and C API specification that allow programmers to implement graph algorithms using the language of linear algebra. Programmers implement their graph algorithms using high-level matrix and vector operations, such as generalized matrix and vector multiply. Their code can then be executed using matrix algorithms, such as sparse matrix multiply, that have been finely tuned, taking advantage of decades of research in optimizing sparse linear algebra for CPU, GPU, and distributed platforms.

In this talk, we discuss our efforts and experience building and implementing a C++ GraphBLAS API. We define a number of data structures, such as our GraphBLAS matrix type, which has a similar interface to `unordered_map`, but with a 2-D `key_type`, a fixed dimension, and possibly different backend storage data structures, depending on a collection of compile-time hints. We also define a collection of structs to represent various binary operators, monoids, and semirings used in graph algorithms. These are similar to the arithmetic operations defined in the STL's `functional`, but with extra type information to store a monoid's identity, and to promote pre-existing binary operators (such as STL's arithmetic ops) to monoids. We also discuss matrix views, the divorce of a specific arithmetic from the data structure (monoids and semirings being specifically associated with an operation, not a data structure, as a data structure may be used in multiple operations with different arithmetics), and generalized element-wise operations.

Speakers
avatar for Benjamin Brock

Benjamin Brock

PhD Candidate, UC Berkeley
Ben Brock is a PhD student at UC Berkeley, where he works on building libraries, tools, and algorithms for high-performance computing. His main work focuses on building a cross-platform library of data structures for distributed applications, with a focus on sparse linear algebra... Read More →
avatar for Scott McMillan

Scott McMillan

Principal research engineer, Carnegie Mellon University
GraphBLAS: graph algorithms in the language of linear algebra


Monday October 25, 2021 3:15pm - 4:15pm MDT
_3
  • Algorithms/Functional, Hybrid

3:15pm MDT

Back to Basics: Pointers
Pointers are scary. Unfortunately that previous statement is what many beginners take away when first learning about pointers and the C++ language. In this talk, we will discuss the low level foundations of what a raw pointer is--a variable that stores an address. We will then see some examples of raw pointers for creating data structures, passing data into functions, dynamically allocated arrays, and function pointers. This portion will cover capabilities of raw pointers and syntax: * (asterisk), .(dot) , -> (arrow). By the end of the first portion of the talk, we will find pointers are not scary, but just another tool we can use in our programmers’ toolbox.

After learning the foundations, we are then going to discuss some of the pitfalls of pointers (e.g. nullptr’s, double frees, memory leaks). However, with modern C++, we can abstract away some of these problems using various “smart pointers” built into the standard library in <memory>. Attendees will leave understanding how we can use pointers in a safe manner through the standard library smart pointer abstractions.

Speakers
avatar for Mike Shah

Mike Shah

Assistant Teaching Professor/3D Senior Graphic Eng, Northeastern University
Michael D. Shah completed his Ph.D. at Tufts University in the Redline Research Group in 2017. His Ph.D. thesis advisor was Samuel Z. Guyer. Michael finished his Masters degree in Computer Science in 2013 at Tufts University and Bachelors in Computers Science Engineering at The Ohio... Read More →


Monday October 25, 2021 3:15pm - 4:15pm MDT
_4

3:15pm MDT

Compile-Time Compression and Resource Generation with C++20
C++20 compile-time features can generate complex resources while simplifying code and ensuring correctness. You can generate USB descriptors, compressed data/strings, lookup tables, or even microcontroller configuration fuses.

In this session we will start from simple examples and progress through the challenges in building compile-time libraries, and then present techniques you can use to create your own header-only libraries with simple-to-use interfaces with lambdas providing user data in the constexpr context.

This session is directly relevant to those working in resource-constrained environments like embedded devices, but these techniques can be used in the wider C++ community.

Speakers
avatar for Ashley Roll

Ashley Roll

Independent Contractor
Ashley has over 25 years of experience as a software engineer and architect working as an independent contractor in Brisbane, Australia. He has worked in large and small projects spanning web applications, desktop applications, business systems as well as embedded hardware and firmware.He... Read More →


Monday October 25, 2021 3:15pm - 4:15pm MDT
`Online _1
  • Embedded, Online

3:15pm MDT

Implementing C++ Modules: Lessons Learned, Lessons Abandoned
C++ Modules were designed to bring more safety to your programs, while dramatically reducing compile time, resulting in overall increased productivity. How can your C++ toolchain meet this challenge? What can you do to take advantage of these new functionalities available in your toolbox? In this talk, we share lessons learned from implementing Modules based on the singular idea of providing robust support through the entire toolchain (from the lexer through the linker, the IDE, the build system, etc.), debunking the misconception that C++ Modules are just some syntactic sugar that is compiled away by the front-end. The challenges that any C++ compiler implementer faces include: (1) how to satisfy the requirements of merging materialization of declarations -- needed for sound handling of the global module fragments, in particular, as found in header files and header units – with associated performance cost; (2) how to take advantage of the One Definition Rule guarantees provided by named modules. They must address those challenges without compromising efficiency and static semantics. These lessons are valuable not just to C++ tools developers, but to ordinary C++ programmers as well, shedding light on how speed and safety gains are achieved by staying close to the spirit of the original C++ Modules design (“take the ODR as foundational”), and how you can put them to good use in the architecture of your programs and libraries.

Speakers
avatar for Cameron DaCamara

Cameron DaCamara

Senior Software Engineer, Microsoft
Senior software engineer at Microsoft working on the MSVC front-end team.  Primary area of focus is C++ Modules and compiler evolution.
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Principal Software Engineer, Microsoft
Gabriel Dos Reis is a Principal Software Engineer at Microsoft, where he works in the area of large scale software construction, tools, and techniques. He is also a researcher, and a longtime member of the C++ community, author and co-author of numerous extensions to support large... Read More →


Monday October 25, 2021 3:15pm - 4:15pm MDT
_2

3:15pm MDT

Designing for the Long Term: Invariants, Knobs, Extensions, and Hyrum’s Law
This session is part of the Software Design Track.

Configurability should be considered a potential design smell, especially for systems and interfaces that will be in use for a long time. As an unfortunate result, “No, please don’t add that feature” must be a viable response to design proposals - just because a change can be made doesn’t mean it should. This is particularly challenging to square with a customer-focused product mindset: it’s hard to balance between long-term needs and immediate “the customer is always right.”

Providing options and toggles to configure settings gives users more freedom, but those settings become stale and brittle almost immediately, and regularly wind up pessimizing overall efficiency results. This is particularly true of rarely-used forms of extensibility and configuration. Of course, whatever sort of optionality and customization you provide will be hard to ever undo, because of Hyrum’s Law.

At the root of it, there is a fundamental tension between customization, extensibility, configuration vs. centralization, efficiency, and evolvability, and this tension needs to be considered when you are evaluating whether to add new customization and extensibility options. This talk will address some of the basic ways that design and invariants interact with long-term maintenance and optimization, and some heuristics for deciding whether adding a knob will turn out to be a mistake.

Speakers
avatar for Titus Winters

Titus Winters

C++ Library Lead, Google
Titus Winters has spent the past 6 years working on Google's core C++ libraries. He's particularly interested in issues of large scale software engineer and codebase maintenance: how do we keep a codebase of over 100M lines of code consistent and flexible for the next decade? Along... Read More →


Monday October 25, 2021 3:15pm - 4:15pm MDT
_1

4:45pm MDT

Back to Basics: Concurrency
You have spent your hard earned money on a multi-core machine. But what does that mean for you as a programmer or for the consumers of your software who also spent their hard earned money on a multi-core machine? Well the deal is, you only get an increase in performance, if you know how to take advantage of your hardware. Perhaps you have also heard something about the free lunch being over for programmers?

In this talk we provide a gentle introduction to concurrency with the modern C++ std::thread library. We will introduce topics with pragmatic code examples introducing the ideas of threads and locks, and showing how these programming primitives enable concurrency. In addition, we will show the common pitfalls to be aware of with concurrency: data races, starvation, and deadlock (the most extreme form of starvation!). But don’t worry--I will show you how to fix these concurrency bugs!

The session will wrap up with discussion and examples of other concurrency primitives and how to use them to write concurrent programs for common patterns(different types of locks, conditional variables, promises/futures). Attendees will leave this session being able to use threads, locks, and start thinking about architecting multithreaded software. All materials and code samples will also be posted online.

Speakers
avatar for Mike Shah

Mike Shah

Assistant Teaching Professor/3D Senior Graphic Eng, Northeastern University
Michael D. Shah completed his Ph.D. at Tufts University in the Redline Research Group in 2017. His Ph.D. thesis advisor was Samuel Z. Guyer. Michael finished his Masters degree in Computer Science in 2013 at Tufts University and Bachelors in Computers Science Engineering at The Ohio... Read More →


Monday October 25, 2021 4:45pm - 5:45pm MDT
_1

4:45pm MDT

Implementing static_vector: How Hard Could it Be?
static_vector is a std::vector that allocates things on the stack instead of the heap. We have std::vector, so it should be easy to write a non-allocating version, right?

Sadly, it's not quite that simple. There are many aspects of the vector interface that make sense based on a container that can reallocate, but do not make sense for a container that cannot. This leads to some API differences. static_vector also faces certain challenges around constexpr that makes it both more and less constexpr than std::vector.

We will go into detail on how std::vector and how static_vector work, how they are similar, and how they differ. This presentation will be focusing on lower-level details and interactions with specific language features in C++20 and (hopefully) C++23. There will be lots of code examples, and we'll step through how they work and where they fall short, trying to build up to a working, production-ready solution.

Speakers
avatar for David Stone

David Stone

Software Engineer, Quantlab
David Stone has worked on autonomous vehicles, large-scale distributed systems, and now works developing software for high-frequency trading. He is a member of the C++ Standardization Committee, where he chairs the Modules Study Group (SG2) and is the vice chair of the Evolution Working... Read More →


Monday October 25, 2021 4:45pm - 5:45pm MDT
_4

4:45pm MDT

Lessons Learned from Packaging 10,000+ C++ Projects
At Bloomberg, we maintain a system that coherently builds and integrates more than 10,000 C++ packages that are maintained independently by thousands of software engineers on hundreds of teams across our Engineering department. In this talk, we will go over the lessons we have learned about maintaining these packages, as well as how package management should interact with third-party libraries, third-party tools, build systems, IDEs, static analysis tools, and refactoring automation. We hope this will start a conversation around the potential requirements for a more complete package management solution in the C++ ecosystem.

Speakers
avatar for Bret Brown

Bret Brown

Team Lead, Bloomberg
Software engineer currently focusing on improving C and C++ ergonomics, correctness, and productivity for Bloomberg's Developer Experience department.Bret works to make authoring and maintaining C++ codebases simpler and more intuitive by treating projects more like cattle and less... Read More →
avatar for Daniel Ruoso

Daniel Ruoso

Senior Software Engineer, Bloomberg
Currently working as the lead for Code Governance at Bloomberg, where we focus on driving large scale Static Analysis and Automated Refactoring. Daniel has been working over the past 20+ years with a persistent lens on how to help engineers be more effective with build, deployment... Read More →


Monday October 25, 2021 4:45pm - 5:45pm MDT
_3

4:45pm MDT

Changing Legacy Code with Confidence: Practical Advice for Maintaining and Migrating Working Code
Modern best practices always recommend writing new code for testability and maintenance. However, most of us spend more time reading other people’s code and trying to find a place to put our change without breaking existing functionality. Rarely, if ever, does that code have tests; nor does the project timeline allow for large scale refactoring to make it testable. In this talk, we will discuss how to take the fear out of working on legacy code and start working toward not only adding a safety net so we can change with confidence, but also make it easier to understand what the code is actually doing. We’ll look at some techniques that can be implemented without requiring massive hits to your deadlines, and even address issues such as dealing with hardware and timing dependencies in embedded systems. Over time, both you and your team will be rewarded by increased reliability and productivity and no longer dread the word "legacy."

Speakers
avatar for Brian Ruth

Brian Ruth

Sr. Software Engineer, Garmin
Brian has been programming in C++ for 20+ years; working for both small and large companies on a wide variety of projects and technologies. For over a decade he worked with neuroscience researchers and created high speed acquisition, analysis and visualization software. He is currently... Read More →


Monday October 25, 2021 4:45pm - 5:45pm MDT
_2
  • Testing/Error Handling, Onsite

8:30pm MDT

Committee Fireside Chat
Bring your questions! This panel of representative members of the C++ standards committee is ready to discuss everything from  C++20, to how the committee is working online as we start the C++23 cycle, and what to look forward to in Standard C++ in the coming years.

Besides C++’s creator, the panelists include the current leaders of key subgroups. These leaders are responsible for language and library evolution, and topics like compile-time programming, real-time/embedded systems, AI, and teaching as the community starts to absorb all the new features in C++20.

The panel also includes representation of fresh forward-looking thinking with the heads of some of the newest national bodies to join in and participate in ISO C++.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting

Monday October 25, 2021 8:30pm - 10:00pm MDT
Aurora C/D
 
Tuesday, October 26
 

6:00am MDT

Committee Fireside Chat
Delayed broadcast

Bring your questions! This panel of representative members of the C++ standards committee is ready to discuss everything from C++20, to how the committee is working online as we start the C++23 cycle, and what to look forward to in Standard C++ in the coming years.

Besides C++’s creator, the panelists include the current leaders of key subgroups. These leaders are responsible for language and library evolution, and topics like compile-time programming, real-time/embedded systems, AI, and teaching as the community starts to absorb all the new features in C++20.

The panel also includes representation of fresh forward-looking thinking with the heads of some of the newest national bodies to join in and participate in ISO C++.

Moderators
avatar for Jon Kalb

Jon Kalb

Conference Chair, Jon Kalb, Consulting

Tuesday October 26, 2021 6:00am - 7:30am MDT
`Online _1

7:45am MDT

Working with Asynchrony Generically: A Tour of C++ Executors (part 1 of 2)
Asynchrony is increasingly important across the software industry, yet C++ lacks a standard async programming model or a comprehensive set of asynchronous algorithms. In this talk, Eric will describe the approach to asynchrony taken by standard Executors, currently targeting C++23. This talk with focus on how to use the new facilities, with glimpses under the covers to see how things work.

"Asynchrony" means many things. It means concurrency (e.g., thread pools) and parallelism (e.g., GPUs). It means parameterizing a computation on where it should execute. It means the ability to chain work, propagating values and errors to user-specified continuations. It means forking and joining async control flow without blocking. It requires guarantees that async work can make forward progress. It means a standard way to request that a computation stop early, and a way to propagate the "I have now stopped" notification back to the caller. And -- since this is C++ -- it means doing all that with bare-metal performance and seamless integration with C++20 coroutines.

The async programming model espoused by the recent standard Executors papers satisfies these constraints while also enabling a full suite of Generic asynchronous algorithms. C++23 will likely come with algorithms such as `then` for chaining work, `timeout` and `stop_when` for cancelling work after certain criteria are met, `when_all` for launching concurrent work and joining (without blocking), and `sync_wait` for blocking until work has finished.

The core abstraction of the Executors design, known as "Sender/Receiver", is to asynchronous algorithms what the STL's "Iterator" abstraction is to sequence algorithms: an enabling abstraction that makes reusable algorithms possible. With the containers and algorithms of the STL, the C++ Standard Library took a giant step forward in power and reusability. With C++23 Executors, the Standard Library takes the next step.

Speakers
avatar for Eric Niebler

Eric Niebler

Distinguished Engineer, NVIDIA
Eric is a long-time member of the ISO C++ Standardization Committee, and is probably best known for his work bringing ranges support to the C++20 Standard Library. He specializes in modern C++ library design, authoring several Boost libraries and the popular range-v3 library for computing... Read More →


Tuesday October 26, 2021 7:45am - 8:45am MDT
`Online _1

7:45am MDT

Back to Basics: Move Semantics
Move semantics, introduced with C++11, has become a hallmark of modern C++ programming. However, it also complicates the language in some ways. For thisu reason it is key to understand move semantics (it purpose, its basic rules, and how to use them in practice).

This session teaches the basics of C++ move semantics. Based on the basic principles, it motivates and explains move semantics so that you as an application programmer you can use move semantics correctly und understand its use better.

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

IT Communication
Nicolai Josuttis (http://www.josuttis.com) is well known in the programming community because he not only speaks and writes with authority (being the (co-)author of the world-wide best sellers The C++ Standard Library (www.cppstdlib.com), C++ Templates (www.tmplbook.com), C++1... Read More →


Tuesday October 26, 2021 7:45am - 8:45am MDT
`Online _2

7:45am MDT

Differentiable Programming in C++
Mathematical derivatives are vital components of many computing algorithms including: neural networks, numerical optimization, Bayesian inference, nonlinear equation solvers, physics simulations, sensitivity analysis, and nonlinear inverse problems. Derivatives track the rate of change of an output parameter with respect to an input parameter, such as how much reducing an individuals’ carbon footprint will impact the Earth’s temperature. Derivatives (and generalizations such as gradients, jacobians, hessians, etc) allow us to explore the properties of a function and better describe the underlying process as a whole. In recent years, the use of gradient-based optimizations such as training neural networks have become widespread, leading to many languages making differentiation a first-class citizen.

Derivatives can be computed numerically, but unfortunately the accumulation of floating-point errors and high-computational complexity presents several challenges. These problems become worse with higher order derivatives and more parameters to differentiate.

Many derivative-based algorithms require gradients, or the computation of the derivative of an output parameter with respect to many input parameters. As such, developing techniques for computing gradients that are scalable in the number of input parameters is crucial for the performance of such algorithms. This paper describes a broad set of domains where scalable derivative computations are essential. We make an overview of the major techniques in computing derivatives, and finally, we introduce the flagman of computational differential calculus -- algorithmic (also known as automatic) differentiation (AD). AD makes clever use of the ‘nice’ mathematical properties of the chained rule and generative programming to solve the scalability issues by inverting the dependence on the number of input variables to the number of output variables. AD provides mechanisms to augment the regular function computation with instructions calculating its derivatives.

Differentiable programming is a programming paradigm in which the programs can be differentiated throughout, usually via automatic differentiation. This talk introduces the differentiable programming paradigm in terms of C++. It shows its applications in science as applicable for data science and industry. The authors make an overview of the existing tools in the area and the two common implementation approaches -- template metaprogramming and custom parsers. We demonstrate implementation pros and cons and propose compiler toolchain-based implementation either in clang AST or LLVM IR. We would like to briefly outline our current efforts in standardization of that feature.

Speakers
avatar for William Moses

William Moses

PhD Candidate, MIT
avatar for Vassil Vassilev

Vassil Vassilev

Research Software Engineer, Princeton


Tuesday October 26, 2021 7:45am - 8:45am MDT
`Online _3

7:45am MDT

Design Patterns: Facts and Misconceptions
This session is part of the Software Design Track.

Design Patterns have proven to be useful over several decades and knowledge about them is still very important to design robust, decoupled systems. However, in recent decades a lot of misconceptions have piled up, many based on misunderstandings about software design in general and Design Patterns in particular.

This purpose of this talk is to help to separate facts from misconceptions. It explains what software design is, how Design Patterns fit in, and what an idiom is. Also, it addresses the following misconceptions about Design Patterns:

- Design Patterns are outdated and have become irrelevant;
- The GoF Design Patterns are nothing but idioms;
- The GoF Design Patterns are limited to object-oriented programming;
- ‘std::make_unique’ is a Design Pattern and helps to adhere to SRP;

After this talk, attendees will have a much deeper understanding of the art of software design and about the purpose of Design Patterns.

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

C++ Trainer/Consultant, Freelancer
Klaus Iglberger is a freelancing C++ trainer and consultant. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the... Read More →


Tuesday October 26, 2021 7:45am - 8:45am MDT
`Online _5
  • Software Design, Online

7:45am MDT

Code Analysis++
Martin Fowler once wrote that high-quality software is actually cheaper to produce than low-quality software. We agree with that sentiment, and we warmly welcomed the C++ Core Guidelines when they were introduced in 2015. Research and surveys conducted in the C++ Community consistently demonstrate the popularity of the Clang family of tools, as well as the growing demand for static analysis to be added to code editors.

In this talk, we’ll explore the current capabilities of existing C++ static analyzers and discuss some of the enforcements listed in the C++ Core Guidelines from a toolability aspect. We’ll also look into the recent “Simplify C++” trend in the language’s evolution, and to wrap things up we’ll take a look at how technology-specific analysis (like MISRA and AUTOSAR) is being adopted.

A variety of checks will be discussed, from catching a dangling pointer to conforming to the preferred code style and naming scheme. And I want to share a crazy idea I have about gamifying static analysis. Let’s play!

Speakers
avatar for Anastasia Kazakova

Anastasia Kazakova

PMM, JetBrains


Tuesday October 26, 2021 7:45am - 8:45am MDT
`Online _4
  • Tooling/Debugging, Online

9:00am MDT

Working with Asynchrony Generically: A Tour of C++ Executors (part 2 of 2)
Asynchrony is increasingly important across the software industry, yet C++ lacks a standard async programming model or a comprehensive set of asynchronous algorithms. In this talk, Eric will describe the approach to asynchrony taken by standard Executors, currently targeting C++23. This talk with focus on how to use the new facilities, with glimpses under the covers to see how things work.

"Asynchrony" means many things. It means concurrency (e.g., thread pools) and parallelism (e.g., GPUs). It means parameterizing a computation on where it should execute. It means the ability to chain work, propagating values and errors to user-specified continuations. It means forking and joining async control flow without blocking. It requires guarantees that async work can make forward progress. It means a standard way to request that a computation stop early, and a way to propagate the "I have now stopped" notification back to the caller. And -- since this is C++ -- it means doing all that with bare-metal performance and seamless integration with C++20 coroutines.

The async programming model espoused by the recent standard Executors papers satisfies these constraints while also enabling a full suite of Generic asynchronous algorithms. C++23 will likely come with algorithms such as `then` for chaining work, `timeout` and `stop_when` for cancelling work after certain criteria are met, `when_all` for launching concurrent work and joining (without blocking), and `sync_wait` for blocking until work has finished.

The core abstraction of the Executors design, known as "Sender/Receiver", is to asynchronous algorithms what the STL's "Iterator" abstraction is to sequence algorithms: an enabling abstraction that makes reusable algorithms possible. With the containers and algorithms of the STL, the C++ Standard Library took a giant step forward in power and reusability. With C++23 Executors, the Standard Library takes the next step.

Speakers
avatar for Eric Niebler

Eric Niebler

Distinguished Engineer, NVIDIA
Eric is a long-time member of the ISO C++ Standardization Committee, and is probably best known for his work bringing ranges support to the C++20 Standard Library. He specializes in modern C++ library design, authoring several Boost libraries and the popular range-v3 library for computing... Read More →


Tuesday October 26, 2021 9:00am - 10:00am MDT
`Online _1

9:00am MDT

Back To Basics: Overload Resolution
During this talk we will explain the definition of a function overload and what rules the compiler follows to decipher which overload to call. The rules can be complex and may not always do what you expect. We will condense the C++ standard to the essential rules every programmer should be aware of in order to reason through overload resolution.

Knowing how overload resolution works will improve your ability to debug compiler errors and this is vital to write correct code. We will provide simple and concise explanations for various buzzwords like template argument deduction, implicit conversion, standard conversions, and tie-breakers.

This talk is part of the Back to Basics track and the material will be targeted to include all skill levels. Familiarity with C++ is recommended however no prior knowledge of function overloads is required.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets including... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for nearly twenty years. My degree is in Computer Science from Cal Poly San Luis  Obispo. I have transitioned to independent consulting and I am currently working on a project for RealtyShares in San Francisco. Co-founder of CopperSpice... Read More →


Tuesday October 26, 2021 9:00am - 10:00am MDT
_2
  • Code Design, Hybrid

9:00am MDT

Embracing User Defined Literals Safely to Create Classes that Act as if Built-in
A fundamental design goal of C++ is to minimize the expressive differences between built-in types and user-defined types (UDTs). Just as we can overload `operator+` for our UDT, we can also specify a syntax for creating a value of that type; think `123_bigint` or `"[a-z]*"_regexp`. But just because we *can* overload an operator or create a user-defined literal (UDL), doesn't mean that we *should* do so. In this talk, we will cover the benefits of UDLS, several ways of defining them (each more powerful and complex than the one before), some best practices, and -- most importantly -- the pitfalls of defining one's own UDLs and when *not* to.

Speakers
avatar for Pablo Halpern

Pablo Halpern

Software Engineer, Halpern-Wight, Inc.
Pablo Halpern has been programming in C++ since 1989 and has been a member of the C++ Standards Committee since 2007. His major contributions to the standard have been in the areas of parallel and vector programming constructs as well as on improvements to the usability of memory... Read More →


Tuesday October 26, 2021 9:00am - 10:00am MDT
_3
  • const/Units/Time, Hybrid

9:00am MDT

Beyond struct: Meta-programming a struct Replacement in C++20
The humble struct. We all use it. We all bump up against its limitations, especially when trying to manipulate it at compile time.

What if I told you that C++20 has enough features that we can meta-program a struct replacement?

Want to have static, compile-time introspection?

Want to add and remove members with compile-time programming?

Want to have type deduction for members?

Want to easily convert from array of structures to structure of arrays (SOA) to optimize cache-friendly traversal?

C++20 allows us to do all these things and more!

No preprocessors, no macros, just standard C++.

Come join me as we explore the magic unleashed by C++20!

Speakers
avatar for John Bandela

John Bandela

Software Engineer, Google
I first started programming in C++ at age 14 in 1994 when I cajoled my parents into buying me Visual C++ 1.0 for my birthday. It took a while, but as I learned the language, I decided I really liked C++. I attended the University of Florida and obtained my undergraduate degree in... Read More →


Tuesday October 26, 2021 9:00am - 10:00am MDT
_1
  • Templates/Concepts, Hybrid

10:30am MDT

Misra Parallelism Safety-critical Guidelines for C++11, 17, Then C++20, 23
The next revision of MISRA C++ is heavily anticipated and the group has been working at an even higher cadence since the shutdown. What you may not know is that there is also a group working on C++ parallel concurrency safety rules to be issued alongside the next MISRA.

There have been very few attempts to take parallelism in a safety critical direction even as many in the industry head towards multicore, manycore, and heterogeneous architectures. This is especially the case in the automotive, medical, and engineering industry and there has been increasing demands for these kinds of guidelines. However, most safety rules tend to focus only on sequential code. There have been a few previous attempts at defining safe parallelism rules by Autosar, High Integrity C++, several H2020 projects, as well as C++ CG, but none have produced statically checkable rules in the format of MISRA. This WG within MISRA C++ attended by safety experts with parallelism background is attempting to unify these attempts.

This talk will summarize the latest progress of this group, reviewing the rules that have the potential of entering MISRA NEXT, as well as those we deferred to a subsequent release. We will discuss the philosophy of why some rules are accepted, or rejected, or deferred. There are currently 18 rules that could be accepted, with another 20 rules that are deferred to the following release. We will speak of the challenge of being C++ parallel safety experts in our respective companies. Finally, while MISRA NEXT will likely aim for C++11, 14, 17, we look into the future, where we also aim to serve the parallelism features in C++20, 23.

Speakers
avatar for Ilya Burylov

Ilya Burylov

Principal Engineer, Intel Corporation
Ilya is an architect of C++ software solutions for autonomous driving market. He is working on contribution into functional safety standard MISRA and C++ standard bodies in threading and vectorization.Ilya has contributed into various Intel software products such as Intel DAAL and... Read More →
avatar for Andreas Weis

Andreas Weis

Andreas Weis has been writing C++ code in many different domains, from real-time graphics, to distributed applications, to embedded systems. As a library writer by nature, he enjoys writing portable code and exposing complex functionalities through simple, richly-typed interfaces... Read More →
avatar for Michael Wong

Michael Wong

DE, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups... Read More →


Tuesday October 26, 2021 10:30am - 11:30am MDT
`Online _2

10:30am MDT

Spooky Action at a Distance
I hate the term “Design Patterns”. It implies there are universally applicable solutions to some common code scenarios. Just codifying existing practice into some rules and blindly following them is a comfortable path, but not the optimal one. It turns out it’s not as easy as following recipes. Each situation and best associated solution is unique.

However there is value in having uniform code structure throughout a project. So this topic is not to be discarded just yet, rather it needs more careful examination.

In terms of inspectable properties of objects, what have we learned from years of OO influence from other languages and frameworks? How can we leverage these borrowed techniques in a value-oriented context? Does C++ benefit from special considerations?

I think it’s time to revisit our old friend, the Observer pattern - from “theory” to practice. I’m not going to offer The Solution, rather we’re going to examine tradeoffs for several possible implementations, in various usage scenarios from a real project.

Speakers
avatar for Victor Ciura

Victor Ciura

Principal Engineer, CAPHYON
Victor Ciura is a Principal Engineer at CAPHYON, Technical Lead on the Advanced Installer team and a Microsoft MVP (Developer Technologies).He’s a regular guest at Computer Science Department of his Alma Mater, University of Craiova, where he gives student lectures & workshops on... Read More →


Tuesday October 26, 2021 10:30am - 11:30am MDT
`Online _4
  • Code Design, Online

10:30am MDT

Back to Basics: const and constexpr
It is a virtue to program as const as possible in modern C++. Your program is by design way more type safe, has fewer concurrency issues, and runs with high probability faster.
Const has many flavors in modern C++. Thanks to const, you can protect a value against mutation. With constexpr, you can initialize and compute values at compile time. Thanks to conteval, a computation can only run at compile time. In the end, constinit empowers you to initialize a modifiable value at compile time.

Let me show you in my lecture how you can initialize a value with constexpr and constinit in a thread-safe way. Let me show you how const and constexpr help you protect values from mutation and, therefore, make them immune to data races. Finally, let me show you how constexpr and consteval empowers you to improve the performance of your program and get functions that are by design easy to test, easy to maintain, and implicitly thread-safe.

Speakers
avatar for Rainer Grimm

Rainer Grimm

C++ trainer, Modernes C++
Rainer works as a software architect, team lead, and instructor since 1999. In 2002, he created a further education round at his company. He gives seminars since 2002. Rainer's first seminars were about proprietary management software, but seminars for Python and C++ followed immediately... Read More →


Tuesday October 26, 2021 10:30am - 11:30am MDT
`Online _1
  • const/Units/Time, Online

10:30am MDT

Documentation in the Era of Concepts and Ranges
Concepts and ranges change how we should think about documentation in C++.

Concepts give us a new way to explicitly constrain templates without resorting to arcane tricks, directly stating requirements on our interfaces as code. Ranges allow us to restructure our programs to describe what the code should do by composing named patterns rather than how it should do it through state-manipulating operations.

As a facility for specifying requirements, to what extent are concepts self-documenting for users of a given interface? How should we balance pure-code descriptions of our interfaces with textual descriptions? How can we use them in aid of creating documentation tuned for our target audience and give them the information they need in a digestible format? We’ll discuss these questions, propose some answers, look at existing documentation from real-world projects, and use ranges as a case study for documenting concepts-based APIs.

Speakers
avatar for Christopher Di Bella

Christopher Di Bella

Software Engineer, Google LLC
Christopher Di Bella is a software engineer working on Google's Chrome OS toolchain team. In a nutshell, this means he's responsible for delivering a high-quality LLVM toolchain to Chrome OS developers, and some of that work includes libc++. Christopher is passionate about generic... Read More →
avatar for Sy Brand

Sy Brand

C++ Developer Advocate, Microsoft
Sy Brand is Microsoft’s C++ Developer Advocate. Their background is in compilers and debuggers for embedded accelerators, but they’re also interested in generic library design, metaprogramming, functional-style C++, undefined behaviour, and making our communities more welcoming... Read More →


Tuesday October 26, 2021 10:30am - 11:30am MDT
`Online _3
  • Templates/Concepts, Online

10:30am MDT

Extending and Simplifying C++: Thoughts on pattern Matching using `is` and `as`
C++20 is a unique historic milestone: It's the first edition of Standard C++ that’s “D&E-complete,” with essentially all of the features Bjarne Stroustrup outlined in /The Design and Evolution of C++/ for C++’s evolution. That doesn’t mean evolution is done, however, and work continues on adding a few more important features in C++23 and beyond, including reflection and pattern matching.

In this talk, I’ll show the C++ pattern matching libraries and language proposals we’ve considered, and present my own contribution that builds on them. My paper has two major aims: (1) to make the syntax clean and regular, and avoid inventing a little sublanguage that works only inside “inspect”; and (2) to make it generalizable so we can use it consistently throughout the language, because matching a pattern is a broadly useful feature that ideally should not be limited to “inspect” only… for example, we would love to express patterns in “if” and “requires” conditions too.

I hope that the most important contribution is that, if we add pattern matching in a way that also provides general “match” and “extract” support throughout the language in the form of generalized “is” constraints and “as” casts, the net result is that we can actually simplify C++… yes, even as we add new features and more expressive power. How can that be simpler? By letting programmers directly express their intent where they have to express it indirectly today, by making the language more regular with fewer special cases to learn, by unifying the syntax of existing standard library features that today have a gaggle of different and divergent styles (e.g., variant, optional), and by providing one general and expressive way to use patterns cleanly throughout C++.

Speakers
avatar for Herb Sutter

Herb Sutter

Software architect, Microsoft
Herb is an author, designer of several Standard C++ features, and chair of the ISO C++ committee and the Standard C++ Foundation. His current interest is simplifying C++.


Tuesday October 26, 2021 10:30am - 12:00pm MDT
Aurora C/D

12:30pm MDT

Back to Basics: Concurrency
Delayed broadcast

You have spent your hard earned money on a multi-core machine. But what does that mean for you as a programmer or for the consumers of your software who also spent their hard earned money on a multi-core machine? Well the deal is, you only get an increase in performance, if you know how to take advantage of your hardware. Perhaps you have also heard something about the free lunch being over for programmers?

In this talk we provide a gentle introduction to concurrency with the modern C++ std::thread library. We will introduce topics with pragmatic code examples introducing the ideas of threads and locks, and showing how these programming primitives enable concurrency. In addition, we will show the common pitfalls to be aware of with concurrency: data races, starvation, and deadlock (the most extreme form of starvation!). But don’t worry--I will show you how to fix these concurrency bugs!

The session will wrap up with discussion and examples of other concurrency primitives and how to use them to write concurrent programs for common patterns(different types of locks, conditional variables, promises/futures). Attendees will leave this session being able to use threads, locks, and start thinking about architecting multithreaded software. All materials and code samples will also be posted online.

Speakers
avatar for Mike Shah

Mike Shah

Assistant Teaching Professor/3D Senior Graphic Eng, Northeastern University
Michael D. Shah completed his Ph.D. at Tufts University in the Redline Research Group in 2017. His Ph.D. thesis advisor was Samuel Z. Guyer. Michael finished his Masters degree in Computer Science in 2013 at Tufts University and Bachelors in Computers Science Engineering at The Ohio... Read More →


Tuesday October 26, 2021 12:30pm - 1:30pm MDT
`Online _1

12:30pm MDT

Implementing static_vector: How Hard Could it Be?
Delayed broadcast

static_vector is a std::vector that allocates things on the stack instead of the heap. We have std::vector, so it should be easy to write a non-allocating version, right?

Sadly, it's not quite that simple. There are many aspects of the vector interface that make sense based on a container that can reallocate, but do not make sense for a container that cannot. This leads to some API differences. static_vector also faces certain challenges around constexpr that makes it both more and less constexpr than std::vector.

We will go into detail on how std::vector and how static_vector work, how they are similar, and how they differ. This presentation will be focusing on lower-level details and interactions with specific language features in C++20 and (hopefully) C++23. There will be lots of code examples, and we'll step through how they work and where they fall short, trying to build up to a working, production-ready solution.

Speakers
avatar for David Stone

David Stone

Software Engineer, Quantlab
David Stone has worked on autonomous vehicles, large-scale distributed systems, and now works developing software for high-frequency trading. He is a member of the C++ Standardization Committee, where he chairs the Modules Study Group (SG2) and is the vice chair of the Evolution Working... Read More →


Tuesday October 26, 2021 12:30pm - 1:30pm MDT
`Online _4
  • const/Units/Time, Online

12:30pm MDT

Lessons Learned from Packaging 10,000+ C++ Projects
Delayed broadcast

At Bloomberg, we maintain a system that coherently builds and integrates more than 10,000 C++ packages that are maintained independently by thousands of software engineers on hundreds of teams across our Engineering department. In this talk, we will go over the lessons we have learned about maintaining these packages, as well as how package management should interact with third-party libraries, third-party tools, build systems, IDEs, static analysis tools, and refactoring automation. We hope this will start a conversation around the potential requirements for a more complete package management solution in the C++ ecosystem.

Speakers
avatar for Bret Brown

Bret Brown

Team Lead, Bloomberg
Software engineer currently focusing on improving C and C++ ergonomics, correctness, and productivity for Bloomberg's Developer Experience department.Bret works to make authoring and maintaining C++ codebases simpler and more intuitive by treating projects more like cattle and less... Read More →
avatar for Daniel Ruoso

Daniel Ruoso

Senior Software Engineer, Bloomberg
Currently working as the lead for Code Governance at Bloomberg, where we focus on driving large scale Static Analysis and Automated Refactoring. Daniel has been working over the past 20+ years with a persistent lens on how to help engineers be more effective with build, deployment... Read More →


Tuesday October 26, 2021 12:30pm - 1:30pm MDT
`Online _3

12:30pm MDT

Software Architecture Lessons from Multidimensional Spaces Explorations
This session is part of the Software Design Track.

Designing software can be fun, but designing good, clean, reliable, and rock-solid libraries can be of incredible complexity. In this talk we will explore what lessons can be learned on software architecture and domain specific languages design from an exploration around multidimensional arrays and linear algebra. The goal will be to review some guiding principles for good software design in C++20 and discuss programming strategies to attack the problem of compositionality. This talk will aim at shedding a new light on issues that go far beyond the sole scope of multidimensional arrays and will provide insights about the difficulty of achieving simplicity in software design.

We will start from the problem of making multidimensional arrays finally available in C++ and quickly describe the current state of affairs with std::mdspan. We will then try to understand what fundamentally makes the problem so much more complicated in C++ than in many other programming languages that have been equipped with such abstractions for decades. This will let us introduce the so-called GPE principle "Genericity, Performance, and Expressivity" as a way to frame software architecture problems. We will illustrate how this principle can be used as a guide to improve the current design of std::mdspan once combined with new C++20 capabilities ranging from generic Non-Type Template Parameters (NTTPs) to concepts and including generic lambdas in unevaluated contexts. This example will help us understand when and how advanced programming techniques can be used to implement generic, expressive, and performance-oriented abstractions. We will then extend the reflection to the design of Embedded Domain Specific Languages (EDSLs). We will see why shifting the focus from the functionality and implementation to the user perspective can be a particularly relevant strategy for the design of embedded mini-languages. We will illustrate how this principle can be translated in practice in C++20, especially in the context of generic NTTPs that allow template classes to be literally used as mini-compilers. Regarding our specific example, we will see how advanced C++20 constructs can be leveraged to allow library users to manipulate multidimensional arrays through a natural, concise, and expressive syntax. This will finally bring us to upcoming C++ features such as reflection that we will discuss from the perspective of questions about the nature of complexity in programming languages.

In short, beyond multidimensional arrays, Embedded Domain Specific Languages, and advanced implementation strategies, this talk will try to provide an interesting perspective on modern software architecture principles as well as a discussion on complexity, simplicity, and compositionality in the context of C++20.

Speakers
avatar for Vincent Reverdy

Vincent Reverdy

Researcher in Astrophysics and Mathematics, Ecole Normale Supérieure
Vincent has been working as a post-doctoral researcher at the University of Illinois at Urbana-Champaign (USA) since he obtained his PhD at the Paris observatory (France) in november 2014. His main scientific interests are related to cosmology and general relativity. He his particularly... Read More →


Tuesday October 26, 2021 12:30pm - 1:30pm MDT
`Online _5

12:30pm MDT

Changing Legacy Code with Confidence: Practical Advice for Maintaining and Migrating Working Code
Delayed broadcast

Modern best practices always recommend writing new code for testability and maintenance. However, most of us spend more time reading other people’s code and trying to find a place to put our change without breaking existing functionality. Rarely, if ever, does that code have tests; nor does the project timeline allow for large scale refactoring to make it testable. In this talk, we will discuss how to take the fear out of working on legacy code and start working toward not only adding a safety net so we can change with confidence, but also make it easier to understand what the code is actually doing. We’ll look at some techniques that can be implemented without requiring massive hits to your deadlines, and even address issues such as dealing with hardware and timing dependencies in embedded systems. Over time, both you and your team will be rewarded by increased reliability and productivity and no longer dread the word "legacy."

Speakers
avatar for Brian Ruth

Brian Ruth

Sr. Software Engineer, Garmin
Brian has been programming in C++ for 20+ years; working for both small and large companies on a wide variety of projects and technologies. For over a decade he worked with neuroscience researchers and created high speed acquisition, analysis and visualization software. He is currently... Read More →


Tuesday October 26, 2021 12:30pm - 1:30pm MDT
`Online _2

2:00pm MDT

C++ to the RISCue! A Practical Guide for Embedded C++20: From an Idea to the Simulation
Embedded developers don't have to settle/suffer anymore due to ancient toolchains' support!

There are tools available that let you use C++20 in embedded systems to gain real performance benefits.

Moreover, these tools are available ONLINE and include hardware simulators,
which makes it very easy to get started without spending a lot of money or time to gear up.

In this case study, we will take a look into a full Software Development (including testing/simulation) for Embedded devices with C++20.

And we will do it fully using only ONLINE tools with reusable source code for popular microcontrollers.

Let's get ready for ARMing developers with C++20 at CppCon-2021!

Speakers
avatar for Kris Jusiak

Kris Jusiak

Software Architect, Quantlab Financial
Kris is a Software Architect passionate about programming and who has worked in different industries over the years including telecommunications, games and most recently finance for Quantlab Financial, LLC. He has an interest in modern C++ development with a focus on performance and... Read More →


Tuesday October 26, 2021 2:00pm - 3:00pm MDT
_2

2:00pm MDT

Bringing Existing Code to CUDA Using constexpr and std::pmr
The options pricing library I work on at CSIRO is both computationally intensive and highly mathematical – a perfect fit for improving performance by moving calculations to the GPU. In this talk I will discuss my experience adjusting our existing code to use CUDA and some lessons learned along the way.

Adjusting existing code to use CUDA is not yet as simple as recompiling with the Nvidia compiler. There are two primary constraints that working with the GPU imposes. First, the GPU cannot access just any memory address. Second, the GPU cannot execute just any function in your program. These constraints can make it difficult to use code that was not designed with the GPU in mind with CUDA.

In this talk I will first address the constraints on memory layout that working with the GPU imposes. I will then show how I adjusted data-structures and used std::pmr to place data within GPU accessible memory. Next, I will discuss the constraints created by only being able to call on the GPU functions annotated with __device__. I will then show how the CUDA feature for treating constexpr functions as __device__ functions makes it easier to get code running on the GPU and debugging it once it is there. Lastly, I will compare the performance of calculations done on the CPU vs CUDA.

If you are considering porting existing code to CUDA, by the end of the talk you should have a better idea of the impediments to running that code on the GPU and high level details of the strategy I used to overcome those impediments.

Speakers
avatar for Bowie Owens

Bowie Owens

Software Developer, CSIRO
Bowie Owens is a software developer working at Data61, a part of the Australian government funded research organisation CSIRO. The team he works in develops complex mathematical models for pricing financial options. The software developed at Data61 is integrated into a larger trading... Read More →


Tuesday October 26, 2021 2:00pm - 3:00pm MDT
`Online _1

2:00pm MDT

Back to Basics: Templates (part 1 of 2)
Generic programming is powerful idiom for building reusable software components whose behavior can be tailored (parametrized) at compile time. The C++ language supports generic programming with templates, which are at the heart of the Standard C++ Library and the basis of many popular libraries like Eigen, JUCE, POCO C++, and Boost.

This two-part series begins with a brief overview of generic programming and why it is so important and useful in modern C++. We'll look at how C++ templates support generic programming, and provide some examples of the kinds of templates most likely to be encountered: function templates, class templates, alias templates, and variable templates. We'll then provide some practical tips for using templates, debugging template code, and structuring code that contains your own templates.

After that, we'll define and discuss the most important aspects of templates, such as parameters and arguments, substitution and instantiation, specialization, qualification, two-phase translation, non-type parameters, the one-definition rule, linkage, and more. Finally, we'll take a look at some slightly more advanced topics like variadic templates, type traits, tag dispatch, and the new lambda template feature in C++20.

These sessions are for C++ programmers seeking a tutorial or refresher on template fundamentals. If you've avoided templates in the past, or felt a little intimidated by them, or want to gain a better understanding of how templates work and how to use them on a daily basis, then this series is for you. Attendees will leave with a basic understanding of what C++ templates are, how they support perform generic programming, the most common kinds of C++ templates and their uses, the fundamental concepts underlying templates, important template terminology, and how to use and write basic templates in everyday code.

Speakers
avatar for Bob Steagall

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing


Tuesday October 26, 2021 2:00pm - 3:00pm MDT
_1

2:00pm MDT

The Preprocessor: Everything You Need to Know and More!
As much as we try to make it go away, the preprocessor is still here. It is used by many libraries and extensively throughout legacy code. And, in some cases, it is still the best tool to get the job done. In this talk, we will review the C and C++ preprocessor directives, where the abilities of the preprocessor differ between the two languages, and the modern C++ attempts to replace those directives. When this talk is completed, you should be more comfortable both debugging and modernizing preprocessor usage in your code.

Speakers
avatar for Brian Ruth

Brian Ruth

Sr. Software Engineer, Garmin
Brian has been programming in C++ for 20+ years; working for both small and large companies on a wide variety of projects and technologies. For over a decade he worked with neuroscience researchers and created high speed acquisition, analysis and visualization software. He is currently... Read More →


Tuesday October 26, 2021 2:00pm - 3:00pm MDT
_3
  • Tooling/Debugging, Hybrid

2:00pm MDT

Faster, Easier, Simpler Vectors
This session is part of the Software Design Track.

The standard library has the type `std::vector`. It is used ubiquitously as a high-performance container. However, it was standardized in the mid 90s and C++ has seen many changes since then. It has been extended with allocators, move semantics, initializer_list, and much more. Can we do better?

We can. It is possible to write a container and a set of algorithms that are more efficient at run time, have simpler implementations, and have easier, more intuitive APIs. Not only that, but we can also make it easy for users to write their own vector-like containers that make slightly different trade-offs for when you need even more performance, and this presentation includes discussion of several such vectors.

We will go through specific examples of these vector-like types and the algorithms that operate on them, and then take from that general principles of software design. We'll look into how we're limited in what we can do by C++ as it exists today and what up-and-coming proposals can make things even better.

Speakers
avatar for David Stone

David Stone

Software Engineer, Quantlab
David Stone has worked on autonomous vehicles, large-scale distributed systems, and now works developing software for high-frequency trading. He is a member of the C++ Standardization Committee, where he chairs the Modules Study Group (SG2) and is the vice chair of the Evolution Working... Read More →


Tuesday October 26, 2021 2:00pm - 3:00pm MDT
_4

3:15pm MDT

The Upcoming Concurrency TS Version 2 for Low-Latency and Lockless Synchronization
The June 2021 ISO C++ virtual plenary approved Concurrency TS Version 2. This new TS  has been in the works for 6+ years and will move us towards supporting highly intensive, low latency lockless synchronization mechanisms. This talk will be given by the Editing team for Concurrency TS2, as well as some of the specific authors.The initial approved content will be hazard pointers (HP) and read-copy update (RCU).

Hazard pointers is a deferred reclamation technique. It is used for fast and scalable protection of access to shared objects that may be removed concurrently. It allows indefinite protection, which makes it suitable for cases of object protection while blocking or while executing arbitrary user code. It also guarantees bounding of unreclaimed objects that are eligible for reclamation.

RCU is another deferred-reclamation technique that is most frequently used to replace reader-writer locking for linked data structures in a number of operating system kernels and concurrent applications.  In the most aggressive implementations, RCU readers might use exactly the same sequence of instructions that would be used in the same traversal of a read-only data structure, which means that RCU can provide excellent read-side performance and scalability.  The C++ RCU proposal features RAII RCU readers, both intrusive and non-intrusive retire functions, and full compatibility with the C++ type system.

This talk will describe the final approved form of hazard pointers and RCU, and also what we hope to learn from the TS process.  This talk will also cover in-the-wild advances in hazard pointers and RCU during the multi-year process leading up to this TS.  We will draw examples from the Folly library, where both hazard pointers and RCU are used, and from the various forms of RCU within the Linux kernel.  We expect that the TS will be a good vehicle for feedback, and the in-the-wild advances will also help shape entry into IS.

We will also give a high-level overview of other contents that we expect to be added to the TS such as Snapshot and Asymmetric fences. We hope to describe these in a future talk after they have passed LWG review. We believe that in about a year, Concurrency TS2 will be completed and released for public review.

We will also describe the new chapters that we hope will enter the C++ standard in C++23 or C++26.

Speakers
avatar for Paul E. McKenney

Paul E. McKenney

Software Engineer, Facebook
Paul E. McKenney has been coding for almost four decades, more than half of that on parallel hardware, where his work has earned him a reputation among some as a flaming heretic. Paul maintains the RCU implementation within the Linux kernel, where the variety of workloads present... Read More →
avatar for Maged Michael

Maged Michael

Engineer, Facebook
Maged Michael is a software engineer at Facebook. He is the inventor of hazard pointers, lock-free malloc and several algorithms for concurrent data structures. He received a Ph.D. in computer science from the University of Rochester. He is an ACM Distinguished Scientist. He is an... Read More →
avatar for Michael Wong

Michael Wong

DE, Codeplay
Michael Wong is VP of R&D at Codeplay Software. He is a current Director and VP of ISOCPP , and a senior member of the C++ Standards Committee with more then 15 years of experience. He chairs the WG21 SG5 Transactional Memory and SG14 Games Development/Low Latency/Financials C++ groups... Read More →


Tuesday October 26, 2021 3:15pm - 4:15pm MDT
_4

3:15pm MDT

Composable C++: Principles and Patterns
This session is part of the Software Design Track.

Programming consists of two activities:

1. Breaking down a problem in parts small enough to understand and implement.
2. Composing the parts to build up functionality and solve the original problem.

That second step is where complexity has an unfortunate tendency to show up,
time and time again.

In this talk, I will highlight some recipes and principles for crafting code that can be more beautifully composed. We'll see how to build on composition-friendly types and patterns and leverage them to achieve simpler code, and in turn how this allows us to use those composable pieces to solve not just the original problem but sibling problems.

I'll show useful techniques in crafting composable interfaces: at the function level, considering types; at the object level, considering patterns; at the larger structural level, considering hierarchies, traversal and execution choices. These techniques are equally applicable to "traditional" run-time polymorphic code and to code that uses compile-time polymorphism.

Speakers
avatar for Ben Deane

Ben Deane

Ben was a game programmer for over 20 years, working in C++ since the late 90s, for companies like EA and Blizzard. In 2018 he left the games industry to join Quantlab, an automated trading firm, where he writes modern, well-performing C++. He likes to play with algorithms, and to... Read More →


Tuesday October 26, 2021 3:15pm - 4:15pm MDT
_3

3:15pm MDT

Back to Basics: Templates (part 2 of 2)
Generic programming is powerful idiom for building reusable software components whose behavior can be tailored (parametrized) at compile time. The C++ language supports generic programming with templates, which are at the heart of the Standard C++ Library and the basis of many popular libraries like Eigen, JUCE, POCO C++, and Boost.

This two-part series begins with a brief overview of generic programming and why it is so important and useful in modern C++. We'll look at how C++ templates support generic programming, and provide some examples of the kinds of templates most likely to be encountered: function templates, class templates, alias templates, and variable templates. We'll then provide some practical tips for using templates, debugging template code, and structuring code that contains your own templates.

After that, we'll define and discuss the most important aspects of templates, such as parameters and arguments, substitution and instantiation, specialization, qualification, two-phase translation, non-type parameters, the one-definition rule, linkage, and more. Finally, we'll take a look at some slightly more advanced topics like variadic templates, type traits, tag dispatch, and the new lambda template feature in C++20.

These sessions are for C++ programmers seeking a tutorial or refresher on template fundamentals. If you've avoided templates in the past, or felt a little intimidated by them, or want to gain a better understanding of how templates work and how to use them on a daily basis, then this series is for you. Attendees will leave with a basic understanding of what C++ templates are, how they support perform generic programming, the most common kinds of C++ templates and their uses, the fundamental concepts underlying templates, important template terminology, and how to use and write basic templates in everyday code.

Speakers
avatar for Bob Steagall

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing


Tuesday October 26, 2021 3:15pm - 4:15pm MDT
_1

3:15pm MDT

Making the Most Out of Your Compiler
Once you decide to start a big project or a company, it eventually comes down to unifying the build infrastructure. However, hundreds and thousands of compilation units are extremely difficult to maintain to achieve the highest possible performance. Contrary to the belief that you should always trust your compiler, recent micro-architectural breakthroughs from merging two arrays with special instructions to JSON parsing through SIMD showed that compilers are far from understanding every single piece of code you write. In this session we will talk about our experience on how to achieve the highest possible performance without much rewriting of your code, which trade-offs C++ compilers have, how to make the most of your micro-architecture, why unrelated changes may decrease the performance and how to debug them. In the end we will show which compiler options gave us the opportunity to gain 5-15% of performance, stabilized the benchmarks and decreased the build size for search engines, databases and high performance computing.

Speakers
avatar for Danila Kutenin

Danila Kutenin

Software Engineer, Google
Danila is a software engineer at Google working in data processing efficiency. As MapReduce and Flume technologies evolve, they currently use a significant portion of the entire server fleet. The main effort is to reduce the resource usage without reducing the computation at scale... Read More →


Tuesday October 26, 2021 3:15pm - 4:15pm MDT
`Online _1
  • Tooling/Debugging, Online

3:15pm MDT

Static Analysis and Program Safety in C++: Making it Real
In this talk, I will explore how to leverage language rules and static analysis principles to provide safety guarantees in C++ at compile time, without compromising on its performance and memory efficiency. Modern analysis tools have come a long way since their inception and are much more powerful than traditional Lint-style checks. They use several techniques from theorem solvers to simple heuristics mimicking developer’s reasoning and can find deep semantic errors in programs. Furthermore, modern analysis tools take advantage of information available in types and type extensions in the language to bridge the gap across function boundaries, without incurring performance penalties of running global analyses. This makes them an indispensable part of the “shift left” experience to drive program safety. Throughout the talk, I will share my experience in developing and running these tools on large production codebases over the last decade and how they evolved over time. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

Speakers
avatar for Sunny Chatterjee

Sunny Chatterjee

Principal Software Engineering Manager, Visual C++, Microsoft Corporation
Sunny leads a team responsible for developing the core C++ static analysis engines in Visual Studio productivity experience as well as the traditional security tooling scenarios used widely within Microsoft. He has many years of experience in static analysis and enjoys delivering... Read More →


Tuesday October 26, 2021 3:15pm - 4:15pm MDT
_2
  • Tooling/Debugging, Hybrid

4:45pm MDT

Deploying the Networking TS
The Networking TS provides a framework for writing asynchronous and network-aware applications. A framework which also promotes reusable and testable code. These platonic concerns are only part of software engineering however, and only a small part of the motivation for a framework. When all is said and done one must not merely prepare to reuse code but actually use it, not just test it but deploy it.

How is an actual, deployed application using the Networking TS structured? How do the principles of reusable, testable Networking TS code compose as one writes an actual application rather than a test suite? How can one integrate components which exist outside the Networking TS’s ecosystem into an application based on the Networking TS?

This talk will take the listener on a guided tour of a deployed application written using the Networking TS, the techniques employed to maintain the promises of the Networking TS while fulfilling the needs of an actual application, and how this lays the foundation not only to maintain the current application but also to author additional applications going forward as the deployment and maintenance cycle continues.

Speakers
avatar for Robert Leahy

Robert Leahy

Lead Software Engineer, MayStreet Inc.
Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After 4.5 years in full stack web development he switched to financial infrastructure software development in early 2017. He’s since become involved in the... Read More →


Tuesday October 26, 2021 4:45pm - 5:45pm MDT
_3

4:45pm MDT

PGAS in C++: A Portable Abstraction for Distributed Data Structures
Writing programs that run on clusters of computers is notoriously tedious and error-prone, particularly for applications like genomics, sparse linear algebra, and graph analytics, which often require fine-grained, irregular communication.

In this talk, I'll argue that the Partitioned Global Address Space (PGAS) programming model, which allows remote access to a portion of the memory space on remote processes in a distributed program, is an effective model for implementing portable, high-level C++ data structures that automatically distribute data, while taking advantage of the high-performance RDMA network primitives available in most supercomputer and data center environments.

I'll discuss how our distributed data structures library BCL builds upon the concept of a global pointer to build a collection of high-performance, high-level data structures, including hash tables, queues, and dense and sparse matrices, that can be used across a variety of communication libraries, including MPI, OpenSHMEM, and GASNet-EX. I'll touch on the some of the important issues that arise in implementing distributed data structures, such as synchronization, remote reference objects, and support for GPUs.

Speakers
avatar for Benjamin Brock

Benjamin Brock

PhD Candidate, UC Berkeley
Ben Brock is a PhD student at UC Berkeley, where he works on building libraries, tools, and algorithms for high-performance computing. His main work focuses on building a cross-platform library of data structures for distributed applications, with a focus on sparse linear algebra... Read More →


Tuesday October 26, 2021 4:45pm - 5:45pm MDT
_1

4:45pm MDT

Using C Libraries in your Modern C++ Embedded Project: A journey integrating an EtherCAT stack, a C++17 compiler, and Modern C++ idioms
Projects have goals, timelines, and deliverables which should shape our solution space and approach. A recent project incorporating EtherCAT had other technical challenges and a fixed timeline which resulted in a basic integration approach.

After the project was complete I continued developing Ciere's capabilities to handle EtherCAT based communication. In all, three different levels of integration were developed.

This talk will briefly introduce the real-time suitable communication technology called EtherCAT and then review the progression of integration approaches. We will explore the techniques and language features employed and extract some rules of thumb about layered architectures. We will look at the technical, timeline, and risk trade-offs for each approach as we make observations about the value provided.

While this talk focuses on integrating C-libraries and facilities within a Modern C++ embedded target, the lessons learned and insights are applicable to Modern C++ projects of all sized targets. Attendees will walk away with a set of patterns for dealing with C library integration, some guidelines about value trade-offs, and one person's experience with implementations.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →


Tuesday October 26, 2021 4:45pm - 5:45pm MDT
_4
  • Embedded, Onsite

4:45pm MDT

In-memory and Persistent Representations of C++
C++ Modules are a tooling opportunity. For example, a common implementation strategy for compilers is to save on disk the abstract semantics graph (ASG) obtained from elaborating a module interface (exported), to be reused later when that module is consumed (imported). That ASG, an intermediate representation, saves the compiler from repeated work in common scenarios, therefore helps achieve substantial reduction in compilation time. In essence, ISO C++ compilers are practically compelled to acknowledge representations of C++ program fragments other than character streams stored in source files. It is all too tempting to view these ASGs as mere build artifact curiosities. If N compilers, on a given platform, decide to use N different on-disk ASG representation formats then we face a severe problem of developer tools fragmentation. I present, in this talk, how the C++ community can avoid that problem: the desiggn and implementation of formal, compiler-neutral in-memory and persistent representations of C++ programs. These alternative representations allow tools to process C++ programs without needing to master or to replicate the dark art of C++ compiler construction. These representations are available either as open specification, or as C++ libraries. The application opportunities range from automated generation of bindings ("foreign function/data interface") to Just-In-Time compilation of interpreted C++ scripts, and beyond.

Speakers
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Principal Software Engineer, Microsoft
Gabriel Dos Reis is a Principal Software Engineer at Microsoft, where he works in the area of large scale software construction, tools, and techniques. He is also a researcher, and a longtime member of the C++ community, author and co-author of numerous extensions to support large... Read More →


Tuesday October 26, 2021 4:45pm - 5:45pm MDT
_2

8:30pm MDT

Lightning Talks
Come for bite size talks you'll want more of!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →

Tuesday October 26, 2021 8:30pm - 10:00pm MDT
Aurora C/D
 
Wednesday, October 27
 

6:00am MDT

Lightning Talks
Delayed broadcast

Come for bite size talks you'll want more of!

Moderators
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →

Wednesday October 27, 2021 6:00am - 7:30am MDT
`Online _1

7:45am MDT

The Foundation of C++ Atomics: The Knowledge You Need to Correctly Use C++ Atomics.
This talk covers all the knowledge you need about atomics to give you a good understanding of how they work under the hood and make sure your code is correct.

C++11 introduced std::atomic template class which supports six memory orderings, writing correct concurrent programs which use the atomic classes can be challenging. It requires understanding the complexity of how std::atomic works under the hood. The goal of this talk is to encourage programmers to use the atomic classes when appropriate and give them the knowledge to do so correctly.

This talk will help you confidently use atomics correctly by bringing knowledge of some of the main components that make parallelism possible in modern computer systems, the relationship between these components, and the individual contribution of each of these components in making atomic difficult to use correctly.

This talk will be aimed at programmers who are new to std::atomic as well as those who have been using these classes. I will show some aspects of atomics which may not be commonly known.

Topics Covered:
• A brief overview of atomics in C++.
• Multi-core processors.
• Operating system context switching.
• Memory Barriers.
• Memory Consistency and Cache Coherence.
• Static & Dynamic Instruction Scheduling.
• The C++ memory model
• Optimizations Allowed by the memory model.
• The Cost of Sequentially Consistent Atomics.
• Semantics of Data Races.
• Compiler and Hardware introduced Data Races.
• The compiler and hardware cooperation to respect the memory model.
• The relationships and tradeoffs among atomics and fences/barriers.
• How atomic map to their expected machine-instruction implementations on x86 architecture .

Speakers
avatar for Filipe Mulonde

Filipe Mulonde

MSc student, Peter the Great St. Petersburg Polytechnic University
Software Engineer passionate about programming,holds a bachelor's degree in software engineering from Peter the Great St. Petersburg Polytechnic University and is now a final year Master's student in Artificial Intelligence at this same university. worked as a software engineer intern... Read More →


Wednesday October 27, 2021 7:45am - 8:45am MDT
`Online _1
  • Async/Concurrency/Parallelism, Online

7:45am MDT

SIMD in C++20: EVE of a new Era
EVE is a new library that exposes SIMD in a uniform way across both ARM (neon) and x86 (from sse2 to avx-512).

It's main advantages over similar libraries include:
* STL like algorithm support, including zip to operate on multiple ranges .
* ARM support (many libraries only support x86)
* A very comprehensive math library.

It is liberally licensed and intended to be production quality. But let's just be direct: vectorized find for x86 and arm on godbolt: https://godbolt.org/z/n6Pds78s6

This talk will include a collection of demos for different library features and benchmarks, how C++20 helped us construct a proper design as well as practical advice on using EVE in your projects.

Speakers
avatar for Denis Yaroshevskiy

Denis Yaroshevskiy

Sr Software Developer, Bloomberg
Denis is a semi-active member of the C++ community. He is mostly interested in algorithms and has done a few things in that area such as: research and implementation of Chromium’s flat_set, a couple of tiny contributions to libc++ algorithm library, a few algorithm related talks... Read More →
avatar for Joel Falcou

Joel Falcou

Teachign Advisor, Code Reckons
Joel Falcou is NumScale CTO. NumScale mission is to assist businesses in the exploration and subsequently the mastery of high-performance computing systems. He is also an assistant professor at the University Paris-Sud and researcher at the Laboratoire de Recherche d’Informatique... Read More →


Wednesday October 27, 2021 7:45am - 8:45am MDT
`Online _4
  • C++20/Future of C++, Online

7:45am MDT

Interactive C++ for Data Science
C++ is used for many numerically intensive applications. A combination of performance and solid backward compatibility has led to its use for many research software codes over the past 20 years. Despite its power, C++ is often seen as difficult to learn and not well suited with rapid application development. The long edit-compile-run cycle is a large impediment to exploration and prototyping during development.

Cling has emerged as a recognized capability that enables interactivity, dynamic interoperability and rapid prototyping capabilities for C++ developers. Cling is an interactive C++ interpreter, built on top of the Clang and LLVM compiler infrastructure. The interpreter enables interactive exploration and makes the C++ language more welcoming for research. Cling supports the full C++ feature set including the use of templates, lambdas, and virtual inheritance.Cling’s field of origin is the field of high energy physics where it facilitates the processing of scientific data. The interpreter was an essential part of the software tools of the LHC experimental program and was part of the software used to detect the gravitational waves of the LIGO experiment. Interactive C++ has proven to be useful for other communities. The Cling ecosystem includes dynamic bindings tools to languages including python, D and Julia (cppyy); C++ in Jupyter Notebooks (xeus-cling); interactive CUDA; and automatic differentiation on the fly (clad).

This talk outlines key properties of interactive C++ such as execution results, entity redefinition, error recovery and code undo. It demonstrates the capability enabled by an interactive C++ platform in the context of data science. For example, the use of eval-style programming, C++ in Jupyter notebooks and CUDA C++. We talk about design and implementation challenges and go beyond just interpreting C++. We showcase template instantiation on demand, language interoperability on demand and bridging compiled and interpreted code. We show how to easily build new capabilities using the Cling infrastructure through developing an automatic differentiation plugin for C++ and CUDA.

Speakers
avatar for Vassil Vassilev

Vassil Vassilev

Research Software Engineer, Princeton


Wednesday October 27, 2021 7:45am - 8:45am MDT
`Online _3
  • Real-time/Data Science, Online

7:45am MDT

Typescripten: Generating Type-safe JavaScript Bindings for emscripten
WebAssembly has become a very popular target platform for C++ developers. Thanks to emscripten, porting native applications to WebAssembly is easy — as long as the application only uses the browser as a display and input device. However, emscripten does not provide type-safe wrappers to the standard JavaScript APIs such as the DOM manipulation API, let alone any other JavaScript API provided by existing web applications.

Our open source tool “typescripten” has been built on top of three powerful technologies to close this gap. It uses TypeScript interface definition files and the TypeScript compiler API to create type-safe C++ wrappers based on emscripten. TypeScript already has interface definition files for over 7000 JavaScript libraries that you can now use safely from C++.

We strive to design our C++ wrappers such that the C++ code using them looks similar to the equivalent TypeScript or JavaScript code. However, the peculiar semantics of prototype-based Javascript and Typescript are often difficult to translate into a type-based language such as C++. I will discuss the challenges we faced and choices we made when designing this framework.

Speakers
avatar for Sebastian  Theophil

Sebastian Theophil

Senior Software Engineer, think-cell
Sebastian studied Computer Science in Berlin and Toulouse, France, and holds a Ph.D. in Computer Science from the Humboldt University of Berlin. He has been working at think-cell Software since its founding in 2002. Over the years, Sebastian has worked on a lot of things at think-cell... Read More →


Wednesday October 27, 2021 7:45am - 8:45am MDT
`Online _5
  • Tooling/Debugging, Online

7:45am MDT

Back To Basics: The Special Member Functions
The six special member functions. Do you know them all? Do you know when the compiler generates them for you and what they are doing? And most importantly, do you know when they don’t give you what you expect? In this talk I will explain the six special members in detail. We will take a look at the exact circumstances when a compiler would generate these functions, what they are doing by default and when we should deal with them manually. Also, among many other guidelines I’ll explain why we should strive for the Rule of 0, why the Rule of 5 is sometimes unavoidable, and why the Rule of 3 is not obsolete.

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

C++ Trainer/Consultant, Freelancer
Klaus Iglberger is a freelancing C++ trainer and consultant. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the... Read More →


Wednesday October 27, 2021 7:45am - 8:45am MDT
`Online _2
  • Type Design, Online

9:00am MDT

Testing Compile-time Constructs Within a Runtime Unit Testing Framework
C++ is used in many different areas, including in safety-critical applications. Coming from the automotive industry, we must conform to stringent safety standards (such as ISO 26262) which nudge developers away from dynamic dispatch and towards a safer and more static flavor of C++. However, following coding guidelines is not enough to write safe code; any program is only as safe as it’s testing suite is robust, so it is critical to have a solid testing framework and a watertight testing strategy.

There are multiple well-known frameworks for testing the code at runtime, such as GoogleTest, CPPUnit or Catch2, but as more and more work is done at compile-time, we believe that there is a need for a framework that also supports testing compile-time constructs. We believe that with the increasing use of static assertions, SFINAE and, soon, contracts, these compile-time constraints become part of the user-facing API and must be rigorously tested as well. As an example, consider a function which is part of the user-facing API with a static assertion in it to ensure that it can only be called with a certain set of types. With the existing testing frameworks there is no way to test that this function would _not_ accept certain types and only the correct behavior with the expected types can be tested. Therefore it is possible that during the development of the library the static assertion gets removed or modified by mistake, allowing the function to accept more types than expected. This kind of bug can lie undetected until it leads to a failure at some later point in time. We therefore believe that testing the compile-time aspects of the code, and especially being able to test what the code should _not_ be able to do, is just as important as testing the nominal runtime behavior. However, it is challenging to test the behavior of the code at compile time as for that the code must be, well, compiled.

To address this, we present a new library that integrates seamlessly with GoogleTest to allow writing special test cases, that we call static tests, within which certain statements can be wrapped in a SHOULD_NOT_COMPILE macro. When such a test is run, the library attempts to compile the statements within these macros . If they compile without an error, the test will fail and the developer will be alerted with an appropriate failure message. In this talk, we will expand on why we believe such a library is useful with real-life examples, cover how this library can be used, and provide some details on its current implementation.

Speakers
avatar for Igor Bogoslavskyi

Igor Bogoslavskyi

Senior software engineer, Apex.AI
Igor is a senior software engineer at Apex.AI. He has a PhD in Robotics and is working on safe and certifiable algorithms for autonomous and automated driving. Igor is passionate about C++ and, apart from working with C++ for over 10 years professionally and writing and maintaining... Read More →


Wednesday October 27, 2021 9:00am - 9:30am MDT
`Online _1
  • Testing/Error Handling, Online

9:00am MDT

Back To Basics: Undefined Behavior
In this talk we will build a refined and improved definition of undefined behavior, to motivate and encourage C++ developers to write correct code. We will explain the terminology associated with Undefined Behavior and explore why it exists in the C++ language. Looking at the standard is the only way to determine what constitutes undefined behavior.

During this talk we will present several new examples to illustrate how various types of undefined behavior can occur in a short span of code. We will also describe the various categories of behavior and the difference between run time errors and undefined behavior. Understanding these distinctions is critical to being an effective programmer.

This talk is part of the Back to Basics track and the material will be targeted to include all skill levels. Familiarity with C++ is recommended however no prior knowledge of compilers or undefined behavior is required.

Speakers
avatar for Barbara Geller

Barbara Geller

Co-Founder, CopperSpice
I am an independent consultant with over twenty-five years of experience as a programmer and software developer. I have worked with numerous smaller companies developing in-house applications. I have also designed and developed Windows applications for several vertical markets including... Read More →
avatar for Ansel Sermersheim

Ansel Sermersheim

Co-Founder, CopperSpice
I have been working as a programmer for nearly twenty years. My degree is in Computer Science from Cal Poly San Luis  Obispo. I have transitioned to independent consulting and I am currently working on a project for RealtyShares in San Francisco. Co-founder of CopperSpice... Read More →


Wednesday October 27, 2021 9:00am - 10:00am MDT
_1
  • Code Design, Hybrid

9:00am MDT

cudaFlow: A Modern C++ Programming Model for GPU Task Graph Parallelism
Graphics processing unit (GPU) has become central to today’s scientific computing applications, such as machine learning and simulation. As the application complexity continues to grow, the need to quickly execute thousands of dependent GPU tasks has become a major bottleneck in the development flow. To overcome this challenge, modern CUDA has introduced CUDA Graph for users to directly offload a GPU task graph on a GPU to minimize scheduling overheads. However, programming CUDA Graph is extremely tedious and involves many low-level details that are difficult to program correctly. Consequently, we introduce in this paper, cudaFlow, a modern C++ programming model to streamline the building of large GPU workloads using CUDA Graph. cudaFlow enables efficient implementations of GPU decomposition strategies supplied with incremental update methods to express complex GPU algorithms that are hard to execute efficiently by mainstream stream-based models. We have demonstrated the simplicity and efficiency of cudaFlow on large-scale GPU applications composed of thousands of tasks and dependencies.

The talk will cover five major components:
1. What is the new CUDA Graph programming model?
2. Why do we need a C++ programming model for GPU task graph parallelism?
3. Designs, implementations, and deployments of the proposed cudaFlow programming model.
4. Real use cases of cudaFlow and its performance advantages in large GPU workloads.
5. Remarks and roadmap suggestions for the GPU programming community.

By the end of the presentation, the audience will know how to leverage the new GPU task graph parallelism to boost the performance of large-scale GPU applications, such as machine learning and scientific simulations.

Speakers
avatar for Tsung-Wei Huang

Tsung-Wei Huang

Assistant Professor, University of Utah
As a university faculty member, a central theme of my research is to make parallel computing easier to handle. I am passionate about using modern C++ technology to solve parallel and heterogeneous computing problems. One such effort is my Taskflow project (https://taskflow.github.io... Read More →
avatar for Dian-Lun Lin

Dian-Lun Lin

PhD student, University of Utah


Wednesday October 27, 2021 9:00am - 10:00am MDT
_3

9:00am MDT

++namedtuple - Python-style Named Tuples in C++20
In this workshop, we will take a look into how Python-style named tuples can be implemented in C++20.
The goal will be to test and implement the following snippet from scratch with modern C++ features.

01 const auto tuple = namedtuple{"price"_t = 42, "size"_t = 1'000};
02 static_assert(42 == tuple["price"_t]);
03 static_assert(1'000 == tuple["size"_t]);
04 static_assert(not [](auto tuple) { return requires { tuple["quantity"_t];}(tuple))

At the end of this session, the audience will have a better understanding of C++20 features such as:
- Concepts
- User-Defined Literals
- New additions to lambdas
- std::fixed_string

Additionally, attendees will get familiar with an expressive way of writing modern C++.

Let's get ready to named all tuples at CppCon 2021!

[1] https://docs.python.org/3/library/collections.html

Speakers
avatar for Kris Jusiak

Kris Jusiak

Software Architect, Quantlab Financial
Kris is a Software Architect passionate about programming and who has worked in different industries over the years including telecommunications, games and most recently finance for Quantlab Financial, LLC. He has an interest in modern C++ development with a focus on performance and... Read More →


Wednesday October 27, 2021 9:00am - 10:00am MDT
_2
  • Type Design, Hybrid

9:35am MDT

A Crash Course in Calendars, Dates, Time, and Time Zones
Before C++11, the C++ Standard Library did not have much support for working with time. C++11 changed all that and introduced the chrono library as part of the Standard Library. With its introduction, C++ gained a standard way to work with durations, clocks, and time points. It allows you to perform arithmetic operations with durations and time points, to convert between different units of time, and more. The library also comes with a number of clocks, including a high-resolution clock which makes it easy to quickly time how long a piece of code executes, e.g. for benchmarking, all without needing any additional libraries.
C++20 has extended the chrono library and added support for calendars, dates, and time zones. It allows you to represent specific days of a year, even something like the 3rd Monday of July or the last day of February, and to perform arithmetic operations with dates. Time can now be expressed in specific time zones, and, of course, converting time between different time zones is supported as well.

Speakers
avatar for Marc Gregoire

Marc Gregoire

Software Architect, Nikon Metrology
Marc Gregoire is a software architect from Belgium. He worked 6 years as a consultant for Siemens and Nokia Siemens Networks on critical 2G and 3G software running on Solaris for telecom operators. This required working in international teams stretching from South America and the... Read More →


Wednesday October 27, 2021 9:35am - 10:05am MDT
`Online _1

10:30am MDT

From Problem to Coroutine: Reducing I/O Latency
Coroutines are now officially part of the C++20 standard and one of their advertised uses is reducing I/O latency. Almost all of the literature on coroutines that I found illustrated either synchronous generators or described the nitty gritty details of coroutines using very simple usages. The best talk I found was Gor Nishanov's excellent talk from CppCon 2018, "Nanocoroutines to the Rescue!" (go watch it!) which solves a different problem than mine, but mostly illustrates the power of coroutines.

In this talk I want to approach coroutines from another direction. I will start with the problem, which almost all engineers face in some form, that of reducing I/O latency while searching and gathering data from a sequential file. Instead of going into the details of how the coroutines work, I will start with the naive synchronous solution and build up coroutines step by step to try and reduce latency, illustrating the pieces as they are added.

Finally I will compare this solution to an old-fashioned solution using threads and we'll see how the coroutines performance measures up and whether all the additional boilerplate needed is worth the additional trouble. I hope discussing the value of coroutines and future proposals for RAII and executors will spark a good discussion with the audience.

Speakers
avatar for Cheinan Marks

Cheinan Marks

Senior Developer
Cheinan Marks is a senior software developer, living in Berlin, where he starting a non-profit to research bioinformatics and bio-computation, specializing in genetics. He got his start in the TUTOR language on the PLATO system at the University of Illinois. Having gotten his doctorate... Read More →


Wednesday October 27, 2021 10:30am - 11:30am MDT
`Online _1

10:30am MDT

Back to Basics: Object-Oriented Programming
C++ is an object-oriented programming (OOP) language but also supports generic and functional features. OOP is a potent tool when used wisely. Let me present you the good parts.
You can design intuitive classes, which encapsulate its internals and allow restricted access. Further, inheritance applied appropriately enables you to build libraries or frameworks that are easy to use and difficult to misuse. The hidden source is the separation of interface and implementation. You can apply "Lesson Learned" from the best and implement design patterns using OOP techniques.

Learn in my lecture the appropriate use of the keywords virtual, override, and final. Learn when you should build a class hierarchy to separate the interface from the implementation. Besides interface inheritance, you can also use implementation inheritance. Learn to distinguish between those.
During this lecture, I also present a few design patterns as examples of good object-oriented design.

Speakers
avatar for Rainer Grimm

Rainer Grimm

C++ trainer, Modernes C++
Rainer works as a software architect, team lead, and instructor since 1999. In 2002, he created a further education round at his company. He gives seminars since 2002. Rainer's first seminars were about proprietary management software, but seminars for Python and C++ followed immediately... Read More →


Wednesday October 27, 2021 10:30am - 11:30am MDT
`Online _2

10:30am MDT

Design Idioms from an Alternate Universe
This session is part of the Software Design Track.

It is common to see different design idioms and patterns in different programming paradigms as they represent /the way/ something should be implemented in a given paradigm, and each paradigm is special enough for its way to be completely different to the way taken by the other ones.

While C++ is an one of a kind multiparadigm langugage, people tend to use object-oriented patterns with it most of the time. Generic and functional programming are also where C++ shines, so why avoid learning and using idioms from those two paradigms? People often think that they need to stick to a single paradigm not realizing that the true power lies in skillfully combining all of them.

This talk will present several software design idioms that people usually connect with generic and functional programming disciplines, but which are highly applicable to the usual code most of the contemporary C++ developers write every day.

Speakers
avatar for Ivan Čukić

Ivan Čukić

Senior Software Engineer, KDAB
dr Ivan Čukić is the author of “Functional Programming in C++” published by Manning.He is a senior software engineer at KDAB. Also, one of the core developers in KDE for more than a decade, the largest free/libre open source C++ project.


Wednesday October 27, 2021 10:30am - 11:30am MDT
`Online _4
  • Software Design, Online

10:30am MDT

The Basics of Profiling
What to do when a program is slower than what we'd like? Where to start when trying to improve throughput, latency or responsiveness?

In this beginner friendly session we will introduce the two big families of profilers (sampling and instrumentation) and two tools my team uses almost every day when working on games: Optick and vTune.
Through a few concrete cases based on past experience we will study how to troubleshoot a performance problem using a profiler and how the code was improved.

We will illustrate a few classic cases such as inefficient algorithms, unsuitable data structures, I/O waits and bad concurrency.

If time allows we will also see how profilers such as vTune can be used to delve into micro-optimizations by looking at low level metrics such as cache misses and branch prediction.

Speakers
avatar for Mathieu Ropert

Mathieu Ropert

Tech Lead, Paradox Development Studio
French C++ expert working on (somewhat) historical video games. Decided to upgrade his compiler once and has been blogging about build systems ever since. Past speaker at CppCon, Meeting C++ and ACCU. Used to run the Paris C++ User Group. Currently lives in Sweden.


Wednesday October 27, 2021 10:30am - 11:30am MDT
`Online _3
  • Tooling/Debugging, Online

10:30am MDT

Value in a Procedural World
This talk is the Software Design Track Keynote.

What is a value? The most common conception is that values are inhabitants of a platonic mathematical world, too far away to be examined or subjected to experiment. As a basis for understanding computer programs, this conception is awkwardly non-local and disturbingly mystical.

In this lecture, I will present a functionalist conception of value, situated locally within the realm of procedural programming. I will show how values in this conception relate directly to program execution, and examine how events within program execution are related through the stability, substitutability, and repeatability of values.

Speakers
avatar for Lisa Lippincott

Lisa Lippincott

Software Architect, Tanium
Lisa Lippincott designed the software architectures of Tanium and BigFix, two systems for managing large fleets of computers. She's also a language nerd, and has contributed to arcane parts of the C++ standard. In her spare time, she studies mathematical logic, and wants to make computer-checked... Read More →


Wednesday October 27, 2021 10:30am - 12:00pm MDT
Aurora C/D
  • Software Design, Hybrid

12:30pm MDT

Back to Basics: Lambdas
Lambdas, introduced with C++11, are used everywhere in modern C++ programming. While their use looks pretty straightforward, you should know about some details that help you to benefit from their full power.
This session teaches lambdas in detail. Based on the basic principles, it motivates and explains why lambdas are more powerful than functions and how to use them to benefit from that.

Speakers
avatar for Nicolai Josuttis

Nicolai Josuttis

IT Communication
Nicolai Josuttis (http://www.josuttis.com) is well known in the programming community because he not only speaks and writes with authority (being the (co-)author of the world-wide best sellers The C++ Standard Library (www.cppstdlib.com), C++ Templates (www.tmplbook.com), C++1... Read More →


Wednesday October 27, 2021 12:30pm - 1:30pm MDT
`Online _1
  • Algorithms/Functional, Online

12:30pm MDT

Deploying the Networking TS
Delayed broadcast

The Networking TS provides a framework for writing asynchronous and network-aware applications. A framework which also promotes reusable and testable code. These platonic concerns are only part of software engineering however, and only a small part of the motivation for a framework. When all is said and done one must not merely prepare to reuse code but actually use it, not just test it but deploy it.

How is an actual, deployed application using the Networking TS structured? How do the principles of reusable, testable Networking TS code compose as one writes an actual application rather than a test suite? How can one integrate components which exist outside the Networking TS’s ecosystem into an application based on the Networking TS?

This talk will take the listener on a guided tour of a deployed application written using the Networking TS, the techniques employed to maintain the promises of the Networking TS while fulfilling the needs of an actual application, and how this lays the foundation not only to maintain the current application but also to author additional applications going forward as the deployment and maintenance cycle continues.

Speakers
avatar for Robert Leahy

Robert Leahy

Lead Software Engineer, MayStreet Inc.
Robert is a graduate of the University of Victoria where he specialized in graphics, gaming, and digital geometry processing. After 4.5 years in full stack web development he switched to financial infrastructure software development in early 2017. He’s since become involved in the... Read More →


Wednesday October 27, 2021 12:30pm - 1:30pm MDT
`Online _3
  • Async/Concurrency/Parallelism, Online

12:30pm MDT

PGAS in C++: A Portable Abstraction for Distributed Data Structures
Delayed broadcast

Writing programs that run on clusters of computers is notoriously tedious and error-prone, particularly for applications like genomics, sparse linear algebra, and graph analytics, which often require fine-grained, irregular communication.

In this talk, I'll argue that the Partitioned Global Address Space (PGAS) programming model, which allows remote access to a portion of the memory space on remote processes in a distributed program, is an effective model for implementing portable, high-level C++ data structures that automatically distribute data, while taking advantage of the high-performance RDMA network primitives available in most supercomputer and data center environments.

I'll discuss how our distributed data structures library BCL builds upon the concept of a global pointer to build a collection of high-performance, high-level data structures, including hash tables, queues, and dense and sparse matrices, that can be used across a variety of communication libraries, including MPI, OpenSHMEM, and GASNet-EX. I'll touch on the some of the important issues that arise in implementing distributed data structures, such as synchronization, remote reference objects, and support for GPUs.

Speakers
avatar for Benjamin Brock

Benjamin Brock

PhD Candidate, UC Berkeley
Ben Brock is a PhD student at UC Berkeley, where he works on building libraries, tools, and algorithms for high-performance computing. His main work focuses on building a cross-platform library of data structures for distributed applications, with a focus on sparse linear algebra... Read More →


Wednesday October 27, 2021 12:30pm - 1:30pm MDT
`Online _5

12:30pm MDT

Using C Libraries in your Modern C++ Embedded Project: A journey integrating an EtherCAT stack, a C++17 compiler, and Modern C++ idioms
Delayed broadcast

Projects have goals, timelines, and deliverables which should shape our solution space and approach. A recent project incorporating EtherCAT had other technical challenges and a fixed timeline which resulted in a basic integration approach.

After the project was complete I continued developing Ciere's capabilities to handle EtherCAT based communication. In all, three different levels of integration were developed.

This talk will briefly introduce the real-time suitable communication technology called EtherCAT and then review the progression of integration approaches. We will explore the techniques and language features employed and extract some rules of thumb about layered architectures. We will look at the technical, timeline, and risk trade-offs for each approach as we make observations about the value provided.

While this talk focuses on integrating C-libraries and facilities within a Modern C++ embedded target, the lessons learned and insights are applicable to Modern C++ projects of all sized targets. Attendees will walk away with a set of patterns for dealing with C library integration, some guidelines about value trade-offs, and one person's experience with implementations.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →


Wednesday October 27, 2021 12:30pm - 1:30pm MDT
`Online _4

12:30pm MDT

In-memory and Persistent Representations of C++
Delayed broadcast

C++ Modules are a tooling opportunity. For example, a common implementation strategy for compilers is to save on disk the abstract semantics graph (ASG) obtained from elaborating a module interface (exported), to be reused later when that module is consumed (imported). That ASG, an intermediate representation, saves the compiler from repeated work in common scenarios, therefore helps achieve substantial reduction in compilation time. In essence, ISO C++ compilers are practically compelled to acknowledge representations of C++ program fragments other than character streams stored in source files. It is all too tempting to view these ASGs as mere build artifact curiosities. If N compilers, on a given platform, decide to use N different on-disk ASG representation formats then we face a severe problem of developer tools fragmentation. I present, in this talk, how the C++ community can avoid that problem: the desiggn and implementation of formal, compiler-neutral in-memory and persistent representations of C++ programs. These alternative representations allow tools to process C++ programs without needing to master or to replicate the dark art of C++ compiler construction. These representations are available either as open specification, or as C++ libraries. The application opportunities range from automated generation of bindings ("foreign function/data interface") to Just-In-Time compilation of interpreted C++ scripts, and beyond.

Speakers
avatar for Gabriel Dos Reis

Gabriel Dos Reis

Principal Software Engineer, Microsoft
Gabriel Dos Reis is a Principal Software Engineer at Microsoft, where he works in the area of large scale software construction, tools, and techniques. He is also a researcher, and a longtime member of the C++ community, author and co-author of numerous extensions to support large... Read More →


Wednesday October 27, 2021 12:30pm - 1:30pm MDT
`Online _2
  • Type Design, Online

2:00pm MDT

Back to Basics: Classic STL
The C++ world experienced a revolution when the original STL was released by HP in the early 1990s. Based on the pioneering work of Alex Stepanov, Meng Lee, and others, the C++ community now had a set of generic container types that did not depend on algorithms, and vice versa. Through its use of well-defined interface and complexity requirements, the design of the STL allows programmers to use library containers with their own algorithms, as well as to use library algorithms with their own containers.

This talk will take a very brief look at the origins of the STL and its importance to C++. We'll then describe the three main pillars of the STL -- containers, iterators, and algorithms -- as well function objects and adaptors. We'll see how they cooperate to provide a set of generic, orthogonal, composable, and extensible programming tools. We'll summarize the containers and their corresponding interface and complexity requirements. We'll look at iterators and how they connect containers with algorithms. And finally, we'll give an overview of the algorithms and how they interact with containers via iterators.

If you're new to C++ or less experienced with the language, and wonder why the STL is such a big deal, this talk is for you. If you're looking for a better understanding of the design and principles underlying the STL, this talk is for you. Attendees will leave this session with a basic understanding of the standard containers, iterators, and algorithms, and most importantly, the relationships between them.

Speakers
avatar for Bob Steagall

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing


Wednesday October 27, 2021 2:00pm - 3:00pm MDT
_2

2:00pm MDT

Generic Graph Libraries in C++20
The C++ Standard Library is a valuable collection of generic algorithms and data structures that improves the usability and reliability of C++ software. Graph algorithms and data structures are notably absent from the standard library, and previous attempts to fill this gap have not gained widespread adoption.

This session presents an approach for expressing graph algorithms in a modern, composable, and extensible, aka generic, fashion. Concepts provide a means for a systematic organization of the type requirements for graph algorithms to operate correctly and efficiently. Remarkably, these type requirements can be expressed not in graph-specific terms, but rather in terms of existing sets of requirements already in place for basic containers in C++, i.e., ranges. Using this conceptual framework, we develop several generic algorithms and concrete data structures as well as the emerging proposal for a standard graph library.

Speakers
avatar for Andrew Lumsdaine

Andrew Lumsdaine

Principal Software Engineer / Affiliate Professor, TileDB / University of Washington
Andrew Lumsdaine is an internationally recognized expert in the area of high-performance computing who has made important contributions in many of the constitutive areas of HPC, including systems, programming languages, software libraries, and performance modeling. His work in HPC... Read More →
avatar for Phil Ratzloff

Phil Ratzloff

Distinguished Software Developer, SAS Institute
Phil Ratzloff is a Distinguished Software Developer and C++ advocate at SAS Institute. He has used C++ for 26 years on applications using graphs for business cost analysis and fraud detection.


Wednesday October 27, 2021 2:00pm - 3:00pm MDT
`Online _1

2:00pm MDT

Building a Lock-free Multi-producer, Multi-consumer Queue for Tcmalloc
Lock free multi-producer, multi-consumer queues are an area of active research in concurrent data structures, but their performance varies heavily with the specific constraints of the surrounding system. This talk tells the story of building such a queue to replace a component in tcmalloc, Google's malloc implementation. In the process, we will cover

- designing the initial data structure based on LMAX's disruptor pattern
- refactoring the existing code to increase testability and experimentation without introducing overhead
- adding micro benchmarks for the new code
- revising micro benchmarks in the face of conflicting system level metrics
- optimizing the data structure based on those conclusions
- debugging difficult concurrency bugs
- measuring the final result with system level metrics

Speakers
avatar for Matt Kulukundis

Matt Kulukundis

Staff Software Engineer, Google
Matt is a senior software engineer on the C++ libraries team at Google.  Prior to Google he has worked on compilers, machine learning, and underwater robotics.  In his free time, he scuba dives in warm places.


Wednesday October 27, 2021 2:00pm - 3:00pm MDT
_1

2:00pm MDT

Modern CMake Modules
At Bloomberg, we have thousands of independently maintained first- and third-party C++ projects built with CMake. One of the keys to achieving this scale, while also keeping engineers productive, has been leveraging one of the most underrated and underutilized features of CMake — its extensibility via its module system. Bloomberg utilizes dozens of single-purpose CMake modules to allow its tens of thousands of CMakeLists.txt files to stay declarative, flexible, future-proof, and simple -- all while using modern CMake principles!

This talk will cover what CMake modules are, how to write one using the latest CMake features, and how to package one for others to use. Importantly, this talk will also cover when *not* to write a CMake module.

If you find yourself wincing at all the repetitive boilerplate in the CMakeLists.txt across your projects, this is the talk for you!

Speakers
avatar for Bret Brown

Bret Brown

Team Lead, Bloomberg
Software engineer currently focusing on improving C and C++ ergonomics, correctness, and productivity for Bloomberg's Developer Experience department.Bret works to make authoring and maintaining C++ codebases simpler and more intuitive by treating projects more like cattle and less... Read More →


Wednesday October 27, 2021 2:00pm - 3:00pm MDT
_4
  • Modules/Libraries, Hybrid

2:00pm MDT

The Factory Pattern
This session is part of the Software Design Track.

C++ programs that are dynamic in nature have to create objects at some time during run-time. New objects can be created by explicitly calling ‘new’ and then the data type of that object. However, this requires that a programmer knows at ‘compile-time’ what object should be created. What we would like, is to have a layer of abstraction, or someway to create objects at run-time to reflect the dynamic nature of some C++ programs. Luckily, there is a common pattern that can help solve this problem--the factory design pattern.

In this talk, we are going to discuss a creational design pattern known as a factory. The pattern can be as simple as a function, or take on other forms as a distributed factory, or an abstract factory. We’ll show some basic examples of a factory in modern C++ as well as real world use cases of where factories occur for further study. Finally, we’ll discuss the tradeoffs of the factory pattern, and discuss which scenarios you may not actually want to use a factory. Attendees will leave this talk with the knowledge to go forward and implement the factory pattern, as well as how to spot the factory pattern in projects they may already be working on!

Speakers
avatar for Mike Shah

Mike Shah

Assistant Teaching Professor/3D Senior Graphic Eng, Northeastern University
Michael D. Shah completed his Ph.D. at Tufts University in the Redline Research Group in 2017. His Ph.D. thesis advisor was Samuel Z. Guyer. Michael finished his Masters degree in Computer Science in 2013 at Tufts University and Bachelors in Computers Science Engineering at The Ohio... Read More →


Wednesday October 27, 2021 2:00pm - 3:00pm MDT
_3
  • Software Design, Hybrid

3:15pm MDT

C++20 ❤ SQL
SQL is *the* language for database manipulation. However, interfacing it to C++ in a type safe manner can be awkward, requiring either preprocessors, boilerplate, or loss of type safety.

In the past, to achieve type safety, people have written domain specific languages. However, a DSL comes with its own issues, including how to specify the DSL data model, how to support the richness of SQL semantics, and how to translate SQL to the DSL.

C++20 provides us the features to be able to use SQL queries almost directly in C++ in a type safe way. With some minimal, specialized SQL comments, we can generate type safe parameter and result row bindings in C++ at compile time from an SQL query string.

No macros, no preprocessors, no boilerplate!

Just awesome standard C++20.

Join us as we explore how we can unleash the full power of two amazing languages: C++ and SQL!

Speakers
avatar for John Bandela

John Bandela

Software Engineer, Google
I first started programming in C++ at age 14 in 1994 when I cajoled my parents into buying me Visual C++ 1.0 for my birthday. It took a while, but as I learned the language, I decided I really liked C++. I attended the University of Florida and obtained my undergraduate degree in... Read More →


Wednesday October 27, 2021 3:15pm - 4:15pm MDT
_3
  • C++20/Future of C++, Hybrid

3:15pm MDT

Back to Basics: Casting
“In all cases, it would be better if the cast ... could be eliminated” --Bjarne Stroustrup. As this quote attests, casting has been controversial from the beginnings of C++ and yet, when used judiciously, continues to be a very powerful tool for the language. In this back to basics talk, we will look at the history of casing in C++, why we have the casts that we do have, how casting interacts with run time type information (RTTI), and what the compiler actually does when we add casts to our code. When we’re done, you should be able to know when to use (or not use) a cast and what effect it will have on your project.

Speakers
avatar for Brian Ruth

Brian Ruth

Sr. Software Engineer, Garmin
Brian has been programming in C++ for 20+ years; working for both small and large companies on a wide variety of projects and technologies. For over a decade he worked with neuroscience researchers and created high speed acquisition, analysis and visualization software. He is currently... Read More →


Wednesday October 27, 2021 3:15pm - 4:15pm MDT
_2
  • Code Design, Hybrid

3:15pm MDT

What's New in Visual Studio: 64-bit IDE, C++20, WSL 2, and More
Visual Studio 2022 is almost here, bringing new and deeper experiences for C++ developers targeting any platform. Since last year we’ve been working hard on implementing C++20 and making the IDE 64-bit, alongside a host of improvements to make your C++ development safer and more productive.

In this talk we’ll demonstrate many of these features, live: showing you how to use our new AddressSanitizer features to find bugs, target WSL 2 in seconds, express your build instructions with CMakePresets.json, consume specific versions of your dependencies with vcpkg, build and test your code with GitHub Actions, and more.

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

Speakers
avatar for Sy Brand

Sy Brand

C++ Developer Advocate, Microsoft
Sy Brand is Microsoft’s C++ Developer Advocate. Their background is in compilers and debuggers for embedded accelerators, but they’re also interested in generic library design, metaprogramming, functional-style C++, undefined behaviour, and making our communities more welcoming... Read More →
avatar for Marian Luparu

Marian Luparu

Group Product Manager, C++ Team, Microsoft
Ask me about @Code @VisualStudio and #Vcpkg


Wednesday October 27, 2021 3:15pm - 4:15pm MDT
`Online _1
  • Tooling/Debugging, Online

3:15pm MDT

Design and Implementation of Highly Scalable Quantifiable Data Structures in C++
Architectural imperatives due to the slowing of Moore's Law, the broad acceptance of relaxed semantics and the O(n!) worst case verification complexity of generating sequential histories motivate a new approach to concurrent correctness. Quantifiability is proposed as a novel correctness condition that models a system in vector space to launch a new mathematical analysis of concurrency. Analysis is facilitated with linear algebra, better supported and of much more efficient time complexity than traditional combinatorial methods.

In this talk, we present the design and implementation of a lock-free quantifiable stack (QStack) and a lock-free quantifiable queue (QQueue) in the C++ programming language. Our design achieves lock-freedom using compare_exchange_strong from the C++17 Atomic Operations Library. We depict several code snippets that illustrate how quantifiable data structures are highly scalable through use of relaxed semantics, an explicit implementation trade-off permitted by quantifiability. We explain how to reason about the correctness of quantifiable data structures and present a technique and a dynamic analysis tool developed in C++ for efficiently verifying a concurrent history as quantifiably correct, referred to as Vector Space Verification (VSV). We illustrate why it is impractical to use alternative verification techniques that compare concurrent histories to sequential histories for determining correctness for real programs.

We showcase the performance of quantifiable data structures by presenting a live demonstration that runs the QStack and QQueue and plots the results in real time. The QStack is compared with the lock-free Elimination Backoff Stack and the lock-free Treiber stack. The QQueue is compared with the lock-free LCRQ, and the wait-free Fetch-And-Add queue. The live performance demonstration illustrates how the QStack and QQueue achieve substantially higher scalability than the state-of-the-art linearizable counterparts. We also present a live demonstration of our VSV tool to dynamically check a concurrent history for the QStack and QQueue as quantifiably correct in less than O(n^2) time.

Speakers
avatar for Victor Cook

Victor Cook

Researcher, University of Central Florida
Victor Cook is a Ph.D. candidate in Computer Science at the University of Central Florida. He received his Bachelor of Science in Geophysics from the Massachusetts Institute of Technology in 1987, and Master of Science in Civil Engineering from the University of Florida in 1989. Mr... Read More →
avatar for Zachary Painter

Zachary Painter

Zachary Painter is a Ph.D. student at the University of Central Florida. His area of research includes concurrent programming, transactional data structures, and blockchain concurrency. His prior work includes a lock-free transactional adjacency list as well as a parallel Hash-Mark-Set... Read More →
avatar for Christina Peterson

Christina Peterson

Postdoctoral Associate, University of Central Florida
Dr. Christina Peterson is a Postdoctoral Associate at the University of Central Florida. Dr. Peterson completed her dissertation work under the supervision of Dr. Damian Dechev with a focus on correctness and progress guarantees of multiprocessor algorithms and data structures. Her... Read More →


Wednesday October 27, 2021 3:15pm - 4:15pm MDT
_1

4:45pm MDT

Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2
The hazard pointer deferred reclamation technique supports low-latency access to dynamic objects by deferring the reclamation of objects that may be removed while being accessed concurrently until reclamation is safe. Many uses of hazard pointers require support for synchronous reclamation, that is, guarantees for the timing of reclamation of some objects, primarily due to the dependence of the deleters of such objects on resources that may become subsequently unavailable.

The upcoming WG21 Concurrency Technical Specification (Concurrency TS2) includes support for hazard pointer synchronous reclamation. This talk describes such support and goes beyond the TS and describes a faster scalable alternative interface for synchronous reclamation and novel algorithms for implementing it that are in heavy use in the Folly open-source library.

Fast and scalable synchronous reclamation for deferred reclamation has been a long-standing open problem. This talk presents a new interface and algorithms that solve the problem. Objects protectable by hazard pointers are organized into cohorts. The completion of the destruction of a cohort object guarantees the completion of the destructors for all associated protectable objects, thus providing synchronous reclamation by controlling cohort destruction. A significant algorithmic challenge is the interaction between synchronous and asynchronous reclamation. Asynchronous reclamation serves to bound the number of reclaimable objects that are not yet reclaimed. The talk outlines how the new algorithms manage to support both types of reclamation safely while allowing synchronous reclamation to be fast and scalable.

The talk concludes with a proposed roadmap for hazard pointer synchronous reclamation standardization beyond Concurrency TS2.

Speakers
avatar for Maged Michael

Maged Michael

Engineer, Facebook
Maged Michael is a software engineer at Facebook. He is the inventor of hazard pointers, lock-free malloc and several algorithms for concurrent data structures. He received a Ph.D. in computer science from the University of Rochester. He is an ACM Distinguished Scientist. He is an... Read More →


Wednesday October 27, 2021 4:45pm - 5:45pm MDT
_1

4:45pm MDT

"Deducing this" Patterns
How would our code change if a member function could deduce the type and value category of the object ("this") it worked on?

Potentially a lot, and this talk will highlight some of those changes. Because with C++23, member functions will be able to do just that using a feature described in P0847, "Deducing this". Many patterns in C++ today could change, and new patterns will arise. This talk will explore those patterns, explain how "deducing this" works, and show how it solves the problems that originally motivated the paper.

Some sample effects on our code: CRTP is simplified; decorators become much easier and terser; recursive lambda expressions become straightforward. There are also implications for safely and efficiently moving values through computations.

Speakers
avatar for Ben Deane

Ben Deane

Ben was a game programmer for over 20 years, working in C++ since the late 90s, for companies like EA and Blizzard. In 2018 he left the games industry to join Quantlab, an automated trading firm, where he writes modern, well-performing C++. He likes to play with algorithms, and to... Read More →


Wednesday October 27, 2021 4:45pm - 5:45pm MDT
_2

4:45pm MDT

3D Graphics for Dummies
Three-dimensional graphics are much simpler than you would think. I will present the rudimentary techniques for the designs of a simple C++ Matrix library and operator methodologies, through an introduction to 3D Graphics: Points, Vectors, Coordinate Spaces, Matrix Math, Depth Buffer and Rasterization.

We will explore the blood and guts of a C++ Matrix library and 3D graphics. Rather than using off-the-shelf libraries like Unity and OpenGL, we will examine a simple library I wrote to teach myself about the subject. Includes demo of the graphics library/app.

Speakers
avatar for Chris Ryan

Chris Ryan

Sr. SW/FW Eng C++ / Speaker Liaison, Day: Amazon   Night: C++Now / CppCon
I make the complex simple by reducing complexity. Chris Ryan was classically trained in both software and hardware engineering. He is well experienced in Modern C++ & Classic ‘C’, on extremely large/complex problem spaces and on Embedded/Firmware devices (large & small). Chris... Read More →


Wednesday October 27, 2021 4:45pm - 5:45pm MDT
_4
  • GPU/Graphics, Onsite

4:45pm MDT

A Case-study in Rewriting a Legacy GUI Library for Real-time Audio Software in Modern C++
This session is part of the Software Design Track.

A case-study in the design and development of iZotope's GUI framework,
for real-time audio software, using C++17 to eliminate common sources of
bugs and increase developer productivity. To illustrate this process,
we will study GlassProperties, a new open-source library for property
serialization and accessor method synthesis. While designed to support
building GUIs for real-time audio software, GlassProperties is a general
purpose framework not tied to any one GUI library and could easily be
adapted into your GUI or any part in your tech stack.

We will cover the library design process, starting with
analysis of legacy code and bugs to develop user problem statements.
These user problems will be our guide for wrapping a legacy system with
a new type-safe API using C++17 compile-time meta-programming so that
run-time bugs become compile-time errors. Once we arrive at a C++17
design, we will close with a brief look to the future and how the
library would look with C++20 Concepts.

In addition to learning the software design techniques to succeed in
this rewrite, some lessons learned will be shared so you will be armed
with both the C++ skills and business strategy to take on a project like
this at your organization.

Speakers
avatar for Roth Michaels

Roth Michaels

Principal Software Engineer, iZotope, Inc.


Wednesday October 27, 2021 4:45pm - 5:45pm MDT
_3

6:00pm MDT

MLOC Group Community Party
Join Million Lines of Code Group for drinks, appetizers, swag, prizes, music and socializing. This event is free for all CPP Con attendees, but you must be registered, so save your spot today.

RSVP by registering here.

Wednesday October 27, 2021 6:00pm - 8:00pm MDT
Aurora B

8:30pm MDT

C++ Pub Quiz
What is C++ Pub Quiz, you ask? It's trivia night CppCon style — five rounds, ten questions per round. Write down your team’s answers on a sheet of paper and turn it in at the end of the round.

Remo's "table" system seems ideal for this, so here's the deal: We'll meet in this event's Remo room at the scheduled time. Join a table near the front of the room with whoever you want to be on your team; turn on your mic in Remo. In the Remo general chat, I'll post a Google Meet URL and a Google Form URL. Open the Google Meet in a second tab; turn off your mic in Google Meet.

Each team should pick a team name, and designate a "team captain" who will use the Google Form to submit their answer sheet at the end of each round.

I'll read each round's questions into the Google Meet. (You will be listening in the Google Meet; or, you might designate a "team communications officer" who will be in the Meet with their mic off and their speakers on, relaying the audio through to everyone at their Remo table. Either way should work.) During the round, feel free to converse with your teammates around the table. At the end of the round, the "team captain" will submit your answer sheet via the Google Form, and we'll have a short break while I tally the scores.

High score after five rounds wins both the game and the bragging rights!

Moderators
avatar for Arthur O'Dwyer

Arthur O'Dwyer

C++ Trainer
Arthur O'Dwyer is the author of "Mastering the C++17 STL" (Packt 2017) and of professional training courses such as "Intro to C++," "Classic STL: Algorithms, Containers, Iterators," and "The STL From Scratch." (Ask me about training your new hires!) Arthur is occasionally active on... Read More →

Wednesday October 27, 2021 8:30pm - 10:00pm MDT
Summit 1
 
Thursday, October 28
 

7:45am MDT

Multi Threading Model in Paradox Games: Past, Present and Future
Paradox grand strategy games are all about simulating history through various lenses (politics, economy, warfare, diplomacy, demographics...) in real time. Over the last 20 years, our games have become more complex and more demanding on CPU computations.
In this talk we will see how the threading model of the game simulation evolved over time to try and deliver the necessary throughput and latency required to keep the games fluid with more and more complex systems.
We will focus on 3 models, the "old" which is shared by some long running production games such as Europa Universalis IV, Hearts of Iron IV and Stellaris, the "current" model brought by Crusader Kings 3 and finally discuss some thoughts and ideas of what future games may experiment with.

Speakers
avatar for Mathieu Ropert

Mathieu Ropert

Tech Lead, Paradox Development Studio
French C++ expert working on (somewhat) historical video games. Decided to upgrade his compiler once and has been blogging about build systems ever since. Past speaker at CppCon, Meeting C++ and ACCU. Used to run the Paris C++ User Group. Currently lives in Sweden.


Thursday October 28, 2021 7:45am - 8:45am MDT
`Online _2

7:45am MDT

Software Engineering Is About Tradeoffs
This talk presents a view of a Software Architect on designing interfaces. Often there is no such thing as "the best" solution for the problem. In many cases, we have to deal with compromises and accept the downsides of a specific approach. We often have to choose between exception safety guarantees, performance, dynamic allocations, and standardization or implementation effort.

During the talk, I will present some of the major tradeoffs and disagreements regarding the C++ design. I will also describe a few issues I encountered during the design of mp-units (the modern C++ physical units library) and ask the audience to make a choice between several alternative solutions to the problem.

Speakers
avatar for Mateusz Pusz

Mateusz Pusz

Principal Software Engineer | Trainer, EPAM Systems | Train IT
A software architect, principal engineer, and security champion with more than 15 years of experience in designing, writing, and maintaining C++ code for fun and living. A trainer with 10 years of C++ teaching experience, consultant, conference speaker, and evangelist. His main areas... Read More →


Thursday October 28, 2021 7:45am - 8:45am MDT
`Online _3
  • Code Design, Online

7:45am MDT

Breaking Dependencies: Type Erasure - A Design Analysis
This session is part of the Software Design Track.

“If I could go back in time and had the power to change C++, rather than adding virtual function, I would add language support for type erasure …” (Eric Niebler, June 19, 2020, Twitter).

For many developers type erasure is superior to inheritance. And indeed, it has proven itself to be a powerful design pattern, helping to significantly reduce coupling between software entities.

This talk will give a short introduction to type erasure, with a particular focus on the design aspect of the technique. After attending this session, attendees will understand why type erasure provides such a strong decoupling and why this makes it superior to inheritance in terms of dependency management.

Speakers
avatar for Klaus Iglberger

Klaus Iglberger

C++ Trainer/Consultant, Freelancer
Klaus Iglberger is a freelancing C++ trainer and consultant. He has finished his PhD in computer science in 2010 and since then is focused on large-scale C++ software design. He shares his experience in popular advanced C++ courses around the world (mainly in Germany, but also the... Read More →


Thursday October 28, 2021 7:45am - 8:45am MDT
`Online _1
  • Software Design, Online

7:45am MDT

Cool New Stuff in Gdb 9 and Gdb 10
GDB is bigger than you might think, and it's evolving fast. This is a depth-first walk through what's been added in versions 9 and 10. Depth-first meaning that no prior knowledge of these features is assumed, but even if you've used them before there should be plenty new for you. Few slides, lots of live demos. Some brand new things and some neat new additions to existing features. Topics include the new debuginfod facility; user-defined commands; enhancements to super-useful convenience variables such as $_siginfo, $_gdb_setting, $_gdb_setting_str; enhancements to TUI mode; how to add new TUI windows from GDB's Python scripting; advanced querying of types from GDB's Python scripting; and enhanced configuration of backtrace printing. You should learn at least two new tricks that will make improve you debugging effectiveness, and so make you a better programmer.

Speakers
avatar for Greg Law

Greg Law

CTO, Undo
Greg is co-founder and CTO at Undo. He is a programmer at heart, but likes to keep one foot in the software world and one in the business world. Greg finds it particularly rewarding to turn innovative software technology into real business development. Greg has over 20 years of experience... Read More →


Thursday October 28, 2021 7:45am - 8:45am MDT
`Online _4
  • Tooling/Debugging, Online

7:45am MDT

What Classes We Design and How
C++ class design has been error prone since the beginning until Scott Meyers told us about the Rule-of-Three. But even that is not enforced by the language. In addition, C++11 changed the set of compiler-provided special member functions and the intrinsic rules have become more complicated. However, instead of starting from the rules for special member functions, we will look at what role a class type plays and how that maps on what special member functions to define and how, if any. Examples for class roles are Value, Relationship, Manager (scoped, unique, general), Mix-in.

We will also look at the roles of member variable types that influence or imply the role of the class type.
The role of a class will also take out many mysteries of move operations and will lead to clear guidance when and how to implement move: for suppressing copying, for managing unique ownership (Unique Manager) or for optimizing object copies (General Manager).

We will rehearse the Rule of Zero, and learn more about the Rule of Five/Six, the Rule of DesDeMovA, and the Rule of Unique Three.

This all will enable you to much more consciously and safely design your class types and combine types of member variables. You will have then the ability to select from a few reasonable combinations from the plethora of possibilities of special member function combinations: {public:,protected:,private:} x {destructor, default constructor, copy constructor, copy assignment, move constructor, assignment} x {noexcept(true),noexcept(false)} x { =default, =delete, {/*body*/}, not declared } (math as homework)

Speakers
avatar for Peter Sommerlad

Peter Sommerlad

founder, Better Software: Consulting, Training, Reviews
Peter Sommerlad was director of IFS Institute for Software at FHO/HSR Rapperswil, Switzerland. Peter is co-author of the books POSA Vol.1 and Security Patterns and contributed to "97 things every programmer should know". His goal is to make software simpler and safer by Decremental... Read More →


Thursday October 28, 2021 7:45am - 8:45am MDT
`Online _5

9:00am MDT

C++20: The Small Pearls
C++20 has way more to offer than the big four concepts, ranges, modules, and coroutines.
Here are a few of the shining pearls.

The spaceship operation automatically creates the six comparison operators. Thanks to consteval, constinit, and improved templates, programming at compile time becomes more powerful. std::span supports safe access to contiguous memory blocks. An enhanced time library and a new type date. Comfortable formatting of data thanks to std::format. Easily synchronize or coordinate threats with semaphores or latches and barriers. An improved thread that maintains itself and supports interruption. Thanks to the synchronized output streams, write operations in the concurrent environment do not end in a mess.

Speakers
avatar for Rainer Grimm

Rainer Grimm

I've worked as a software architect, team lead, and instructor since 1999. In 2002, I created company-intern meetings for further education. I have given training courses since 2002. My first tutorials were about proprietary management software, but I began teaching Python and C... Read More →


Thursday October 28, 2021 9:00am - 10:00am MDT
`Online _1
  • C++20/Future of C++, Online

9:00am MDT

Embracing (and also Destroying) Variant Types
Designing and implementing a variant type (such as `std::variant` itself) in C++, at first, seems a rather inane topic. It turns out, however, that a variant type's performance or lack thereof, can have an inordinately large impact on software that directly impacts the bottom-line performance of important applications, such as interpreters. database clients, and communication protocols.

In this talk we will delve into the gory details of designing and implementing variant types, with an emphasis on layout, construction, and destruction. Along the way we'll figure out how to optimize not only the run time of the produced program, but also the time and memory consumed during compilation. These aspects, although seldom discussed, are important for provisioning and deploying continuous integration systems.

Speakers
avatar for Andrei Alexandrescu

Andrei Alexandrescu

Software Development Consultant, Self Employed
Andrei Alexandrescu is a researcher, software engineer, and author. He wrote three best-selling books on programming (Modern C++ Design, C++ Coding Standards, and The D Programming Language) and numerous articles and papers on wide-ranging topics from programming to language design... Read More →


Thursday October 28, 2021 9:00am - 10:00am MDT
_4
  • Templates/Concepts, Hybrid

9:00am MDT

"unit"_test: Implementing a Macro-free Unit Testing Framework from Scratch in C++20
Testing in C++ is not easy, it often requires a lot of boilerplate code, macro usage, and/or understanding of complicated testing frameworks.
But it doesn't have to be like that. C++20 will enable us to reinvent the way we write tests!

In this case study, we will address the difficulty of testing with C++ by implementing a new, fully functional, macro-free testing framework 1 from scratch with modern C++20 features to make the following snippet compile and run:

01 import ut;
02
03 int main() {
04 "fib"_test = [] { // Running "fib"...
05 12_i == fib(7); // fib.cpp:5:FAILED [ 12 == 13 ]
06 }; // tests: 1 | 1 failed
07 } // asserts: 1 | 0 passed | 1 failed

At the end of this session, the audience will have a better understanding of C++20 features such as:
- Modules
- Concepts
- Source Location
- New additions to lambdas
- User-Defined Literals

Additionally, attendees will get familiar with an expressive way of testing with modern C++ based on UT - Unit Testing Framework [2].

Let's get ready to follow the Beyonce rule - 'If you liked it then you "should put a"_test on it' and test all the things at CppCon 2021!

[1]: https://godbolt.org/z/Kr4PPexsM
[2]: https://github.com/boost-ext/ut

Speakers
avatar for Kris Jusiak

Kris Jusiak

Software Architect, Quantlab Financial
Kris is a Software Architect passionate about programming and who has worked in different industries over the years including telecommunications, games and most recently finance for Quantlab Financial, LLC. He has an interest in modern C++ development with a focus on performance and... Read More →


Thursday October 28, 2021 9:00am - 10:00am MDT
_2

9:00am MDT

Back to Basics: Debugging Techniques
Finding and correcting defects in our code (aka bugs) is often a time-consuming, tedious, and challenging task. As the size and complexity of our code bases grows, it can feel like the corresponding difficulty in finding and understanding defects is growing exponentially. And yet, defects continue to arise, and we must continue to fix them.

This talk will look at what debugging is, the role of debugging in our development processes, and some of the many challenges associated with debugging. We'll look at the kinds of defects that debugging can address, and examine a number of strategies, tools, and tips for tracking them down. Finally, we'll provide some guidance for what to do after you've found the problem.

If you've ever faced a challenging bug, and wished for a more complete set of tools for finding it, then this session is for you. Attendees will leave this session with a basic set of debugging tips, tools, and tricks that they can immediately apply to their own daily work.

Speakers
avatar for Bob Steagall

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing


Thursday October 28, 2021 9:00am - 10:00am MDT
_1

9:00am MDT

A Persistent Hash Map for Graph Processing Workloads and a Methodology for Persistent Transactional Data Structures
Emerging byte-addressable Non-Volatile Memories (NVMs) provide higher densities and data persistence where process state can be recovered after crashes. Graph analytic applications such as search and ranking, pattern matching, and clustering benefit from the large capacity available with persistent memory since the data sets are very large with up to trillions of vertices and edges. A hash map is fundamental for graph analytics because it associatively map keys to values, offering constant time lookup for graph updates. While lock-free persistent hash maps have been developed, most perform poorly due to a heavy use of pointer dereferences. Additionally, it is often desirable to perform a composition of graph updates as a transaction. Although persistent data structures enable applications to rely on persistent data with failure-atomic operations, they lack the ability to allow users to execute a sequence of operations as transactions. Meanwhile, persistent transactional memory (PTM) has been proposed by adding durability to Software Transactional Memory (STM). However, PTM suffers from high performance overheads and low scalability due to false aborts, logging, and ordering constraints on persistence.

In this talk, we present PMap, a persistent concurrent hash map with open addressing and non-blocking parallel resizing to cater to large graph processing workloads. Our PMap achieves lock-freedom using compare_exchange_strong from the C++11 Atomic Operations Library. To provide persistence, our design uses a modified version of the link-and-persist approach. While this approach is traditionally used to persist pointers, our modification enables link-and-persist to be used in-place, persisting keys and values directly. This is crucial, as logs, or separate object allocations may require pointer dereferences, which undermines the cache locality benefits of pure open addressing. The PMap uses the C++11 alignas specifier to ensure data can be aligned and flushed on a per-cacheline basis into persistent memory. To accommodate durable transactions, we present PETRA, a new approach for constructing persistent transactional non-blocking linked data structures. PETRA natively supports transactions, but unlike PTM, relies on the high-level information from the data structure semantics. This gives PETRA unique advantages in the form of high performance and high scalability. We present diagrams detailing the PMap design and PETRA methodology for the C++ programming language, and illustrate how to keep the number of cache line flushes and memory fences low through the use of descriptor objects, which are commonly used in the design of lock-free data structures.

We showcase the performance of our proposed persistent data structures by presenting a live demonstration of PMap and PETRA data structures including a linked list, skiplist, map, and multi-dimensional list. We compare PMap to clevel, OneFile, STL, and PMDK, tested on a micro-benchmark and on files from Recursive Model for graph mining (R-MAT). We compare the PETRA data structures to OneFile, Romulus, and PMDK, tested on a micro-benchmark and the Telecommunication Application Transaction Processing (TATP) benchmark. The live demonstration illustrates how PMap outperforms state-of-the-art alternatives averaging 3122x faster under Intel Optane DC, and PETRA outperforms the state-of-the-art PTMs by an order of magnitude in transactions of size greater than one, and demonstrates superior performance in transactions of size one.

Speakers
avatar for Kenneth Lamar

Kenneth Lamar

Graduate Research Assistant, University of Central Florida
Kenneth Lamar received his Bachelor of Science (2017) from the University of Central Florida. He is currently pursuing his PhD in Computer Science at UCF. His research interests include concurrent data structures and distributed computing. His work is currently focused on HPC scheduling... Read More →
avatar for Christina Peterson

Christina Peterson

Postdoctoral Associate, University of Central Florida
Dr. Christina Peterson is a Postdoctoral Associate at the University of Central Florida. Dr. Peterson completed her dissertation work under the supervision of Dr. Damian Dechev with a focus on correctness and progress guarantees of multiprocessor algorithms and data structures. Her... Read More →


Thursday October 28, 2021 9:00am - 10:00am MDT
_3

10:30am MDT

C++20’s <chrono> Calendars and Time Zones in MSVC
The <chrono> header has existed since C++11, but C++20 dramatically increased its capabilities. MSVC has completed this C++20 feature and this session will focus on the development of our implementation and Windows-specific considerations that we encountered. For instance, how do we know if a given point in time is during a leap second insertion? Where do we get the data for time zones? If you are excited by these new chrono features and want to support a Windows platform, come and learn about its developments and caveats for a Windows implementation!

We will also touch on how STL maintainers and our valued external contributors developed the new features collaboratively. If you’re interested in participating in our open-source repo by reporting issues, contributing to discussions, or submitting pull requests, we hope that hearing about an example of collaboration will encourage you to visit our repo in the future.

Speakers
avatar for Miya Natsuhara

Miya Natsuhara

Software Engineer, Microsoft


Thursday October 28, 2021 10:30am - 11:30am MDT
`Online _4
  • const/Units/Time, Online

10:30am MDT

Handling a Family of Hardware Devices with a Single Implementation
Embedded software typically uses memory-mapped registers to communicate with hardware. These registers are often finicky and demanding. Software that accesses a hardware register in the wrong way often produces bugs that are hard to diagnose and fix. In this session, we’ll look at ways to use operator overloading, enumeration types, and other C++ features to craft interfaces that protect against such misuses. We’ll then look at techniques for generalizing that code so that one implementation works for many variations of the hardware.

Using real-world examples of 8-bit and 16-bit hardware timers, we’ll begin by constructing a safe interface for a specific hardware timer. From there, we’ll use templates to generalize the implementation to cover more timer variations. By isolating and extracting the differences between the timers, we’ll minimize the need for code duplication. We’ll also be able to write application code that works equally well with any of the timers. Along the way, we’ll deal with smaller problems, such as dealing with non-contiguous register layouts and guaranteeing that large values are locked during accesses.

This session uses concrete examples of timers in the ARM7 and Arduino MEGA 2560 architectures. However, the techniques from this session apply to a wide variety of platforms and hardware devices such as serial ports or I/O pins.

Speakers
avatar for Ben Saks

Ben Saks

Chief Engineer, Saks & Associates


Thursday October 28, 2021 10:30am - 11:30am MDT
`Online _3
  • Embedded, Online

10:30am MDT

A (Short) Tour of C++ Modules
Modules are probably the most impactful and most transformative recent major addition to the C++ language. From a user perspective, Modules are conceptually simple and the idea is easy to grasp. And with the C++20 ecosystem maturing, using Modules and adopting them into every-day programming is both feasable and advantageous.

But what is the motivation that lead to the invention of Modules and their inclusion into the standard? How do they look like? Which are the three key features of C++ Modules that exist since the inception of the language, that are mostly irrelevant in the typical usage of 'classical' C++ such that hardly any programmer needs to know much about them but a Modules developer does? What surprises might lie on the path of transforming a classical library into a Module? Are there still any issues, loose ends or open questions regarding Modules?

The talk will try to give a comprehensive answer to those questions. The audience shall get enough information to decide when the right time has come for them to take the plunge and move their codebase to Modules wherever it is advantageous.

Speakers
avatar for Daniela Engert

Daniela Engert

Senior Developer, GMH Prüftechnik GmbH
Daniela has a degree in electrical engineering and has been working for more than 30 years in small innovative companies in the field of software and hardware development. She has spent her youth with exploring the very first microprocessors since the late 70's, and has been creating... Read More →


Thursday October 28, 2021 10:30am - 11:30am MDT
`Online _2

10:30am MDT

Embracing PODs Safely Until They Die
How do you change the active member of a union? Can you copy an object without
a publicly callable copy constructor? Can you pass classes having private data to
a function implemented in C? What is the use case for the library type trait
`std::is_trivially_move_assignable`? All these questions and more will be answered
in this session.

PODs --- Plain Old Data --- are neither plain nor old in C++11, and continued to
evolve in every published standard since, until they were finally banished in C++20.
In researching the deconstruction of PODs for the upcoming book, "Embracing
Modern C++ Safely" Alisdair Meredith (and the other authors including John
Lakos, Vittorio Romeo, and Rostislav Khlebnikov) discovered that many of the
intuitive properties and capabilities of trivial and standard layout types did not
behave quite as expected, and there are many subtleties waiting to catch the
unwary. Nina Ranns, as an active member of the Core working group, stepped in
to explain and resolve many concerns, while pointing out further bad assumptions.
Together they will present the use cases, pitfalls, and annoyances of these features
as now properly understood, giving a flavor of the presentation style of each of the
57 C++11/14 features presented in the book.

Speakers
avatar for Alisdair Meredith

Alisdair Meredith

Alisdair Meredith is a software developer at BloombergLP in New York, and a previous chair of the C++ Standard Committee Library Working Group. He has been an active member of the C++ committee for almost two decades, and by a lucky co-incidence his first meeting was the kick-off... Read More →
avatar for Nina Ranns

Nina Ranns

Nina Ranns has been a member of the C++ standard committee since 2013, focusing mostly on the core part of the language, and committee secretary since 2018. Throughout her career she has worked for Siemens, Motorola, Datasift, and Symantec on everything from parts of the UMTS network... Read More →


Thursday October 28, 2021 10:30am - 11:30am MDT
`Online _1
  • Type Design, Online

10:30am MDT

Small Inspiration
This talk is the Embedded Track Keynote.

Less than 1% of microprocessors sold each year find their way into general purpose computers. Desktops, laptops, and servers of all sizes represent a very small fraction of the compute that surrounds us. We interact with a few of these systems but most go unnoticed. These invisible, unsung embedded devices offer lessons in engineering at all scales and can provide inspiration to seasoned practitioners and future technologists.

Join me as we learn from the embedded world and become inspired to inspire.

Speakers
avatar for Michael Caisse

Michael Caisse

Ciere, Inc.
Michael Caisse started using C++ with embedded systems over 30 years ago. He continues to be passionate about combining his degree in Electrical Engineering with elegant software solutions and is always excited to share his discoveries with others.Michael works for Ciere Consulting... Read More →


Thursday October 28, 2021 10:30am - 12:00pm MDT
Aurora C/D
  • Embedded, Hybrid

12:30pm MDT

Hazard Pointer Synchronous Reclamation Beyond Concurrency TS2
Delayed broadcast

The hazard pointer deferred reclamation technique supports low-latency access to dynamic objects by deferring the reclamation of objects that may be removed while being accessed concurrently until reclamation is safe. Many uses of hazard pointers require support for synchronous reclamation, that is, guarantees for the timing of reclamation of some objects, primarily due to the dependence of the deleters of such objects on resources that may become subsequently unavailable.

The upcoming WG21 Concurrency Technical Specification (Concurrency TS2) includes support for hazard pointer synchronous reclamation. This talk describes such support and goes beyond the TS and describes a faster scalable alternative interface for synchronous reclamation and novel algorithms for implementing it that are in heavy use in the Folly open-source library.

Fast and scalable synchronous reclamation for deferred reclamation has been a long-standing open problem. This talk presents a new interface and algorithms that solve the problem. Objects protectable by hazard pointers are organized into cohorts. The completion of the destruction of a cohort object guarantees the completion of the destructors for all associated protectable objects, thus providing synchronous reclamation by controlling cohort destruction. A significant algorithmic challenge is the interaction between synchronous and asynchronous reclamation. Asynchronous reclamation serves to bound the number of reclaimable objects that are not yet reclaimed. The talk outlines how the new algorithms manage to support both types of reclamation safely while allowing synchronous reclamation to be fast and scalable.

The talk concludes with a proposed roadmap for hazard pointer synchronous reclamation standardization beyond Concurrency TS2.

Speakers
avatar for Maged Michael

Maged Michael

Engineer, Facebook
Maged Michael is a software engineer at Facebook. He is the inventor of hazard pointers, lock-free malloc and several algorithms for concurrent data structures. He received a Ph.D. in computer science from the University of Rochester. He is an ACM Distinguished Scientist. He is an... Read More →


Thursday October 28, 2021 12:30pm - 1:30pm MDT
`Online _1

12:30pm MDT

"Deducing this" Patterns
Delayed broadcast

How would our code change if a member function could deduce the type and value category of the object ("this") it worked on?

Potentially a lot, and this talk will highlight some of those changes. Because with C++23, member functions will be able to do just that using a feature described in P0847, "Deducing this". Many patterns in C++ today could change, and new patterns will arise. This talk will explore those patterns, explain how "deducing this" works, and show how it solves the problems that originally motivated the paper.

Some sample effects on our code: CRTP is simplified; decorators become much easier and terser; recursive lambda expressions become straightforward. There are also implications for safely and efficiently moving values through computations.

Speakers
avatar for Ben Deane

Ben Deane

Ben was a game programmer for over 20 years, working in C++ since the late 90s, for companies like EA and Blizzard. In 2018 he left the games industry to join Quantlab, an automated trading firm, where he writes modern, well-performing C++. He likes to play with algorithms, and to... Read More →


Thursday October 28, 2021 12:30pm - 1:30pm MDT
`Online _2
  • C++20/Future of C++, Online

12:30pm MDT

3D Graphics for Dummies
Delayed broadcast

Three-dimensional graphics are much simpler than you would think. I will present the rudimentary techniques for the designs of a simple C++ Matrix library and operator methodologies, through an introduction to 3D Graphics: Points, Vectors, Coordinate Spaces, Matrix Math, Depth Buffer and Rasterization.

We will explore the blood and guts of a C++ Matrix library and 3D graphics. Rather than using off-the-shelf libraries like Unity and OpenGL, we will examine a simple library I wrote to teach myself about the subject. Includes demo of the graphics library/app.

Speakers
avatar for Chris Ryan

Chris Ryan

Sr. SW/FW Eng C++ / Speaker Liaison, Day: Amazon   Night: C++Now / CppCon
I make the complex simple by reducing complexity. Chris Ryan was classically trained in both software and hardware engineering. He is well experienced in Modern C++ & Classic ‘C’, on extremely large/complex problem spaces and on Embedded/Firmware devices (large & small). Chris... Read More →


Thursday October 28, 2021 12:30pm - 1:30pm MDT
`Online _4

12:30pm MDT

Back to Basics: Compiling and Linking
Most C and C++ programmers know the conventions for distributing declarations and definitions among headers and source files. However, there are exceptions to these conventions that we often chalk up to “linker magic”. If the linker can’t deal with multiply-defined symbols, how does it handle inline and constexpr functions? Why do explicit template specializations go into source files when most template code goes into headers? And what can embedded developers do to tell the linker to map certain code and data into specific memory regions?

This session answers these questions by taking a detailed look at how the traditional C/C++ build model works with headers and source files. It describes what happens during each stage of the build process: preprocessing, compiling, instantiation, and linking. It explains what information the compiler records from declarations and definitions – including exceptional cases like inline and templates – and how the linker uses that information to generate an executable. It also shows how you can use explicit instantiation to control memory layout and reduce build times. Finally, this session walks an example program through the entire build process to demonstrate how everything fits together.

This is **not** a session on C++20 Modules. However, it explains terms such as “translation unit” and “linkage” that are also part of the Modules framework, providing a solid foundation for understanding Modules.

Speakers
avatar for Ben Saks

Ben Saks

Chief Engineer, Saks & Associates


Thursday October 28, 2021 12:30pm - 1:30pm MDT
`Online _5
  • Modules/Libraries, Online

12:30pm MDT

A Case-study in Rewriting a Legacy GUI Library for Real-time Audio Software in Modern C++
Delayed broadcast

This session is part of the Software Design Track.

A case-study in the design and development of iZotope's GUI framework,
for real-time audio software, using C++17 to eliminate common sources of
bugs and increase developer productivity. To illustrate this process,
we will study GlassProperties, a new open-source library for property
serialization and accessor method synthesis. While designed to support
building GUIs for real-time audio software, GlassProperties is a general
purpose framework not tied to any one GUI library and could easily be
adapted into your GUI or any part in your tech stack.

We will cover the library design process, starting with
analysis of legacy code and bugs to develop user problem statements.
These user problems will be our guide for wrapping a legacy system with
a new type-safe API using C++17 compile-time meta-programming so that
run-time bugs become compile-time errors. Once we arrive at a C++17
design, we will close with a brief look to the future and how the
library would look with C++20 Concepts.

In addition to learning the software design techniques to succeed in
this rewrite, some lessons learned will be shared so you will be armed
with both the C++ skills and business strategy to take on a project like
this at your organization.

Speakers
avatar for Roth Michaels

Roth Michaels

Principal Software Engineer, iZotope, Inc.


Thursday October 28, 2021 12:30pm - 1:30pm MDT
`Online _3

2:00pm MDT

Custom Views for the Rest of Us
C++20's views are an exciting and powerful new feature, and while the standard includes several views to get you started, there is plenty of room for improvement. Third-party libraries such as range-v3 can help, but how hard would it be to write one for your own application?

This talk will provide an introduction to how views work, along with solutions to common problems that you may encounter when trying to implement your own views. It will also go into some depth on a few of the shortcomings in the C++20 implementation of views and how they can be improved in future versions, as well as some possible workarounds that you can use in the meantime.

Speakers
avatar for Jacob Rice

Jacob Rice

Software Engineer, Keysight Technologies, Inc.
Jacob is a software engineer for Keysight Technologies in Colorado Springs, CO. He specializes in legacy code modernization, template library utility design, and system architecture. While he is a proponent of clean code in the workplace, he's also a big fan of esoteric and overly... Read More →


Thursday October 28, 2021 2:00pm - 3:00pm MDT
_2
  • Algorithms/Functional, Hybrid

2:00pm MDT

Using Coroutines to Implement C++ Exceptions for Freestanding Environments
The current design of C++ exceptions lead to many reasons and excuses to disable them. They require outstanding unwinding libraries, ABI specific support, slow failure paths, metadata that increases binary size, RTTI (run time type information), and many more. Putting costs and overhead aside, it is often impractical, or holds significant implementation barriers, to implement the necessary support for C++ exceptions in every environment - kernel, custom OS, hypervisors, embedded, or an arbitrary freestanding environment with limited or no C++ runtime libraries.

Writing code using exceptions is great though! The programmer gets to focus on the actual story of what the program is doing, and not worry too much about error propagation that happens automatically whenever an exception is thrown.

So how do we avoid the manual error propagation that is usually followed by turning off exceptions? We use Macros(!), of course, to propagate the errors via return value, such as CHECK_ERROR(expression), RIGHT? Well... Not in this talk.

In this session we are going to use the only tool I know of, that is both available in standard C++20, and gives us the ability to automatically propagate errors. If you read the title, you already know that this tool was not meant to be used for that purpose - that is C++20 Coroutines!

We are going to not only run without exceptions, we are turning off RTTI as well, as we get inspired by this alternative method of throwing exceptions, observe some cool optimizations such as memory allocation elisions, nice work arounds, and more. We will even get the link to the open source library that I wrote for this talk, so that you could try it yourself!

This talk is for you if you want to get inspired on a unique usage of coroutines, not commonly seen before, or if you are working on kernel / freestanding code and like the use of exceptions. I hope that after this talk the audience plays with the thought that maybe in the future, exceptions could be implemented as a standard library feature, using a core language machinery such as coroutines, or some evolution or adaptation of it to this great use case.

How to prepare for the talk - please be familiar with C++20 coroutines, just the basic understanding is enough.

Speakers
avatar for Eyal Zedaka

Eyal Zedaka

Device Security Engineering Manager, Magic Leap
Eyal Zedaka is a technical leader. He is a C++ knowledge center, lecturer in various C++ courses, and an author of C++ open source software in the areas of low level OS, and pure C++ frameworks. Eyal is now working at Magic Leap, an Augmented Reality (AR) device company, as manager... Read More →


Thursday October 28, 2021 2:00pm - 3:00pm MDT
_1
  • Async/Concurrency/Parallelism, Hybrid

2:00pm MDT

Branchless Computing: Why Conditions Are Bad for Your Code, and What Can You Do About It
Have you ever written code like this:
void f(bool b, long x, long& s) { if (b) s += x; }
Probably you have. Would you like me to tell you how much performance you left on the table? With a small change, that function could be made 2.5 times faster.

What about this code:
if (a[i] && b[i]) do_something(); else do_something_else();
Would you believe me if I told you that, under some not-so-exotic conditions, this line runs four times slower than it could be? It’s true, and I’m going to show you when and why.

This presentation will explain how modern CPUs handle computations to ensure that the hardware is used efficiently (which is how you get high performance from the processor). We will then learn how conditional code disrupts the ideal flow of computations and the countermeasures employed by the CPU designers to retain good performance in the presence of such code. Sometimes these measures are sufficient, often with the help of the compiler. But when they aren’t, it is up to the programmer to recover lost performance by coding with fewer branches.

Speakers
avatar for Fedor Pikus

Fedor Pikus

Chief Scientist, Siemens
Fedor G Pikus is a Chief Engineering Scientist in the Design to Silicon division of Mentor Graphics Corp (Siemens business). His earlier positions included a Senior Software Engineer at Google and a Chief Software Architect for Calibre PERC, LVS, DFM at Mentor Graphics. He joined... Read More →


Thursday October 28, 2021 2:00pm - 3:00pm MDT
_4

2:00pm MDT

An Editor Can Do That? Debugging Assembly Language and GPU Kernels in Visual Studio Code
In this session, you’ll learn how to take advantage of VS Code’s new debugging capabilities and discover easy ways to boost your C++ development productivity along the way.

We’ll get a simple embedded project up and running on a Raspberry Pi using the new Makefile Tools extension for Visual Studio Code. Then, we’ll dive deep into a debugging session, digging into both source code and assembly language. Next, we’ll debug GPU kernels in VS Code using NVIDIA’s Nsight Visual Studio Code Edition extension.

You’ll walk away from this talk with the knowledge and tools to take advantage of all VS Code’s debugger has to offer, along with bonus tips about optimizing productivity in C++ development regardless of which editor or IDE you’re using.

Speakers
avatar for Julia Reid

Julia Reid

Program Manager, Microsoft
Julia is a program manager on the Visual C++ team at Microsoft, focusing specifically on Visual Studio Code. Because Julia comes from a background of C++ development, she has a passion for enhancing and simplifying C++ development experiences for programmers of all levels. Within... Read More →


Thursday October 28, 2021 2:00pm - 3:00pm MDT
_3
  • Tooling/Debugging, Hybrid

2:00pm MDT

Code Size Compiler Optimizations and Techniques for Embedded Systems
Code size of embedded application has been a concern for a very long time. While storage becomes cheaper and smaller, developers find creative ways to increase code size by adding features or unnecessary software engineering. Compilers have come a long way in optimizing applications for code size. While most compiler optimization work were focused on application performance, we have seen increase in the code size optimizations in recent years.

In this presentation I'll talk about classical as well as recent compiler optimizations for code size, a few of which I implemented in the LLVM compiler. Some optimizations (hot cold splitting, function entry instrumentation) require collecting data from the field while the application is running. I'll provide an overview of how those compiler techniques help reduce code size. I'll also talk about some tips and techniques (compiler flags to reduce code size, tuning of compiler options like inline threshold), that help reduce binary size. Having knowledge of the code generated by the compiler and the instruction set architecture can help engineers chose appropriate programming abstractions and idioms.

Key takeaways:
- Compiler optimization flags and tunings for code size optimizations
- Selecting code-size friendly data structures and algorithms from the C++ standard library
- Source code level optimization and annotation techniques to reduce binary size
- Compiler instrumentation techniques to get insights into the source code
- Software re-organization techniques to reduce working set during program startup

Speakers
avatar for Aditya Kumar

Aditya Kumar

Compiler Engineer, Snap Inc
I've been working on LLVM since 2012. I've contributed to modern compiler optimizations like GVNHoist, Hot Cold Splitting, Hexagon specific optimizations, clang static analyzer, libcxx, libstdc++, and graphite framework of gcc.


Thursday October 28, 2021 2:00pm - 3:00pm MDT
`Online _1

3:15pm MDT

Conquering C++20 Ranges
This is the final part in a trilogy of talks covering the new Ranges functionality in C++20. Following the format of “C++20 Ranges in Practice” (CppCon 2020), in this instalment we’ll look at three more everyday programming problems and discover how Ranges can be used to solve them cleanly, elegantly and concisely. In particular, in this talk we’ll focus on how we can implement our own custom range adaptors, often seen as the “final hurdle” on the road to conquering Ranges. Time permitting, we’ll also take a brief look at the new ranges additions currently in the planning stages for C++23.

Familiarity with previous talks in the series is helpful, but not required.

Speakers
avatar for Tristan Brindle

Tristan Brindle

C++ London Uni


Thursday October 28, 2021 3:15pm - 4:15pm MDT
`Online _1

3:15pm MDT

Why does std::format do that?
std::format is a very convenient and very fast text formatting interface added in C++20. This session looks at the internals of how std::format works, and why it works that way. We'll cover how and why argument types are erased (along with the basics of type erasure in general), how to customize format for your own types, precisely what happens when you do, and how format optimizes copying to its output without generating excessive amounts of code. No knowledge of std::format is required to understand this session.

While the primary goal of this session is to understand some std::format internals, many of the techniques described may help you make your own generic libraries smaller and faster.

Speakers
avatar for Charles Barto

Charles Barto

Software Engineer, Microsoft
Charlie works on the Visual C++ Standard Library. He and open source contributors implemented <format> for msvc, based on {fmt}.


Thursday October 28, 2021 3:15pm - 4:15pm MDT
_1

3:15pm MDT

Back to Basics: Smart Pointers and RAII
In this talk we will overview one of the most fundamental and useful abilities of C++: Resource Acquisition Is Initialization. We'll start with an overview of "what is a resource" and understand the difficulties of managing resources in modern programming. Next, we will overview a few solutions suggested in the software development world, and analyze their pros and cons.

We will then deep dive into C++'s suggested solutions, including smart pointers, and learn how to combine them in our code. Finally, we will discuss RAII from a design perspective, and how to apply a user-defined RAII solution to your code.

At the end of the talk you'll be familiar with resource management in software applications in general, and have the toolbox for applying it to your C++ project.

This talk will assume knowledge of topics presented in: "Back to Basics: Pointers", "Back To Basics: Special Member Functions"

Speakers
avatar for Inbal Levi

Inbal Levi

SolarEdge
Inbal Levi is an embedded software engineer with a passion for high performance.She is a director at ISO C++ foundation, the chair of SG9 (Ranges group)  of ISO/IEC JTC1/SC22/WG21 (the C++ Standards Committee) and of the ISO C++ Israeli NB, and one of the organizers of CoreCpp conference... Read More →


Thursday October 28, 2021 3:15pm - 4:15pm MDT
_4

3:15pm MDT

Embracing `noexcept` Operators and Specifiers Safely
The `noexcept` operator, in concert with the `noexcept` specifier, allows generic code to choose a more efficient algorithm for types that have nonthrowing move and swap operations. These two C++11 features --- which have continued to evolve with every release of the language since C++11 --- are useful to high-performance computing yet, when overused, can profoundly jeopardize the maintainability of a large code base.

In this talk we will explore what the `noexcept` keyword means, what it offers, how it can be used effectively, the potential pitfalls one can encounter (and how to avoid them), and finally some excruciating annoyances regarding `noexcept` that exist in the C++ standard today. We intend to propose a fix for C++23 that will address those pitfalls and annoyances.

Background: Modern C++ offers a cornucopia of new features, not all of which are equally safe, especially when introduced into a large organization comprising legacy software and seasoned engineers proficient in early versions of the language. Over the past 18 months, I -- along with my coauthors -- have been privileged to work with some of the best minds on the planet to create a compendium of engineering wisdom from which virtually any C++ software engineer might benefit. The material presented in this talk derives directly from our about-to-be-published book, Embracing Modern C++ Safely.

Speakers
avatar for John Lakos

John Lakos

Software Engineer, Bloomberg
John Lakos, author of Large-Scale C++ Software Design, serves at Bloomberg LP in New York City as a senior architect and mentor for C++ Software Development world-wide. He is also an active voting member of the C++ Standards Committee’s Evolution Working Group. Previously, Dr. Lakos... Read More →


Thursday October 28, 2021 3:15pm - 4:15pm MDT
_2

3:15pm MDT

Using Clang LibASTMatchers for Compliance in Codebases
Many Clang AST matcher use cases revolve around refactoring code. We utilized them in a new way, to ensure compliance in our codebase. In this presentation, we will explore Clang's LibASTMatcher library, go over the basics of setting up a project, and walk through our approach to creating matchers for simple to complex cases.

Developers who must comply with industry or product regulations will find this use case helpful. Join me as we take what we've learned and apply it.

Speakers
avatar for Jonah Jolley

Jonah Jolley

Jonah Jolley is a staff engineer at Devetry where he helps clients and engineers navigate the complex world of tech. He is passionate about embedded systems and optimizing developer’s workflows. In his spare time he likes to play disc golf and go sailing.


Thursday October 28, 2021 3:15pm - 4:15pm MDT
_3
  • Tooling/Debugging, Hybrid

4:45pm MDT

Asserting Your Way to Faster Programs
It is common practice to use defensive runtime checks, such as C-style assertions to help ensure program correctness, especially during testing. However, when thorough testing and beta releases bring confidence that production software is acceptably defect-free, redundant checks' value gradually decreases. With the value of redundant runtime checks diminishing, disabling them becomes more reasonable as doing so can often lead to measurable performance improvements. Although these assertions are disabled, they still carry valuable information which could assist the compiler's optimizer - namely, that for every defect-free program, the expression stated in the inactive assertion must hold. Most C and C++ compilers optimize code based on actively checked assertions; however, there is currently no standardized support for harnessing that very same information once redundant checks are disabled.

This talk explores the potential impact of the compiler assuming inactive C-style assertion predicates on runtime performance. We then share the result of our raw empirical research applied to real-world production software leveraging Bloomberg's BDE libraries, contrasting relevant metrics - such as compile times, run times, and binary sizes - across various categories of software libraries and applications. It will turn out that there are substantial opportunities to improve performance having relatively little impact on compile times. Moreover, if runtime performance is not improved, it is rarely, if ever, made measurably worse.

Speakers
avatar for Parsa Amini

Parsa Amini

Senior Software Engineer, APC Workforce Solutions


Thursday October 28, 2021 4:45pm - 5:45pm MDT
_2

4:45pm MDT

C++20 on Xilinx FPGA with SYCL for Vitis
FPGA (Field-Programmable Gate Arrays) are electronic devices which are
programmable with a configuration memory to implement arbitrary
electronic circuits. While they have been used for decades to
implement various adaptable electronic components, they got some
traction more recently to be used as generic programmable accelerators
more suitable for software programmers.

There are already HLS (High-Level Synthesis) tools to translate some
functions written with languages like C/C++ into equivalent electronic
circuits which can be called from programs running on processors to
accelerate parts of a global application, often in an energy-efficient
way. The current limitation is that there are 2 different programs:
the host part, running the main application, and the device part,
glued together with an interface library without any type-safety
guaranty.

Since the C++ standard does not address yet the concept of hardware
heterogeneity and remote memory, the Khronos Group organization has
developed SYCL, an open standard defining an executable DSL
(Domain-Specific Language) using pure modern C++ without any
extension. There are around 10 different SYCL implementations
targeting various devices allowing a single-source C++ application to
run on CPU and controlling various accelerators (CPU, GPU, DSP, AI...)
in a unified way by using different backends at the same time in a
single type-safe C++ program.

We present a SYCL implementation https://github.com/triSYCL/sycl
targeting Xilinx Alveo FPGA cards by merging 2 different open-source
implementations, Intel’s oneAPI DPC++ with some LLVM passes from
triSYCL.

For a C++ audience, this presentation gives a concrete example on why
the C++ standard does not describe detailed execution semantics
(stack, cache, registers...): because C++ can be executed on devices
which are not even processors.

While this presentation targets FPGA and a SYCL implementation from a
specific vendor, the content provides also:
- a generic introduction to FPGA which should be interesting outside
of Xilinx or even without the use of SYCL;
- how C++ can be translated in some equivalent electronic circuits;
- a generic introduction to SYCL which should be interesting for
people interested to know more about heterogeneous programming and
C++, beyond only FPGA.

Speakers
avatar for Ronan Keryell

Ronan Keryell

Principal Software Engineer, Xilinx
Ronan Keryell is principal software engineer at Xilinx Research Labs,where he works on high-level programming models for heterogeneoussystems, such as FPGA and CGRA, with the open-sourcehttps://github.com/triSYCL/triSYCL SYCL implementation.He is the specification editor of the SYCL... Read More →


Thursday October 28, 2021 4:45pm - 5:45pm MDT
_1
  • Embedded, Onsite

4:45pm MDT

Up to Code
This session is part of the Software Design Track.

Many engineering disciplines require alterations or improvements of existing systems to be "up to code," whether that be the installation of railings on a staircase or upgrades to electrical work. In this talk, we'll apply this concept to Software Engineering and, in particular, C++-based systems. Using one real-world example, we'll cover best practices including: contracts, type-driven architecture, hierarchical design, and difficult testing scenarios as they apply to "old work."

While many of these topics are covered elsewhere, they are usually presented as if all code is being written from scratch. Application to an existing system is an entirely different matter. That is the subject of this talk.

Speakers
avatar for David Sankel

David Sankel

Software Engineering TL, Bloomberg
David Sankel is a Software Engineering Manager/TL at Bloomberg and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography... Read More →


Thursday October 28, 2021 4:45pm - 5:45pm MDT
_4
  • Software Design, Onsite

4:45pm MDT

Finding Bugs Using Path-Sensitive Static Analysis
Path-sensitive static analysis simulates the runtime behavior of the program code and uses the analysis state to evaluate which branches can be taken. It is an effective tool to find non-trivial bugs in code at compile time. While checks based on such analysis can take longer time to run, they have a sophisticated understanding of the code that helps them uncover semantic issues. First, I will discuss how can you turn these checks on and how to make sense of the warning messages they produce. Furthermore, I will do a deep dive on what makes path-sensitive analysis an effective tool to reason about code and how MSVC is leveraging this power to find bugs. In particular, I will explain how modern tools like constraint solvers can help increase the precision of the analysis. Throughout the talk, I will not only feature already released checks but also give a glimpse of the upcoming ones that we are actively working on. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

Speakers
avatar for Gabor Horvath

Gabor Horvath

Software Engineer, Microsoft
Gabor started a Ph.D. in 2016. He is a contributor to research projects related to static analysis since 2012. He is a clang contributor, participated in Google Summer of Code twice as a student and many times as a mentor, interned for Apple, Microsoft and Google. He taught C++ and... Read More →


Thursday October 28, 2021 4:45pm - 5:45pm MDT
_3

6:30pm MDT

Meet the Speakers Banquet
The Meet the Speakers Banquet is open to all attendees. Invitation is included with "Full" conference registration and is also available as a separate, stand-alone registration.

A Main Program speakers are invited by the conference, so this is your opportunity to meet and discuss with speakers in a relaxed, informal environment.

[CppCon 2021 Registration]

Thursday October 28, 2021 6:30pm - 8:00pm MDT
Aurora B
 
Friday, October 29
 

7:45am MDT

C++ Standard Parallelism
Imagine writing parallel code that can run on any platform - CPUs, GPUs, DPUs, specialized accelerators, etc. It's no longer just a dream - you can do it in Standard C++!

Parallelism is increasingly common in software, from supercomputer simulations to mobile applications. But writing parallel code is increasingly challenging, due to an explosion of diversity in hardware, a trend that's likely to continue into the future. To meet this challenge, the Standard C++ Committee has developed a roadmap for C++ Standard Parallelism, a parallel programming model that will be portable to all platforms while delivering reasonable performance and efficiency for most use cases.

Our vision of C++ Standard Parallelism consists of three key components:

* Common parallel algorithms that dispatch to vendor-optimized parallel libraries
* Tools to write your own parallel algorithms that run anywhere.
* Mechanisms for composing parallel invocations of algorithms into task graphs.

In this talk, we'll dive into this roadmap - we'll discuss what we already have that you can use today, what's coming down the line, and where the future may lead us.

Speakers
avatar for Bryce Lelbach

Bryce Lelbach

HPC Programming Models Architect, NVIDIA
Bryce Adelstein Lelbach has spent over a decade developing software libraries and programming languages. He is the HPC Programming Models Architect at NVIDIA, where he leads programming language standardization efforts and drives the technical roadmap for NVIDIA's HPC compilers and... Read More →


Friday October 29, 2021 7:45am - 8:45am MDT
`Online _1

7:45am MDT

Our Adventures With REST API in C++ : Making it Easy
Consuming webservices is a routine work in today software development, however the solutions requires developers to repeat themselves very often : parsing and serializing payloads in JSON manually, hardcoding HTTP REST route calls in their applications themselves.

In principle OpenAPI comes to the rescue, but this implies generating code in a custom build process step, with terrible tooling leading to reduced code quality.

In this talk we present a clean and modern C++ solution to REST, JSON and OpenAPI with a bit of magic.

Speakers
avatar for Damien Buhl

Damien Buhl

Founder, tipi.build
Damien (aka daminetreg) co-founder and CEO tipi.build is an enthusiast C++ developer. Opensource entrepreneur, GameMaker.fr community founder, Qt for Android contributor, Boost.Fusion maintainer since 2014.


Friday October 29, 2021 7:45am - 8:45am MDT
`Online _3
  • Code Design, Online

7:45am MDT

How Can Package Managers Handle ABI (In)compatibility in C++?
Package managers are crucial in many software ecosystems for reusing libraries, and several major package manages (Conan, vcpkg, and, at least in the HPC world, Spack) have started to grow a large user base within the community. One of the central issues to reusing packages in C++ is ABI, or Application Binary Interface. ABI is fundamental to package compatibility -- it affects how binary artifacts can be reused and composed, and ABI incompatibilities can mean that you need to rebuild an entire stack from source -- which may not be possible, depending on your deployment environment and your user base.

This presentation will look at how ABI can be managed at the *ecosystem* level. We'll look at how the major C++ package managers guarantee ABI compatibility (or not), and how that compares to major build systems (Bazel, Buck, etc.) that manage monorepos. We'll look at the ramifications of ABI on your CI system -- if you reuse a dependency form one project, or if you change a header in one library, when do you need to rebuild the other libraries? What metadata is needed if we want to do better than rebuilding everything from source all the time? We'll finally look at some early (and novel) attempts to do deeper ABI analysis in Spack, and how they could be implemented at scale.

We hope you'll come away from this presentation with the tools to understand how binary compatibility fits into a larger C++ package ecosystem, and what tradeoffs there are from the perspective of the user and the package manager developer. Recent talks at CppCon about ABI have been pessimistic, and we hope this sparks more exchange of ideas around ABI management and how we can make reliable and *fast* package managers for C++ users, without rebuilding the world.

Speakers
avatar for Todd Gamblin

Todd Gamblin

Senior Principal Member of Technical Staff, Lawrence Livermore National Laboratory
Todd Gamblin is a computer scientist in the Center for Applied Scientific Computing at Lawrence Livermore National Laboratory. His research focuses on scalable tools for measuring, analyzing, and visualizing parallel performance data. In addition to his research, Todd leads LLNL's... Read More →


Friday October 29, 2021 7:45am - 8:45am MDT
`Online _5

7:45am MDT

The Roles of Symmetry And Orthogonality In Design
This session is part of the Software Design Track.

An essential aspect in designing C and C++ systems is to validate the execution flow and resource contention of a proposed approach in the contexts of symmetry and orthogonality.

The role of symmetry is to provide some level of notional understanding without requiring direct inspection (using “similarity” to enable greater scaling and management of design complexity). The role of orthogonality is to remove edge cases and coupling by making things unrelated (thereby making whole system scaling to be simpler, more efficient, and more adaptable).

These roles establish symmetry and orthogonality as useful tools to define our systems by leveraging different aspects of “knowing” many things about our system components and their possible interactions intuitively, and without tedious scrutiny. Symmetry allows us to “know” things we should not otherwise know; while orthogonality grants simplicity to dismiss as a possibility some behaviors or component interactions within the resulting system.

In practice, we use C and C++ language guarantees to implement design choices. But, these design choices come from integrating: (1) the problem to be addressed; and (2) exploiting symmetry and orthogonality to fabricate a system that is logical, implementable, scalable, and unsurprising.

Speakers
avatar for Charley Bay

Charley Bay

Charley Bay
Charley is a software developer with over three decades of experience using C++ in multiple regulated and high-performance fields focused on large-scale and distributed systems in performance-sensitive environments including time-sensitive processing of large data sets, performance... Read More →


Friday October 29, 2021 7:45am - 8:45am MDT
`Online _4
  • Software Design, Online

7:45am MDT

Zen and the Art of Code Lifecycle Maintenance
Robert Pirsig’s 1974 bestselling classic, “Zen and the Art of Motorcycle Maintenance” was not about Zen - or Motorcycles - although both made an appearance. The subtitle gives you more of an idea: “An Inquiry into Values” - but it was only later that the main concepts in the book, along with the sequel, “Lila” came to form part of “A Metaphysics of Quality”.

Quality, it turns out, is very hard to define. Software Quality is no different. When someone talks about software quality, what do they really mean? How do we measure it? How can we improve it? How do we know when we have it?

We have no shortage of incomplete candidates for these definitions. But over the years I’ve been working to establish what I think are the most important aspects of software quality, how they work together (and sometimes against each other) and how we need all of them (even if they sometimes come as a set).

In Pirsig’s semi-autobiographical novel, we are taken on a motorcycle journey from the east to west coasts of the USA. Our journey will take us through the territories of tests, types and static and dynamic static analysis - all with no mention of east or west const.

Speakers
avatar for Phil Nash

Phil Nash

Developer Advocate, SonarSource
Developer Advocate at SonarSource, author of Catch/Catch2, co-host of cpp.chat and No Diagnostic Required, host of C++ London, chair and organiser of C++ on Sea.


Friday October 29, 2021 7:45am - 8:45am MDT
`Online _2

9:00am MDT

Squaring the Circle: Value-oriented Design in an Object-oriented System
In this talk, we will present a new open-source library of cursors. Cursors are inspired by functional lenses and reactive streams to provide composable and modular facades to "single atom" value storages. We will see how this can be used to navigate the tension between object-oriented and value-oriented design, and build an example interactive application using Qt and QML against a value-based data-model.

Value-oriented design reconciles functional and procedural programming by focusing on value semantics. Like functional programming, it promotes local reasoning and composition — it is, however, pragmatic and can be implemented in idiomatic C++. In previous talks, the speaker has discussed how immutable data-structures help use value semantics at scale, and how the Unidirectional Data-flow Architecture (Redux, Elm) provide a solid foundation for designing interactive software based on values and functions.

However, we rarely have the luxury of starting from scratch. We are often embedded in legacy codebases with Frankensteinian designs crystalized over decades of multi-paradigm evolution. Also, it's hard to build serious interactive software without frameworks like Qt or Juce that, with all its power, also impose a Javaish object-oriented approach at the boundaries of our system. In this talk we will learn how novel abstractions and design methodologies can help modernize real world code-bases, incrementally migrating them to a value-oriented design.

Speakers
avatar for Juan Pedro Bolivar Puente

Juan Pedro Bolivar Puente

Consultant, Independent (Sinusoidal Engineering)
Juanpe is a Berlin based freelance software engineer, with a focus on interactive software, modern C++, functional programming and open source strategy. Before he worked for Ableton and he has been involved in various music technology projects. He has also developed for the GNU project... Read More →


Friday October 29, 2021 9:00am - 10:00am MDT
`Online _1
  • Code Design, Online

9:00am MDT

Units Libraries and Autonomous Vehicles: Lessons from the Trenches
Units libraries have an enticing value proposition: they can catch mistakes in physical units at compile time, with zero runtime cost.  The most famous such error is the unit mismatch that brought down the Mars Climate Orbiter in 1999.  This multi-hundred-million dollar disaster has since become the poster child for units libraries everywhere, leaving the impression that their primary function is to produce compiler errors.  But does prolonged, real-world experience bear that out?

This talk distills lessons learned from three years of units library usage in the Autonomous Vehicle industry, across two companies (Uber ATG and Aurora).  While these libraries do work as advertised to prevent unit mismatches, we find that this is not their primary value.  Such errors are extremely rare in practice---but only because developers do significant manual work to both create and maintain unit correctness.  The main value of the units library is to robustly automate this work, letting developers redeploy this mental energy more profitably elsewhere.

The degree to which users actually obtain this benefit is primarily driven by the quality of the library's interfaces.  Broadly, this means striking a balance where we minimize friction as much as possible, while anticipating and preventing pitfalls and traps.  It also means adhering to a principle we call "unit safety", which reduces cognitive load by keeping our reasoning about units as local as possible.  Finally, it means playing nicely with other libraries: using the Eigen library as an example, we'll discuss the tradeoffs involved in two separate integration strategies.  By the end of the talk, users should have a realistic picture of the suite of benefits offered by units libraries, and be well equipped to use one effectively.

Speakers
avatar for Chip Hogg

Chip Hogg

Staff Software Engineer, Aurora Innovation
Chip Hogg is a Senior Software Engineer with Aurora Innovation, on the Motion Planning Team. After obtaining his PhD in Physics from Carnegie Mellon in 2010, he was a postdoctoral researcher and then staff scientist at the National Institute of Standards and Technology (NIST), doing... Read More →


Friday October 29, 2021 9:00am - 10:00am MDT
_1
  • const/Units/Time, Hybrid

9:00am MDT

Down the Rabbit Hole: An Exploration of Stack Overflow Questions
This is the Closing Keynote of the Back to Basics Track.

Many Stack Overflow questions are straightforward - "How do I do sort a vector in decreasing order?" for example. But some of them are subtle, and the more you look at them, the more different possible answers appear.

In this talk, I will show a few SO posts, and discuss possible solutions. These will involve tradeoffs between different data structures and algorithms, complexity guarantees, algorithm design, performance measurement, and testing alternatives.

This talk requires moderate familiarity with the standard library and the contents of the STL.

Speakers

Friday October 29, 2021 9:00am - 10:00am MDT
_2

9:00am MDT

Real-time Programming with the C++ Standard Library
In applications such as video games and audio processing, a program has to not only produce the correct result, but to do so reliably in a deterministic amount of time. The code needs to satisfy real-time constraints, complicated by the fact that it will typically run on a non-real-time OS kernel. Writing code for such constraints significantly differs from writing code that maximises for bandwidth or overall performance.

How well suitable is the C++ standard library for such scenarios? In this talk, we will go through many of its facilities in detail. Which are safe to use in (near-)real-time contexts? Which should be avoided, and why? We will discuss well-established utilities and useful patterns as well as some less commonly known details.

This talk is a different kind of tour through the standard library – and afterwards, you will be more confident in using it!

Speakers
avatar for Timur Doumler

Timur Doumler

Cradle
Timur Doumler is a C++ developer specialising in audio and music technology, an active member of the ISO C++ committee, and Conference Chair of the Audio Developer Conference (ADC). He is passionate about building communities, clean code, good tools, and the evolution of C++.


Friday October 29, 2021 9:00am - 10:00am MDT
_3

10:30am MDT

Correctly Calculating min, max, and More: What Can Go Wrong?
The C++ standard library long ago selected operator < as its ordering primitive, and even spells it in several different ways (e.g., std::less).

This talk will explain why operator < (and its aliases) must be used with care, in even such seemingly simple algorithms as max and min.

We will also discuss the use of operator < in several other order-related algorithms, showing how easy it is to make mistakes when using the operator < primitive directly, no matter how it’s spelled.  (Of course, we will also present a straightforward technique to avoid such mistakes.)

Speakers
avatar for Walter E. Brown

Walter E. Brown

With broad experience in industry, academia, consulting, and research, Dr. Walter E. Brown has been a C++ programmer for over forty years, joining the C++ standards effort in 2000. Among numerous other contributions, he is responsible for introducing such now-standard C++ library... Read More →


Friday October 29, 2021 10:30am - 11:30am MDT
_3
  • Algorithms/Functional, Hybrid

10:30am MDT

Beyond CUDA: GPU Accelerated Computing on Cross-Vendor Graphics Cards with Vulkan Kompute (AMD, Qualcomm, NVIDIA & Friends)
Many advanced data processing paradigms fit incredibly well to the parallel-architecture that GPU computing offers, and exciting advancements in the open source projects such as Vulkan and Kompute are enabling developers to take advantage of general purpose GPU computing capabilities in cross-vendor mobile and desktop GPUs (including AMD, Qualcomm, NVIDIA & friends). In this talk we will provide a conceptual and practical insight into the cross-vendor GPU compute ecosystem as well as how to adopt these tools to add GPU acceleration to your existing C++ applications.

In this talk we will show how you can write a simple GPU accelerated machine learning algorithm from scratch which will be able to run on virtually any GPU. We will give an overview on the projects that are making it possible to accelerate applications across cross-vendor GPUs. We'll show how you can get started with the full power of your GPU using the Kompute framework with only a handful of lines of C++ code, as well as providing an intuition around how optimizations can be introduced through the lower level C++ interface.

As part of the more advanced example, we will showcase some optimizatiosn that can be leveraged through the hardware capabilities of relevant graphics cards, such as concurrency-enabled GPU queues which allow us to introduce 2x+ performance improvements into advanced data processing workloads. We will dive into the GPU computing terminology around asynchronous & parallel workflow processing, cover the core principles of data parallelism, explain the hardware concepts of GPU queues & queueFamilies, and talk about how advancements in new and upcoming graphics cards will enable for even bigger speedups (such as the AMD architectures or NVIDIA Ampere GA10x architecture which will support up to 3 parallel queue processing workloads).

Speakers
avatar for Alejandro Saucedo

Alejandro Saucedo

Engineering Director, Seldon Technologies
Alejandro is the Chief Scientist at the Institute for Ethical AI & Machine Learning, where he leads the development of industry standards on machine learning explainability, adversarial robustness and differential privacy. Alejandro is also the Director of Machine Learning Engineering... Read More →


Friday October 29, 2021 10:30am - 11:30am MDT
`Online _1

10:30am MDT

Making Libraries Consumable for Non-C++ Developers
In this lecture, we will discuss some of the most painful issues faced by developers attempting to consume C++ libraries from a non-C++ application. These issues are typically first confronted by the non-C++ developer and then more experience interop stakeholders must be brought in. Issues arising during initial consumption are notoriously difficult to diagnose, debug, and understand often requiring some reverse engineering skills. This talk is designed around bridging the gap between C++ library author and the library consumer who is often not a C++ application developer.

Speakers
avatar for Aaron R Robinson

Aaron R Robinson

Principal Software Engineer, Microsoft
Aaron Robinson currently works at Microsoft on the .NET Interop team. He previously worked at The MathWorks helping developers interop their C/C++, Fortran, C#, Java, and Ada code via MEX functions. Aaron took an unusual path to software and graduated with a degree in Social Work... Read More →


Friday October 29, 2021 10:30am - 11:30am MDT
_4
  • Modules/Libraries, Hybrid

10:30am MDT

Template Metaprogramming: Practical Application
This presentation is a tutorial covering multiple metaprogramming topics. It builds upon last year's "Template Metaprogramming: Type Traits." That talk walked you through template metaprogramming fundamentals by implementing some basic type traits. This tutorial demonstrates how to build upon these basic building blocks to solve real world problems.

For example, we will explore how to manage types as plain lists and associative collections. However, we will not just demonstrate how to sort a collection of types, but also some practical use cases where such techniques provide significant advantages, both in representation and runtime performance.

We will look some explicit real world examples where we trade an upfront compile time cost for faster runtime performance. We will also explore ways to measure the compile time costs so that we can make educated decisions about how to improve the compile time performance, and determine if that cost is worth the runtime gain.

Thus, the tutorial will walk through a number of metaprogramming techniques and tricks, but with the goal of applying them to solve several explicit real world problems, all the while being very aware of the compile time costs.

Speakers
avatar for Jody Hagins

Jody Hagins

MayStreet
Jody Hagins first compiled "C++" code in 1984, and wrote a specialized LisP editor using Zortech C++ for senior project in 1988. However, he didn't truly start programming in C++ until 1992, when he read The Greatest C++ Book Ever Written, "Advanced C++ Programming Styles and Idioms... Read More →


Friday October 29, 2021 10:30am - 11:30am MDT
_1
  • Templates/Concepts, Hybrid

10:30am MDT

The Unit Tests Strike Back: Testing the Hard Parts
Unit tests are now considered to be one of the foundational practices in modern software development. There are excellent talks and resources for getting started, and no end of good advice on how to write unit tests and what ideal tests should look like. Unit tests should be correct, complete, readable, resilient, and so forth.

But in real life, it's rarely possible to meet all these goals at the same time, and some situations make writing unit tests difficult or impossible. Existing or legacy code may not have been written with testing in mind; or "correct" results may not be well defined; or the code under test may rely on external services of hardware.

This talk reviews some of the most common "Plan B" techniques for tackling the more challenging unit testing situations. Topics covered will include

* White box testing: how to white box, when to white box test, and how to recover afterwards
* Abstract classes don't exist but we have to test them anyway.
* You can't test it without refactoring it, but you can't refactor without tests: cutting the legacy code gordian knot.
* It's probably right but we can't prove it, now what?
* It just failed: was it the code, the test, or some other part of reality?

Most techniques will first throw away some of the good advice we already have,

Speakers
avatar for Dave Steffen

Dave Steffen

Principal Software Engineer, SciTec Inc.
Dave Steffen completed his Ph.D. in theoretical physics at Colorado State University in 2003, and promptly changed course for a career in software engineering. He has worked primarily in defence and aerospace, and is currently a technical lead at SciTec Inc.'s Boulder office. For... Read More →


Friday October 29, 2021 10:30am - 11:30am MDT
_2
  • Testing/Error Handling, Hybrid

12:00pm MDT

Asserting Your Way to Faster Programs
Delayed broadcast

It is common practice to use defensive runtime checks, such as C-style assertions to help ensure program correctness, especially during testing. However, when thorough testing and beta releases bring confidence that production software is acceptably defect-free, redundant checks' value gradually decreases. With the value of redundant runtime checks diminishing, disabling them becomes more reasonable as doing so can often lead to measurable performance improvements. Although these assertions are disabled, they still carry valuable information which could assist the compiler's optimizer - namely, that for every defect-free program, the expression stated in the inactive assertion must hold. Most C and C++ compilers optimize code based on actively checked assertions; however, there is currently no standardized support for harnessing that very same information once redundant checks are disabled.

This talk explores the potential impact of the compiler assuming inactive C-style assertion predicates on runtime performance. We then share the result of our raw empirical research applied to real-world production software leveraging Bloomberg's BDE libraries, contrasting relevant metrics - such as compile times, run times, and binary sizes - across various categories of software libraries and applications. It will turn out that there are substantial opportunities to improve performance having relatively little impact on compile times. Moreover, if runtime performance is not improved, it is rarely, if ever, made measurably worse.

Speakers
avatar for Parsa Amini

Parsa Amini

Senior Software Engineer, APC Workforce Solutions


Friday October 29, 2021 12:00pm - 1:00pm MDT
`Online _2

12:00pm MDT

Evolving a Nice Trick
We will start with a "simple" problem, and put ourselves in a situation where only C++98 is available to us, with no other library that the C++ standard library. We will solve that problem with the tools at hand, and (hopefully) be satisfied with what we did in that context.

We will then fast-forward to C++11, and revisit the same problem, solving it better with the tools at hand. We will do the same again with C++14, then with C++17, and finally with C++20. At each step, we will examine the ways in which the language makes our solution better, more efficient, simpler.

This will lead us to reflect on what C++ is becoming, and where it is leading us. And hopefully, this will make us smile!

Speakers
avatar for Patrice Roy

Patrice Roy

Professor, Université de Sherbrooke
Patrice Roy has been playing with C++, either professionally, for pleasure or (most of the time) both for over 25 years. After a few years doing R&D and working on military flight simulators, he moved on to academics and has been teaching computer science since 1998. Since 2005, he’s... Read More →


Friday October 29, 2021 12:00pm - 1:00pm MDT
`Online _5

12:00pm MDT

C++20 on Xilinx FPGA with SYCL for Vitis
Delayed broadcast

FPGA (Field-Programmable Gate Arrays) are electronic devices which are
programmable with a configuration memory to implement arbitrary
electronic circuits. While they have been used for decades to
implement various adaptable electronic components, they got some
traction more recently to be used as generic programmable accelerators
more suitable for software programmers.

There are already HLS (High-Level Synthesis) tools to translate some
functions written with languages like C/C++ into equivalent electronic
circuits which can be called from programs running on processors to
accelerate parts of a global application, often in an energy-efficient
way. The current limitation is that there are 2 different programs:
the host part, running the main application, and the device part,
glued together with an interface library without any type-safety
guaranty.

Since the C++ standard does not address yet the concept of hardware
heterogeneity and remote memory, the Khronos Group organization has
developed SYCL, an open standard defining an executable DSL
(Domain-Specific Language) using pure modern C++ without any
extension. There are around 10 different SYCL implementations
targeting various devices allowing a single-source C++ application to
run on CPU and controlling various accelerators (CPU, GPU, DSP, AI...)
in a unified way by using different backends at the same time in a
single type-safe C++ program.

We present a SYCL implementation https://github.com/triSYCL/sycl
targeting Xilinx Alveo FPGA cards by merging 2 different open-source
implementations, Intel’s oneAPI DPC++ with some LLVM passes from
triSYCL.

For a C++ audience, this presentation gives a concrete example on why
the C++ standard does not describe detailed execution semantics
(stack, cache, registers...): because C++ can be executed on devices
which are not even processors.

While this presentation targets FPGA and a SYCL implementation from a
specific vendor, the content provides also:
- a generic introduction to FPGA which should be interesting outside
of Xilinx or even without the use of SYCL;
- how C++ can be translated in some equivalent electronic circuits;
- a generic introduction to SYCL which should be interesting for
people interested to know more about heterogeneous programming and
C++, beyond only FPGA.

Speakers
avatar for Ronan Keryell

Ronan Keryell

Principal Software Engineer, Xilinx
Ronan Keryell is principal software engineer at Xilinx Research Labs,where he works on high-level programming models for heterogeneoussystems, such as FPGA and CGRA, with the open-sourcehttps://github.com/triSYCL/triSYCL SYCL implementation.He is the specification editor of the SYCL... Read More →


Friday October 29, 2021 12:00pm - 1:00pm MDT
`Online _1

12:00pm MDT

Up to Code
Delayed broadcast

This session is part of the Software Design Track.

Many engineering disciplines require alterations or improvements of existing systems to be "up to code," whether that be the installation of railings on a staircase or upgrades to electrical work. In this talk, we'll apply this concept to Software Engineering and, in particular, C++-based systems. Using one real-world example, we'll cover best practices including: contracts, type-driven architecture, hierarchical design, and difficult testing scenarios as they apply to "old work."

While many of these topics are covered elsewhere, they are usually presented as if all code is being written from scratch. Application to an existing system is an entirely different matter. That is the subject of this talk.

Speakers
avatar for David Sankel

David Sankel

Software Engineering TL, Bloomberg
David Sankel is a Software Engineering Manager/TL at Bloomberg and an active member of the C++ Standardization Committee. His experience spans microservice architectures, CAD/CAM, computer graphics, visual programming languages, web applications, computer vision, and cryptography... Read More →


Friday October 29, 2021 12:00pm - 1:00pm MDT
`Online _4

12:00pm MDT

Finding Bugs Using Path-Sensitive Static Analysis
Delayed broadcast

Path-sensitive static analysis simulates the runtime behavior of the program code and uses the analysis state to evaluate which branches can be taken. It is an effective tool to find non-trivial bugs in code at compile time. While checks based on such analysis can take longer time to run, they have a sophisticated understanding of the code that helps them uncover semantic issues. First, I will discuss how can you turn these checks on and how to make sense of the warning messages they produce. Furthermore, I will do a deep dive on what makes path-sensitive analysis an effective tool to reason about code and how MSVC is leveraging this power to find bugs. In particular, I will explain how modern tools like constraint solvers can help increase the precision of the analysis. Throughout the talk, I will not only feature already released checks but also give a glimpse of the upcoming ones that we are actively working on. All the checks in the demo will be available for free in the community edition of Visual Studio and as security actions in GitHub.

Speakers
avatar for Gabor Horvath

Gabor Horvath

Software Engineer, Microsoft
Gabor started a Ph.D. in 2016. He is a contributor to research projects related to static analysis since 2012. He is a clang contributor, participated in Google Summer of Code twice as a student and many times as a mentor, interned for Apple, Microsoft and Google. He taught C++ and... Read More →


Friday October 29, 2021 12:00pm - 1:00pm MDT
`Online _3

1:30pm MDT

Combining Co-Routines and Functions into a Job System
Every game engine today should have a job system that harvests the power of the available CPU cores. Additionally, C++20 has introduced co-routines, which can schedule other tasks and suspend until these tasks have finished. Due to this suspension, the thread the co-routine is running on is free to serve other jobs.
Using co-routines in a job system results in easy to read code, local variables do not go out of scope until the co-routine returns.
However, there is a price to pay. Co-routines demand to use their own machinery for suspension and synchronizing them with other co-routines. Mixing in functions, lambdas or functors that do not have access to this machinery proves to be a demanding task, especially if they should interact and synchronize with co-routines.
This talk presents the Vienna Game Job System (VGJS), a C++20 based job system that seamlessly combines co-routines with functions, lamdas and functors. Co-routines can synchronize with functions, and vice-versa. This way, programmers can always choose which form of job is appropriate - either create a co-routine (which incurs some overhead due to allocations from the heap and the co-routine machinery), or run a function, a functor, etc., with generally better performance.
Additionally, VGJS allows to create tagged jobs to be run later, e.g., if a game in the game loop goes sequentially through phases, and specific jobs should be run in them. VGJS also allows for collecting performance trace files to be visualized in Chrome, and supports memory resources to be used for its allocations.
The talk will also show performance differences between co-routines, functions, and fibers (co-routines that do not return).

Speakers
avatar for Helmut Hlavacs

Helmut Hlavacs

Professor, University of Vienna
Dr. Helmut Hlavacs is Full Professor for Computer Science at the University of Vienna, Austria (ORCID: orcid.org/0000-0001-6837-674X). Dr. Hlavacs has a PhD in Mathematics (2001), and an MSc in Mathematics (1993). He also was awarded a Habilitation in the area of Applied Computer... Read More →


Friday October 29, 2021 1:30pm - 2:30pm MDT
`Online _1

1:30pm MDT

What You Can Learn from Being Too Cute: Why You Should Write Code That You Should Never Write
During the COVID-19 global pandemic, as we all searched for ways to stay connected to the C++ community, I innocently started posting short, 25-line or less C++ snippets of counterintuitive C++ code that I called my "Cute C++ trick of the day." I was floored by the amount of attention these tweets received, with some being viewed more than 30,000 times and liked or retweeted hundreds of times. I received repeated requests to collect these tricks into a library or talk, and this is that talk.

In this presentation, I will dissect a few of my most popular "Cute C++ tricks" to a level of detail not possible on social media platforms like Twitter. I'll talk about how and why these tricks work the way they do, talk about the dark corners of C++ they touch upon, and talk about what you should actually do if you need to produce the same effect in production code. While not targeted at beginners, these tricks span the gauntlet from features that most intermediate programmers are aware of (but never thought to use in a particular way) to dark corners of the language that many of my C++ committee colleagues were surprised to learn about. Throughout it all runs a common thread: learning how to exploit your own curiosity to expand your toolbox, gain a better grasp of the fundamentals of C++, and ultimately, become a better programmer.

Speakers
avatar for Daisy Hollman

Daisy Hollman

Google
Dr. Daisy S. Hollman has been a member of the C++ standards committee since 2016, where she has made contributions to a wide range of library and language features, including proposals related to executors, atomics, generic programming, futures, and multidimensional arrays. Since... Read More →


Friday October 29, 2021 1:30pm - 2:30pm MDT
_3
  • Education/Coaching, Hybrid

1:30pm MDT

Large Performance Gains by Data Orientation Design Principles Made Practical Through Generic Programming Components
This session is part of the Software Design Track.

C++ conferences have had presentations showing the important performance benefits of data-oriented design principles; however, the principles seem to require lots of "manual" effort and "code uglification"; these make the principles less practical, and there haven't been clear recommendations about how to deal with runtime-polymorphic types.

In this talk we will recapitulate on data orientation principles and their benefits showing their application through production-strength Generic Programming components made to support them.

Specific examples include:
1. Structures of arrays instead of arrays of complex structures (a.k.a. "scattering")
2. Support for data oriented designs for runtime-polymorphism without inheritance+virtual (the equivalent of using std::variant or std::function, but generalized as allowed by the Zoo type-erasure framework)
----1. Hybrid buffers: the equivalent of the virtual table pointer is scattered out of the objects solving the "Goldilocks problem" of how big the local buffer should be, objects occupy the available space optimally
----2. Easy (de)serialization through very easy relocatability
----3. Voiding the need for pointers in favor of indices into arrays

Speakers
avatar for Eduardo Madrid

Eduardo Madrid

Tech Lead, Snap, Inc.
Eduardo has been working for many years on financial technologies, automated trading in particular, and other areas where performance challenges can be solved in C++. He contributes to open source projects and teaches advanced courses on Software Engineering with emphasis in Generic... Read More →


Friday October 29, 2021 1:30pm - 2:30pm MDT
_1

1:30pm MDT

Building an Extensible Type Serialization System Using Partial Template Specialization
As software engineers, we all prefer using performant libraries with user-friendly interfaces. But designing a template-free interface can be challenging for some C++ libraries, like serialization libraries, that need to support generic values but handle them differently based on their type.

This talk shows how we can leverage partial template specialization to implement a generic user-friendly API that can be extended to support custom user-defined types. As a proof of concept, I will showcase an extensible type serialization system, that is built on top of the FlatBuffers serialization library, and enables users to register custom serializers for their user-defined types to support their automatic serialization at runtime.

Template programming is generally known to be associated with long type names and indecipherable compile-time errors. This presentation includes examples and recommendations that help C++ engineers to create more expressive and easy-to-understand implementations. Finally, the talk describes how C++20 features like Concepts can further simplify those implementations and facilitate designing elegant user-friendly programming interfaces.

Speakers
avatar for Pejman Ghorbanzade

Pejman Ghorbanzade

Founder, CEO, Touca
Pejman Ghorbanzade is the Founder and CEO of Touca, helping software engineers understand the true impact of their code changes on the behavior and performance of their software. Before Touca, Pejman was a senior software engineer at Canon Medical Informatics building software for... Read More →


Friday October 29, 2021 1:30pm - 2:30pm MDT
_2

2:45pm MDT

Back to Basics: Algorithmic Complexity
When you're designing a program, how do you choose appropriate data structures and algorithms? How do you know when the proposed design is likely to be "too slow," without benchmarking the finished code? How can you avoid introducing inefficiencies into the code as you write it, without burning yourself out on "premature optimization"? Why do people always say the inner loop is the most important? How is it that the 10x speedup you committed yesterday was completely wiped out by a mere 2x increase in site traffic today?

In this session, we'll explore the notion of algorithmic complexity, especially as it relates to the data structures and algorithms provided by the C++ standard library, such as std::sort, std::find, and std::binary_search. With just a bit of informal math, we'll define "big-O notation" and demonstrate the differences between complexity classes such as O(1), O(lg n), and O(n). We'll show how to determine the big-O complexity of your own functions by counting loops (including the loops hidden inside STL algorithms and overloaded operators). Then we'll show how we can use limits — or a bit of geometric intuition — to determine that certain algorithms run in linear time despite their complex inner structure, and explain what we mean when we say that vector::push_back runs in "amortized constant time." Finally, we'll discuss ways to trade off space against time, or setup time against query time, and discuss some practical considerations such as constant factors and physical implementation limits.

Speakers
avatar for Amir Kirsh

Amir Kirsh

Teacher, Dev Advocate, Academic College of Tel-Aviv-Yafo and Incredibuild
Amir Kirsh is both a Lecturer and a practitioner. Teaching at the Academic College of Tel-Aviv-Yaffo and at Tel-Aviv University while keeping hands on, mainly on C++, as a Dev Advocate at Incredibuild and previously as the Chief Programmer at Comverse. Amir is also one of the organizers... Read More →
avatar for Adam Segoli Schubert

Adam Segoli Schubert

Incredibuild
Adam is a software consultant, programming instructor, and part of the Dev Advocate office at Incredibuild. He also collaborates on projects which focus on decentralization, parallelization, and blockchain, with the objective of advancing transparency, freely available distributed... Read More →


Friday October 29, 2021 2:45pm - 3:45pm MDT
_3

2:45pm MDT

UB, ODR, ADL, ICE, SFINAE, IFNDR... WTF?
C++ programmers love to create and throw around cryptic acronyms. If you've ever wondered what some of them mean, but were afraid to ask, then this talk is for you. In this talk, we'll provide definitions for a number of the most common C++ acronyms as well as a definitive guide to their pronunciation. Each acronym's definition will be accompanied by an explanation of the underlying principles it denotes, how it relates to other important C++ concepts, and supporting code examples.

So join us as we ask the question "UB || !UB", and reveal the answers to many C++ acronymic mysteries.

Speakers
avatar for Bob Steagall

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing


Friday October 29, 2021 2:45pm - 3:45pm MDT
_2

2:45pm MDT

Dynamically Loaded Libraries Outside the Standard
You must be aware of dynamically-link libraries, but have you tried using them through LoadLibrary on Windows or dlopen on UNIX?

A library may be dynamically-linked, but not designed for being loaded at runtime. Likewise, we may load a library at runtime, but we may not need to unload it before the program exits. In other words, a library can be "dynamic" at different levels. Those dynamically loaded and dynamically unloaded are often more special than the ones that do not. However, the dark side is that the more dynamic a library is, the further they are apart from the C++ standard.

This talk will cover a few typical use cases of dynamically loaded libraries, such as delay loading, plugin system, live update. We will discuss their status quo on different platforms, tools for diagnosis, common practices, problems, and what standardization can do to them. These should inspire you about what to do when designing your next architecture that may involve dynamically loaded code.

Speakers
avatar for Zhihao Yuan

Zhihao Yuan

R&D Software Engineer, Broadcom Inc.
Zhihao Yuan is an R&D Software Engineer at Symantec, a division of Broadcom. He participated in standardizing designated initializers and improved narrowing conversions in C++20 but ends up almost exclusively programmed in Python last year and only recently picked up C++14 again... Read More →


Friday October 29, 2021 2:45pm - 3:45pm MDT
`Online _1

2:45pm MDT

C++23 Standard Library Preview
Despite the pandemic the C++ committee is continuing to work towards C++23. This survey presentation provides students with a broad overview of the changes and new facilities in the C++23 standard library.

The changes include a major expansion of ranges - including new view types and algorithms. For i/o there's a number of extensions to ~std::format~ facilities as well as a new i/o stream type, ~span_stream~ that allows for user supplied buffers in for i/o. In containers, we see the addition of ~flat_map~ and ~flat_set~. ~std::stacktrace~ provides a badly needed debugging capability. More ~constexpr~ library facilities include ~type_info~, ~std::variant~ and ~std::optional~. For interfaces with C there are changes for atomics and ~out_ptr~ to help with resource management. For functional programming monadic interfaces on ~optional~ are provided.

Fast paced, and chock full of example codes, this tutorial will focus on practical application of the new c++23 standard library facilities. Some of these topics will be covered very briefly, but with pointers in the slides for further study. The tutorial is up to date with the latest working draft will include pointers to current implementations as well as the state of compiler support.

Speakers
avatar for Jeff Garland

Jeff Garland

CrystalClear Software
Jeff Garland has worked on many large-scale, distributed software projects over the past 25+ years. The systems span many different domains including telephone switching, industrial process control, satellite ground control, ip-based communications, and financial systems. He has written... Read More →


Friday October 29, 2021 2:45pm - 3:45pm MDT
_1
  • Templates/Concepts, Hybrid

4:15pm MDT

Warning: std::find() is Broken!
We often take it for granted that calling one of the Standard algorithms will do something meaningful. For example, when invoking `position = find(first, last, value)` we expect that if an element equal to value is contained in the range `[first, last)` then `position` will point to the first such element; otherwise, position will equal `last`. But how do we know `find `will perform this operation? This talk explores requirements, guarantees, and domains, and we'll discover that maybe `find` doesn't.

Speakers
avatar for Sean Parent

Sean Parent

Sr. Principal Scientist, STLab, Adobe
Sean Parent is a senior principal scientist and software architect for Adobe’s Software Technology Lab (v2). Sean has been at Adobe since 1993 when he joined as a senior engineer working on Photoshop and later managed Adobe’s Software Technology Lab. In 2009 Sean spent a year... Read More →


Friday October 29, 2021 4:15pm - 6:00pm MDT
Aurora C/D
 
  • Timezone
  • Filter By Date CppCon 2021 Oct 24 -29, 2021
  • Filter By Venue online
  • Filter By Type
  • • Algorithms/Functional
  • • Async/Concurrency/Parallelism
  • • C++20/Future of C++
  • • Code Design
  • • const/Units/Time
  • • Education/Coaching
  • • Embedded
  • • GPU/Graphics
  • • Modules/Libraries
  • • Real-time/Data Science
  • • Software Design
  • • Templates/Concepts
  • • Testing/Error Handling
  • • Tooling/Debugging
  • • Type Design
  • Social
  • Access