CppCon 2020: Full Schedule

09:00 MDT

More Concurrent Thinking in C++: Beyond the Basics

More Concurrent Thinking in C++: Beyond the Basics is a three-day online training course taught by Anthony Williams of Just Software Solutions. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Students are expected to have a good knowledge of C++, and familiarity with the C++11 standard thread library.
Students will require a laptop with one of the following compilers to handle the example code:

Microsoft Visual Studio 2017 or later.
gcc 7 or later
clang 5 or later

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Anthony Williams

Just Software Solutions Ltd

Anthony Williams is the author of C++ Concurrency in Action.

Wednesday September 9, 2020 09:00 - 14:00 MDT
Classroom-Williams

Class

09:00 MDT

Accelerated TDD: For More Productive C++

Accelerated TDD: For More Productive C++ is a three-day online training course with programming exercises taught by Phil Nash. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Be comfortable with the basics of C++. Being an expert not required
A laptop with a reasonably modern OS.
A compiler capable of running C++11 (ideally gcc, clang or VC++) – don’t worry if it’s not what you use in your day job.
A development environment you’re comfortable with. I can provide short term CLion licenses if you’d like (please let me know beforehand if possible)
An open mind and motivation to find better ways of doing things.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Phil Nash

Developer Advocate, Sonar

Phil is the original author of the C++ test framework, Catch2, and composable command line parser, Clara. As Developer Advocate at Sonar he's involved with SonarQube, SonarLint and SonarCloud, particularly in the context of C++. He's also a member of the ISO C++ standards committee... Read More →

Wednesday September 9, 2020 09:00 - 15:00 MDT
Classroom-Nash

Class

09:00 MDT

Advanced and Modern C++ Programming: The Tricky Parts

Advanced and Modern C++ Programming: The Tricky Parts is a three-day online training course with programming examples taught by Nicolai Josuttis. It has been one of our most popular classes. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Students are expected to have a basic knowledge of C++ including C++11.
Students are not required to bring any laptop. We will go through code examples together with the laptop of the presenter.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Nicolai Josuttis

IT Communication

Nicolai Josuttis (www.josuttis.com) is well-known in the community for his authoritative books and talks. For more than 20 years he has been a member of the C++ Standard Committee. He is the author of several worldwide best-sellers, including:- C++20: The Complete Guide- C++17: The... Read More →

Wednesday September 9, 2020 09:00 - 15:00 MDT
Classroom-Josuttis

Class

09:00 MDT

Managing Memory

Managing Memory is a two-day training course with programming examples taught by Patrice Roy. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

The target audience is intermediate-level developers who:

Are familiar with modern C++, meaning C++11 and more in this case, without necessarily being experts
Seek to develop a deeper understanding of memory management concepts and mechanisms made available to them in C++
Want the programs they write to be faster, safer and more correct

Junior developers can benefit from this course if they are willing to explore this part of the C++ language. Developers coming to C++ from another language might find the course surprisingly instructive, as they might gain a better understanding of the workings of other languages too. More advanced developers might also enjoy this course if looking for a greater familiarity with modern C++ and its usefulness in their daily tasks.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

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 30 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 →

Wednesday September 9, 2020 09:00 - 15:00 MDT
Classroom-Roy

Class

09:00 MDT

Modern C++ Design Patterns

Modern C++ Design Patterns is a three-day training course with programming exercises taught by Klaus Iglberger. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Course participants should have a solid base knowledge of C++ and at least one to two years of experience with the language. Additionally, the course is interesting for you if several of the following statements apply to you:

You are not aware of the impact of dependencies on code quality
You don’t know the SOLID principles or don’t consider them for your work
You believe object-oriented programming is about inheritance relationships
You consider moving functionality into classes the preferred design choice
You don’t comprehend the arcane rules when the compiler is generating the special member functions for you
You don’t know the details of move semantics
You want to reevaluate classic design patterns
You want to get an impression on modern C++ design patterns
You wonder about type erasure and expression templates or their value

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

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 September 9, 2020 09:00 - 15:00 MDT
Classroom-Iglberger

Class

09:00 MDT

Modern C++: When Efficiency Matters

Modern C++: When Efficiency Matters is a three-day online training course with programming exercises taught by Andreas Fertig. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Students are expected to have a basic knowledge of C++ (at least 98 with a basic understanding of C++11).

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

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 →

Wednesday September 9, 2020 09:00 - 15:00 MDT
Classroom-Fertig

Class

09:00 MDT

System Architecture and Design Using Modern C++

System Architecture and Design Using Modern C++ is a three-day online training course with programming examples taught by Charley Bay. It is offered online from 11AM to 5PM Eastern Time (EDT), Wednesday September 9th through Friday September 11th, 2020 (before the conference).

Course participants should:

Have solid knowledge of C++ and familiarity with common C++ idioms and code patterns
Be able to deeply explore priorities and constraints for at least one industry domain
Be prepared to discuss, analyze, and reflect upon past project-level successes and failures (yours or those raised by other participants)
Be excited to share with and learn from real-world experts facing similar challenges in different domains, but which expose solutions and insight into your domain

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

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 →

Wednesday September 9, 2020 09:00 - 15:00 MDT
Classroom-Bay

Class

09:00 MDT

More Concurrent Thinking in C++: Beyond the Basics

Microsoft Visual Studio 2017 or later.
gcc 7 or later
clang 5 or later

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Anthony Williams

Just Software Solutions Ltd

Anthony Williams is the author of C++ Concurrency in Action.

Thursday September 10, 2020 09:00 - 14:00 MDT
Classroom-Williams

Class

09:00 MDT

Accelerated TDD: For More Productive C++

Be comfortable with the basics of C++. Being an expert not required
A laptop with a reasonably modern OS.
A compiler capable of running C++11 (ideally gcc, clang or VC++) – don’t worry if it’s not what you use in your day job.
A development environment you’re comfortable with. I can provide short term CLion licenses if you’d like (please let me know beforehand if possible)
An open mind and motivation to find better ways of doing things.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Phil Nash

Developer Advocate, Sonar

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Nash

Class

09:00 MDT

Advanced and Modern C++ Programming: The Tricky Parts

Speakers

Nicolai Josuttis

IT Communication

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Josuttis

Class

09:00 MDT

Managing Memory

Are familiar with modern C++, meaning C++11 and more in this case, without necessarily being experts
Seek to develop a deeper understanding of memory management concepts and mechanisms made available to them in C++
Want the programs they write to be faster, safer and more correct

Speakers

Patrice Roy

Professor, Université de Sherbrooke

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Roy

Class

09:00 MDT

Modern C++ Design Patterns

You are not aware of the impact of dependencies on code quality
You don’t know the SOLID principles or don’t consider them for your work
You believe object-oriented programming is about inheritance relationships
You consider moving functionality into classes the preferred design choice
You don’t comprehend the arcane rules when the compiler is generating the special member functions for you
You don’t know the details of move semantics
You want to reevaluate classic design patterns
You want to get an impression on modern C++ design patterns
You wonder about type erasure and expression templates or their value

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Iglberger

Class

09:00 MDT

Modern C++: When Efficiency Matters

Speakers

Andreas Fertig

Unique Code

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Fertig

Class

09:00 MDT

System Architecture and Design Using Modern C++

Have solid knowledge of C++ and familiarity with common C++ idioms and code patterns
Be able to deeply explore priorities and constraints for at least one industry domain
Be prepared to discuss, analyze, and reflect upon past project-level successes and failures (yours or those raised by other participants)
Be excited to share with and learn from real-world experts facing similar challenges in different domains, but which expose solutions and insight into your domain

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Charley Bay

Thursday September 10, 2020 09:00 - 15:00 MDT
Classroom-Bay

Class

09:00 MDT

More Concurrent Thinking in C++: Beyond the Basics

Microsoft Visual Studio 2017 or later.
gcc 7 or later
clang 5 or later

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Anthony Williams

Just Software Solutions Ltd

Anthony Williams is the author of C++ Concurrency in Action.

Friday September 11, 2020 09:00 - 14:00 MDT
Classroom-Williams

Class

09:00 MDT

Accelerated TDD: For More Productive C++

Be comfortable with the basics of C++. Being an expert not required
A laptop with a reasonably modern OS.
A compiler capable of running C++11 (ideally gcc, clang or VC++) – don’t worry if it’s not what you use in your day job.
A development environment you’re comfortable with. I can provide short term CLion licenses if you’d like (please let me know beforehand if possible)
An open mind and motivation to find better ways of doing things.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Phil Nash

Developer Advocate, Sonar

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Nash

Class

09:00 MDT

Advanced and Modern C++ Programming: The Tricky Parts

Speakers

Nicolai Josuttis

IT Communication

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Josuttis

Class

09:00 MDT

Managing Memory

Are familiar with modern C++, meaning C++11 and more in this case, without necessarily being experts
Seek to develop a deeper understanding of memory management concepts and mechanisms made available to them in C++
Want the programs they write to be faster, safer and more correct

Speakers

Patrice Roy

Professor, Université de Sherbrooke

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Roy

Class

09:00 MDT

Modern C++ Design Patterns

You are not aware of the impact of dependencies on code quality
You don’t know the SOLID principles or don’t consider them for your work
You believe object-oriented programming is about inheritance relationships
You consider moving functionality into classes the preferred design choice
You don’t comprehend the arcane rules when the compiler is generating the special member functions for you
You don’t know the details of move semantics
You want to reevaluate classic design patterns
You want to get an impression on modern C++ design patterns
You wonder about type erasure and expression templates or their value

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Iglberger

Class

09:00 MDT

Modern C++: When Efficiency Matters

Speakers

Andreas Fertig

Unique Code

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Fertig

Class

09:00 MDT

System Architecture and Design Using Modern C++

Have solid knowledge of C++ and familiarity with common C++ idioms and code patterns
Be able to deeply explore priorities and constraints for at least one industry domain
Be prepared to discuss, analyze, and reflect upon past project-level successes and failures (yours or those raised by other participants)
Be excited to share with and learn from real-world experts facing similar challenges in different domains, but which expose solutions and insight into your domain

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Charley Bay

Friday September 11, 2020 09:00 - 15:00 MDT
Classroom-Bay

Class

09:00 MDT

Open House

Please join us from 12:00 to 14:30 for our Welcome Reception.

If that time isn't convenient, then please drop by anytime during the Open House hours to try out the Remo platform and visit all of the conference rooms.

Sunday September 13, 2020 09:00 - 12:00 MDT
Hallway Track

Business

12:00 MDT

Welcome Reception

The Welcome Reception is an opportunity for both socializing and verifying that you're properly checked in and ready to attend sessions.

CppCon 2020 attendees, including instructors, presenters, exhibitors, sponsors, PC members, organizers, volunteers, and many of your friends, latent friends, and colleagues in the C++ community will be on hand to chat and get to know you or get to know you better.

You'll need to set up your Remo account and it is better to get that out of the way and deal with any issues early rather than when a session you want to see is starting. (We strongly recommend that you arrive early at all presentation sessions, not to get a good seat–they are all good seats online–but for the opportunity of chatting with other attendees before the session starts.)

Please take a "tour" of the conference rooms by visiting each track to verify that you have access to that track without any issues.

The theme for this year's reception is My Favorite Chocolate. Since we, obviously, won't be serving food and beverages at an online reception, we've decided that this event is BYOChocolate. Have some of your favorite chocolate with you to tantalize us with. It is show-and-tell time for your favorite chocolate and you don't even have to share any!

If you don't care for chocolate, you can just lord it over the rest of us that you don't have this silly addiction and have some other guilty pleasure one hand to show us.

In addition to socializing and exploring the online venue, we are planing some surprises that you might find amusing.

Sunday September 13, 2020 12:00 - 14:30 MDT
Hallway Track

Social

08:45 MDT

The Beauty and Power of "Primitive" C++

Often, we focus on novel, clever, and advanced features of C++. To contrast, here I look at addressing relatively simple problems in relatively simple ways under severe constraints of performance, ease of use, and reliability. My main example is to read and write typed objects from and to a byte buffer. This is of course something we do a lot and in a bewildering variety of ways. Any object that needs to be stored or transmitted to another computer must go through such a process. However, the constrains on such reading and writing varies immensely based on the kind of data to be moved around, the performance and reliability requirements, the hardware available, and history. Many trade-offs are possible, and many different interfaces. That makes this an interesting design exercise.

This is an exploration of a design space close to the hardware and of the use of C++ in that space, rather than a standards proposal or the presentation of a mature tool chain. And, no, by “primitive”, I don’t mean “old-fashioned, C-like” code; some of the general techniques are old, but some of the code requires C++17 and much could be done better given features we are unlikely to get even in C++23.

Speakers

Bjarne Stroustrup

Professor, Columbia University

Bjarne Stroustrup is the designer and original implementer of C++ as well as the author of The C++ Programming Language (4th Edition) and A Tour of C++ (3rd edition), Programming: Principles and Practice using C++ (2nd Edition), and many popular and academic publications. He is a... Read More →

Monday September 14, 2020 08:45 - 10:00 MDT
all_of()

• Design

Level Intermediate, Advanced
Tags serialization

08:45 MDT

[Overflow] The Beauty and Power of "Primitive" C++

If the all_of() track is full, then join us in generate_n() as the overflow room.

Often, we focus on novel, clever, and advanced features of C++. To contrast, here I look at addressing relatively simple problems in relatively simple ways under severe constraints of performance, ease of use, and reliability. My main example is to read and write typed objects from and to a byte buffer. This is of course something we do a lot and in a bewildering variety of ways. Any object that needs to be stored or transmitted to another computer must go through such a process. However, the constrains on such reading and writing varies immensely based on the kind of data to be moved around, the performance and reliability requirements, the hardware available, and history. Many trade-offs are possible, and many different interfaces. That makes this an interesting design exercise.

This is an exploration of a design space close to the hardware and of the use of C++ in that space, rather than a standards proposal or the presentation of a mature tool chain. And, no, by “primitive”, I don’t mean “old-fashioned, C-like” code; some of the general techniques are old, but some of the code requires C++17 and much could be done better given features we are unlikely to get even in C++23.

Speakers

Bjarne Stroustrup

Professor, Columbia University

Monday September 14, 2020 08:45 - 10:00 MDT
generate_n()

• Design

Tags serialization

10:30 MDT

Back to Basics: The Abstract Machine

The compilation of every C++ program is controlled by an obscure device that remains mysterious, or even unknown, to many programmers: the C++ abstract machine. When a program is compiled, the abstract machine constructs and expresses the compiler's "mental model" of that program. It is responsible for enforcing all of the rules governing C++ programs, and ensuring that programs execute properly when those rules are observed. What's more, the abstract machine is often quite different from the physical machine, and the difference between the two can be confusing at first.

The goal of this talk is to provide an introduction to the C++ abstract machine and describe its relationship to the C++ language, how it influences the way we think about coding in C++, and its relationship to the underlying hardware upon which C++ programs execute. If you were previously unaware of the abstract machine, or have only a vague notion of what it is, then this talk is for you. Attendees will leave this session with a basic understanding of what the abstract machine is, its conception of memory, its relationship to hardware, undefined/unspecified/implementation-defined/observable behavior, and the "as-if" rule.

Speakers

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Monday September 14, 2020 10:30 - 11:30 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, abstract machine

10:30 MDT

A New Decade of Visual Studio: C++20, Open STL, and More

As C++20 brings new features for C++ programmers at all levels of experience, so does our last year of work on Visual Studio and MSVC. New versions of the IDE have brought new productivity features and experience improvements for all developers, no matter what platforms they are targeting. Our open source standard library has seen contributions from across the C++ ecosystem, improving in conformance and performance. We've been hard at work on key C++20 compiler features like Concepts. We're also working on bold new ways of working on C++ projects with cloud environments.

Come along to hear about all of these as well as announcements about the future of our tools.

Speakers

Marian Luparu

Group Product Manager, C++ Team, Microsoft

Ask me about @Code @VisualStudio and #Vcpkg

Sy Brand

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 →

Monday September 14, 2020 10:30 - 11:30 MDT
count_if()

• Compilers/Tooling

Level Beginner, Intermediate, Advanced, Expert
Tags IDE, Microsoft Visual C++, Visual Studio, compiling, linking, tooling

10:30 MDT

Breaking Dependencies: The SOLID Principles

SOLID is an abbreviation for five of the most important software design principles:

- (S)ingle Responsibility Principle
- (O)pen-Closed Principle
- (L)iskov Substitution Principle
- (I)nterface Segregation Principle
- (D)ependency Inversion Principle

For almost two decades, these principles have proven to be a valuable set of guidelines to cope with software dependencies. Although initially introduced as guidelines for object-oriented programming, they have become a universal set of guidelines that can be used equally well for procedural, functional or generic programming. In this talk I'll recap the SOLID principles and explain why they form such a valuable set of universal design guidelines. Also, I'll go into detail about several common misconceptions.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Monday September 14, 2020 10:30 - 11:30 MDT
generate_n()

• Design

Level Beginner, Intermediate
Tags SOLID, quality, software design

10:30 MDT

Memory-Mapped Devices as Objects

Most, if not all, modern CPUs communicate with external devices via memory-mapped device registers. A memory-mapped register is circuitry that connects to a CPU’s bus structure and responds to bus signals almost as if it were ordinary memory. Almost, but not quite.

C++ programs can use C features such as pointers and casts to access memory-mapped registers. This is still widespread practice. However, traditional C techniques tend to treat memory-mapped registers more as raw storage than as objects with constrained behaviors. C idioms for accessing memory-mapped devices leave too many opportunities for programming errors and late nights with a debugger.

This session explains various C++ techniques for placing objects into memory-mapped locations and for guaranteeing proper initialization and destruction. It shows how you can use base classes and templates to capture commonalities among different devices that use similar register layouts. By applying these techniques, you’ll be able to package memory-mapped devices as lightweight class objects that are easy to use correctly and hard to use incorrectly.

Speakers

Dan Saks

President, Saks & Associates

Dan Saks is the president of Saks & Associates, which offers training and consulting in C and C++ and their use in developing embedded systems. Dan used to write the “Programming Pointers” column for embedded.com online. He has also written columns for numerous print publications... Read More →

Monday September 14, 2020 10:30 - 11:30 MDT
Embedded

• Embedded

Level Intermediate
Tags alignment, class-specific new, embedded, extern declarations, memory-mapped registers, object placement, padding, placement new, reinterpret_cast, standard layout classes

10:30 MDT

Template Metaprogramming: Type Traits (part 1 of 2)

Template metaprogramming is a vast subject, but there are a small number of basic fundamental idioms that are used over and over. Mastery of these idioms will help in reading, writing, and using modern C++ code. The type traits that come as part of the standard library are incredibly useful, but at times can be thought of as some form of dark magic.

In this tutorial, we will explore some of the fundamental idioms of template metaprogramming by implementing a good portion of the type traits from the standard library. In so doing, attendees will come away with a solid understanding of how to apply the fundamental template metaprogramming idioms to solve problems including, but not limited to, standard type traits.

Speakers

Jody Hagins

MayStreet

Jody Hagins has been using C++ for the better part of four decades. He remains amazed at how much he does not know after all those years. He has spent most of that time designing and building systems in C++, for use in the high frequency trading space.

Monday September 14, 2020 10:30 - 11:30 MDT
destroy_n()

• Metaprogramming/Reflection

Level Beginner, Intermediate
Tags generic programming, metaprogramming, templates, type traits

12:00 MDT

Back to Basics: The Structure of a Program

What's the difference between a declaration and a definition? What is a translation unit, and how is it related to the source code that you write? How would you describe the one-definition rule? What is name-mangling? If the answers to these questions are a little hazy for you, or if you would like a refresher on the fundamentals of how source code is converted into executable programs, then this talk is for you.

In this session, we'll cover the process of compiling and linking C++ source code, describing and discussing the key concepts involved in that process along the way. Attendees will leave with a basic understanding of such fundamental concepts as translation units, declarations, definitions, the one-definition rule, name-mangling, ABIs, and how the compiler and linker conspire to convert human-readable source code into binary code that executes on hardware.

Speakers

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Monday September 14, 2020 12:00 - 13:00 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, compiling, linking, one definition rule, program structure

12:00 MDT

Collaborative C++ Development with Visual Studio Code

Do you contribute to open-source projects or share projects with coworkers and classmates? In this talk, you’ll learn how optimize Visual Studio Code for collaborative, cross-platform C++ development. This talk will cover recommended tools and extensions for collaborative, cross-platform development, diving deep into the C++ extension, the CMake Tools extension, the GitHub Pull Requests and Issues extension, and the Live Share extension.

During this session, we’ll build and submit a PR to an open-source CMake project in Visual Studio Code, interacting with GitHub pull requests and issues directly in the editor. You’ll also learn how to create Live Share sessions for an nontraditional pair programming experience, where you can work together while retaining personal editor preferences as well as having your own cursor. Throughout the demo, we’ll showcase Visual Studio Code’s rich, productive editing and debugging features for C++ development.

Speakers

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 →

Monday September 14, 2020 12:00 - 13:00 MDT
count_if()

• Compilers/Tooling

Level Beginner, Intermediate, Advanced
Tags Linux, Mac, Microsoft Visual C++, VS Code, Visual Studio Code, collaboration, cross-platform, open source, remote

12:00 MDT

The Future of C++ Parallel and Concurrency Safety Guidelines

As we move into a world of multicore, manycore, and heterogeneous cores, we foresee a need for safety guidelines and standards for these domains. Yet most safety guidelines only cover sequential programming.

There has never really been any guidelines for safe parallel/concurrency C++. This is not an oversight. The challenge of creating safety standards and guidelines has been so involved that just focusing on the rules for sequential programming has consumed most group's time, especially as they track a rapidly changing C++ Standard. There have been only a few concurrency related-rules in HIC++, SEI CERT C++, C++CG, WG23, Khronos Safety forum(SCAF), as well as several European H2020 projects, though none of them are specifically for static analyzers, with a mixture of meta-guidelines and specific guidance. However, they have formed a useful starting point Over the last 2 years, I have been working with experts from various Safety Groups including WG23, SG1, and MISRA to develop a set of guidelines for safe concurrency and have developed nearly 100 rules which I plan to put into C++CG, and MISRA C++. We have needed this collaboration among all the groups because not everyone who is a concurrency expert is a safety experts, and vice versa. Many more people are experts in neither domain, and need to still understand how to program parallelism and concurrency safely.

In this talk, I will show some of the developing rules, none of it will be in its final form obviously, but it will develop the argument on the rationale on these rules. Some are uncheckable and are more meta-rules that are appropriate for C++ CG, such as don't use Mutex. But if you do, there are a bunch of more specific rules that you need to be aware of (i.e.e do not destroy a locked mutex while some are very specific). Others are checkable and are appropriate for a safety standard like MISRA C++ or a future Safe version of SYCL or any other heterogeneous framework. As none of these rules are in any guideline or standard as yet, there will be an opportunity for you to participate and help shape the future of safety in parallelism and concurrency.

Speakers

Michael Wong

Distinguished Engineer, VP, Codeplay

Michael Wong is Distinguished Engineer/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... Read More →

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 →

Monday September 14, 2020 12:00 - 13:00 MDT
Embedded

• Concurrent/Async/Parallel

Level Beginner, Intermediate, Advanced
Tags MISRA, concurrency, embedded, guidelines, type safety

12:00 MDT

Calling Functions: A Tutorial

How is a function call resolved? How does the compiler find the right function and how does the compiler choose from a set of available functions? This talk will give an overview of the individual steps taken during the resolution of a function call. It will primarily focus on the different kinds of name lookup, argument deduction, and on overload resolution. Attendees will gain insight into the mechanics of (un-)qualified lookup, argument dependent lookup, two-phase lookup, name hiding, SFINAE, (viable) candiate functions, and ambiguous function calls. They will leave the talk with a much better understanding of the (sometimes surprising) details of function calls.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Monday September 14, 2020 12:00 - 13:00 MDT
generate_n()

• Deep Magic

Level Beginner, Intermediate
Tags access labels, name lookup, overload resolution, template argument deduction, templates

12:00 MDT

Template Metaprogramming: Type Traits (part 2 of 2)

Speakers

Jody Hagins

MayStreet

Monday September 14, 2020 12:00 - 13:00 MDT
destroy_n()

• Metaprogramming/Reflection

Level Beginner, Intermediate
Tags generic programming, metaprogramming, templates, type traits

13:30 MDT

The Hidden Secrets of Move Semantics

Move semantics, introduced with C++11, has become a hallmark of modern C++ programming. However, it also complicates the language in many ways. Even after several years of support, experienced programmers struggle with all the details of move semantics. And style guides still recommend different consequences for programming even of trivial classes. And in the C++ community we still discuss semantic details.

While I took the time to write up all the facts and details in my new book "C++ Move Semantics - The Complete Guide (cppmove.com), I learned a lot I wasn't aware of. Note that the final book will have 200 pages.
This talk is about the most surpising facts, even experts sometimes don't know.
Some hidden secrets so that you understand C++ a bit better.

Speakers

Nicolai Josuttis

IT Communication

Monday September 14, 2020 13:30 - 14:30 MDT
destroy_n()

• Deep Magic

Level Intermediate, Advanced, Expert
Tags move semantics, universal references

13:30 MDT

Making Iterators, Views and Containers Easier to Write with Boost.STLInterfaces

Writing standard-compliant iterators is surprisingly easy to get wrong. Standard containers are tedious to write, because they have such large interfaces, involving lots of similar operations. For many years, Boost.Iterator's iterator_facade and iterator_adaptor were the state of the art for automating the creation of iterators with minimal effort. However, that library has not kept up with the evolution of C++, particularly with regard to constexpr and noexcept.

Boost.STLInterfaces is a newly-accepted Boost library that solves these problems for authors of iterators and sequence containers. It does this using the same approach as C++20's std::ranges::view_interface. The view_interface template is a CRTP base that implements all the possible view member functions when inherited by a derived type containing just begin() and end(). This pattern allows the user to use Boost.STLInterfaces to write correct iterators, views, and/or sequence containers, requiring surprisingly little code.

Speakers

Zach Laine

Principal Software Engineer, Cadence Design Systems

Zach Laine has been using C++ in industry for 15 years, focusing on data visualization, numeric computing, games, generic programming, and good library design. He finds the process of writing bio blurbs to be a little uncomfortable.

Monday September 14, 2020 13:30 - 14:30 MDT
generate_n()

• Design

Level Intermediate, Advanced, Expert
Tags Boost.STLInterfaces, STL, containers, generic programming, iterators, templates, views

13:30 MDT

Back to Basics: Class Layout

In C++, as in many other languages, classes are the key feature that supports data abstraction. A C++ class is essentially a C structure, but with added capabilities that support object-oriented programming as well as better type safety, resource management, and usability.

Although some of these added capabilities require additional storage allocation or run-time support, most do not. Thus, the storage layout for a C++ class can be as simple as the layout for a C structure. Unfortunately, too many programmers imagine that classes incur space and speed penalties that simply aren’t there.

This session offers a practical look “under the hood” to see how compilers typically implement the storage layout and member access for C++ classes. It also explains how compilers typically implement member function calls. You’ll come away with a better sense of what using classes actually costs in speed and space. You’ll gain insights that will help you with a variety of programming tasks, including debugging, performance tuning, and working with objects that have rigid layout requirements.

Speakers

Stephen Dewhurst

President, Semantics Consulting, Inc.

Steve Dewhurst is the co-founder and president of Semantics Consulting, Inc. Steve is the author of numerous technical articles on C++ programming techniques and compiler design, is the author of the critically acclaimed books C++ Common Knowledge and C++ Gotchas, and is the co-author... Read More →

Monday September 14, 2020 13:30 - 14:30 MDT
Back to Basics

• Embedded

Level Beginner, Intermediate
Tags Back to Basics, POD, alignment, classes, code generation, embedded, padding, run-time polymorphism, sizeof, standard layout, static data members, storage layout, virtual functions

13:30 MDT

Just-in-Time Compilation

Just-in-Time compilers... we've all heard of them! What are they really? Why would anyone want them, are they actually a good idea, and how do they fit in with C++ since we all use Ahead-of-Time compilers?

In this talk I'll tell you about C++ AOT compiler, JITs for dynamic language, JITs for binary translation, and dive back 20, 30, 40, 50, 60 years, way back into compiler history and read wonderful academic papers about compilers. I'll illustrate how our view of compilers is really monolithic, and how compilers through time, and still today, are actually a continuum.

Speakers

JF Bastien

Software Architect, Toyota Research Institute-Advanced Development

Compiler engineer, chair of the C++ committee's language evolution working group.

Monday September 14, 2020 13:30 - 14:30 MDT
count_if()

• Future of C++

Level Intermediate, Advanced, Expert
Tags jit

13:30 MDT

Test Driven C++

We know that testing is important, but writing tests is hard and takes time - and can be demotivating when you want to hack out features.

But what if we flipped the whole thing around? It turns out that by writing tests first the dynamic changes in unexpected ways. Testing becomes easier. Adding features becomes easier. The dopamine hit you get from seeing something work becomes more frequent. Time lost to bugs and regressions virtually disappears. You start to get invited to bigger and better parties!

Ok, one of those statements is not guaranteed - but the rest are! If you've never tried TDD (perhaps you have heard of it but been skeptical), or maybe had a bad experience in the past, this talk will give you a sound intro to how it works, how you can get started, and what you can expect to achieve.

Speakers

Phil Nash

Developer Advocate, Sonar

Monday September 14, 2020 13:30 - 14:30 MDT
Fuzzing/Testing

• Testing

Level Beginner, Intermediate, Advanced
Tags behavior-driven development, testing

14:30 MDT

AMA: Zach Laine

Join Zach Laine for a hallway-style discussion on:

STL algorithms
STL containers
Unicode ⌘

Speakers

Zach Laine

Principal Software Engineer, Cadence Design Systems

Monday September 14, 2020 14:30 - 14:55 MDT
generate_n()

• Education/Coaching

15:00 MDT

AMA: Herb Sutter

This is your chance to ask your questions of Herb or, as Herb, who is Canadian, would say, "AMA, eh."

Speakers

Herb Sutter

Software architect, Standard C++ Foundation

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++.

Monday September 14, 2020 15:00 - 16:00 MDT
count_if()

• Education/Coaching

07:30 MDT

Committee Fireside Chat

Bring your questions! This panel of representative members of the C++ standards committee is ready to discuss everything from the just-completed 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

Herb Sutter

Software architect, Standard C++ Foundation

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++.

Speakers

Bryce Adelstein Lelbach

CUDA C++ Core Libraries Lead, NVIDIA

Michael Wong

Distinguished Engineer, VP, Codeplay

Bjarne Stroustrup

Professor, Columbia University

Inbal Levi

Software Engineer, SolarEdge

Inbal Levi is an embedded software engineer with a passion for high performance.She is one of the organizers of CoreCpp conference and CoreCpp user group.She's also a member of ISO/IEC JTC1/SC22/WG21 (the C++ Standards Committee), and among the founders of the Israeli NB Mirror c... Read More →

JF Bastien

Software Architect, Toyota Research Institute-Advanced Development

Compiler engineer, chair of the C++ committee's language evolution working group.

Hana Dusíková

Staff Scientist, AVAST

Hana works as a staff scientist at Avast Software. She is the Czech National Body chair for SC22 and WG21. She is also chair of WG21's Study Group for Compile-Time Programming, where C++'s future Reflection facilities are being developed.

JC Van Winkel

SRE EDU lead educator, Google Switzerland

JC has been teaching UNIX and programming languages since 1992, working for AT Computing, a small courseware spin-off of the University of Nijmegen, the Netherlands. JC joined Google's Site Reliability Engineering team in 2010 and is both a founding member and lead educator of the... Read More →

Tony Van Eerd

Stunt-double for C++ Expert, Christie Digital

Tony has been coding for well over 25 years, and hopefully coding well for most of that. Previously at Inscriber, Adobe, and BlackBerry, he now enables painting with light at Christie Digital. He is on the C++ Committee. He is a Ninja and a Jedi. Follow @tvaneerd

Tuesday September 15, 2020 07:30 - 08:30 MDT
all_of()

• Future of C++

09:00 MDT

Back to Basics: Pointers and Memory

The prevailing wisdom in Modern C++ is to favor smart pointers and container classes over raw pointers and built-in arrays -- there are too many traps and pitfalls that come with using those more-primitive types. However, many C++ programmers can’t avoid using them because they’re still so prevalent in legacy C++ code and C libraries. If you have to use raw pointers and built-in arrays, then you should learn to use them safely and effectively.

This session explains the true nature of built-in pointers and arrays, and why they’re so easily confused despite actually being distinct types. It covers the rules for pointer and array type conversions, along with the mechanics of pointer arithmetic and array subscripting. It compares and contrasts pointers with references and iterators, as well as the pointer and reference member types in the STL, to help you make more informed choices about what to use when. This session also explains the origins of the types size_t and ptrdiff_t, and their relationship to size and difference types in the STL.

You’ll leave with a clearer understanding of how pointer operations behave, whether you’re using raw pointers and built-in arrays or smart pointers and container classes.

Speakers

Ben Saks

Chief Engineer, Saks & Associates

Ben Saks is the chief engineer of Saks & Associates, which offers training and consulting in C and C++ and their use in developing embedded systems. Ben has represented Saks & Associates on the ISO C++ Standards committee as well as two of the committee’s study groups: SG14 (low-latency... Read More →

Tuesday September 15, 2020 09:00 - 10:00 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, arrays, iterators, pointer arithmetic, pointers, references, type conversions

09:00 MDT

Building an Intuition for Composition

If you're fed up of reading articles about "monads" and "endofunctors" that don't give you an understanding of how they can actually help your C++ programming, this talk is for you.

Function and data composition are becoming increasingly important in C++ due to features like ranges, continuable futures, and new error handling techniques. Using real-world examples and C++ programming idioms, I'll help you build an intuition for the mathematical concepts which underpin these so that you can make the most of them in your code and build your own abstractions built on the same foundations.

Speakers

Sy Brand

Microsoft

Tuesday September 15, 2020 09:00 - 10:00 MDT
destroy_n()

• Algorithms/Functional

Level Intermediate, Advanced, Expert
Tags algorithms, functional, maths

09:00 MDT

Modern Software Needs Embedded Modern C++ Programming

As the chair of SG14 Embedded, I like to give an update of what we have done for embedded. But this talk is much more than that. It will describe our group's collective experience in what is Embeddedwhich has come from Automotive, games, Medical, Finance and many others. The definition is surprisingly wide and covers hard- and soft-real time, wide span of seriousness, hardware, replication, response time, and supported software. For that matter, who are the Embedded programmers? I will tie this back to the two pillars of C++: a direct map to hardware and zero overhead. I will argue why we should use C++, some of the bad reasons for note using C++, and identify 2 of the biggest problems people have complained about moving to C++. Understanding that Embedded compilers may not be up to the latest standard, we plan to separate Modern C++ into 3 Ages so that we can have people to change their code with varying levels of Embedded C++ compiler support. Finally, I will show some examples of how to change from C to C++ as one of the most common case in the Embedded community. I will show some of the common c++ features for each of several cases which includes Adopting to C++ in one shot, and gradual adoption for various sizes of systems. These are some of the common cases when people need to convert to C++ from some other language in the Embedded domain. We hope this overview and deep dive at the same time will give people a better appreciation and realistic perspective of what it takes to move to Modern C++ for Embedded systems.

Speakers

Michael Wong

Distinguished Engineer, VP, Codeplay

Tuesday September 15, 2020 09:00 - 10:00 MDT
Embedded

• Embedded

Level Beginner, Intermediate
Tags C to C++, embedded, hard, modern C++, programming patterns, soft real-time

09:00 MDT

A Physical Units Library For the Next C++

On CppCon 2019, Mateusz provided an overview of current solutions on the market as well as the challenges of implementing a modern C++ physical units library. This year's talk will focus on 'mp-units', the library developed by Mateusz and contributors, and proposed for the C++ standardization.

During this tutorial, we will get familiar with the building blocks of the library's framework and its most important concepts. Numerous code examples will present how to use and solve real-life problems with the library. The audience will learn how easy it is to extend it with new units, dimensions, or even whole new systems of quantities. Last but not least, Mateusz will provide a brief overview of how well this library performs compared to other products on the market.

Even if you are not interested in the physical units subject itself, you might still want to attend the talk as the library is full of C++20 features.

Speakers

Mateusz Pusz

Principal Engineer | C++ Trainer, Epam Systems | Train IT

A software architect, principal engineer, and security champion with over 20 years of experience designing, writing, and maintaining C++ code for fun and living. A trainer with over 10 years of C++ teaching experience, consultant, conference speaker, and evangelist. His main areas... Read More →

Tuesday September 15, 2020 09:00 - 10:00 MDT
generate_n()

• Future of C++

Level Beginner, Intermediate, Advanced
Tags C++20, concepts, dimensional analysis, mp-units, physical units, templates

09:00 MDT

2020: The Year of Sanitizers?

Clang-tidy is the go-to assistant for most C++ programmers looking to improve their code, whether to modernize it or to find hidden bugs with its built-in checks. Static analysis is great, but you also get tons of false positives.

Now that you’re hooked on smart tools, you have to try dynamic/runtime analysis. After years of improvements and successes for Clang and GCC users, LLVM AddressSanitizer (ASan) is finally available on Windows, in the latest Visual Studio 2019 versions. Let's find out how this experience is for MSVC projects.

We’ll see how AddressSanitizer works behind the scenes (compiler and ASan runtime) and analyze the instrumentation impact, both in perf and memory footprint. We’ll examine a handful of examples diagnosed by ASan and see how easy it is to read memory snapshots in Visual Studio, to pinpoint the failure.

Want to unleash the memory vulnerability beast? Put your test units on steroids, by spinning fuzzing jobs with ASan in Azure, leveraging the power of the Cloud from the comfort of your Visual Studio IDE.

Speakers

Victor Ciura

Principal Engineer, Visual C++ / Microsoft

Victor Ciura is a Principal Engineer on the Visual C++ team, helping to improve the tools he’s been using for years. Leading engineering efforts across multiple teams working on making Visual Studio the best IDE for C++ Game developers. Before joining Microsoft, he programmed... Read More →

Tuesday September 15, 2020 09:00 - 10:00 MDT
Fuzzing/Testing

• Testing

Level Beginner, Intermediate
Tags AddressSanitizer, Azure, CVE, Clang/LLVM, Microsoft Visual C++, Visual Studio, dynamic analysis, fuzzing, memory, testing

10:00 MDT

AMA: Mateusz Pusz

Join Mateusz Pusz for a hallway-style discussion on:

Modern C++
Templates, metaprogramming
C++20
the C++ standardization process
Performance and Low Latency
Delivering online talks and workshops
CMake
Conan

Speakers

Mateusz Pusz

Principal Engineer | C++ Trainer, Epam Systems | Train IT

Tuesday September 15, 2020 10:00 - 10:20 MDT
generate_n()

• Education/Coaching

10:05 MDT

BoF: C++ Video Captioning and Translation BoF

Sen has requested a Birds of a Feather meeting for attendees interested in captioning and translating C++ videos such as those from the CppCon YouTube channel.

Please meet at Table 2 in the AMA Room.

Note that this table only holds eight participants. If you see that the table is full and you are just lurking, please consider surrendering your seat to another attendee.

Attendees interested in discussing captioning and translating C++ videos, can join the discussion channel at #sig_i18n_videos, or the CppLang #cppvap channel, or the C++ Video Access Project website.

Speakers

Sen Li

SWE (Open to Work), Looking for Google Team Match

Learning on Student Visa.Waiting for Google Team Match, Let me know if your team have an opening position!

Tuesday September 15, 2020 10:05 - 10:25 MDT
_1

• Education/Coaching

10:30 MDT

C++20: An (Almost) Complete Overview

The technical work on C++20 was finished in January 2020, and is now being pushed through ISO certification.

This presentation gives an overview of (almost) all new features in both the language and the Standard Library. Some more exotic features will be left out. New language features include modules, coroutines, concepts, templated lambdas, constexpr changes, designated initializers, the spaceship operator, string literals as template parameters, feature test macros, conditional explicit, immediate functions, and more.

The second part of the session discusses the changes to the Standard Library. This includes topics such as ranges, atomic smart pointers, cancellable threads, a synchronization library, calendars, time zones, span, a formatting library, features test macros, and more.

The material is mostly the same as the "C++20: What's in it for you?" session from CppCon 2019, but it has been updated with the final standard. If you want a complete overview of all C++20 features, including references to other more deep-dive sessions at CppCon 2020 on certain topics, then this session is for you.

Speakers

Marc Gregoire

Software Architect, Nikon Metrology

MARC GREGOIRE is a software project manager and software architect from Belgium. He graduated from the University of Leuven, Belgium, with a degree in "Burgerlijk ingenieur in de computer wetenschappen" (equivalent to a master of science in engineering in computer science). The... Read More →

Tuesday September 15, 2020 10:30 - 11:30 MDT
all_of()

• Future of C++

Level Beginner, Intermediate, Advanced, Expert
Tags C++20, concepts, coroutines, modules, ranges, spaceship operator

10:30 MDT

[Overflow] C++20: An (Almost) Complete Overview

If the all_of() track is full, then join us in generate_n() as the overflow room.

The technical work on C++20 was finished in January 2020, and is now being pushed through ISO certification.

This presentation gives an overview of (almost) all new features in both the language and the Standard Library. Some more exotic features will be left out. New language features include modules, coroutines, concepts, templated lambdas, constexpr changes, designated initializers, the spaceship operator, string literals as template parameters, feature test macros, conditional explicit, immediate functions, and more.

The second part of the session discusses the changes to the Standard Library. This includes topics such as ranges, atomic smart pointers, cancellable threads, a synchronization library, calendars, time zones, span, a formatting library, features test macros, and more.

The material is mostly the same as the "C++20: What's in it for you?" session from CppCon 2019, but it has been updated with the final standard. If you want a complete overview of all C++20 features, including references to other more deep-dive sessions at CppCon 2020 on certain topics, then this session is for you.

Speakers

Marc Gregoire

Software Architect, Nikon Metrology

Tuesday September 15, 2020 10:30 - 11:30 MDT
generate_n()

• Future of C++

Tags C++20, concepts, coroutines, modules, ranges, spaceship operator

11:35 MDT

BoF: Pair Programming

Honey has requested a Birds of a Feather meeting for attendees interested in pair programming.

Please meet at Table 2 in the AMA Room.

Note that this table only holds eight participants. If you see that the table is full and you are just lurking, please consider surrendering your seat to another attendee.

Moderators

Honey Sukesan

Senior Software Developer, Jaguar Land Rover Ireland Services Ltd

I'm an embedded software developer working currently in Vehicle Engineering domain. I'm part of a team helping my employer to build vehicle software platform for our next generation cars. My previous domain experience was mostly with embedded healthcare domain where I got the opportunity... Read More →

Tuesday September 15, 2020 11:35 - 11:55 MDT
_1

• Education/Coaching

12:00 MDT

Back to Basics: Templates (part 1 of 2)

Template Basics

This talk is a two-parter. In the first part we start with the question what is generic programming. I then will introduce the different kinds of templates: function, class and method templates. We will walk through how to write and apply. Along with that we distinguish the different types of template parameters type, and non-type using std::array as an illustration. This is accompanied by a peak behind the scenes by using C++ Insights. This should also give you a valuable tool where you can checkout details for yourself.

At this point we look at alias templates and how they can help us.

Once we covered the basics, we take care that our templates do not bloat the code. For that we use an example of passing an array and a length and optimize this. While on that, we consider at type_traits and incorporate them in our solution. With type_traits we use constexpr if for conditional compile-time code paths.

This session is for developers with C++ experience who have avoided templates so far. After attending this talk, attendees have learned to think in types rather than in values and can write their own templates.

-----

Advanced Templates

This is the second part of Templates where go more into depth. Attendees expected to know the syntax an properties of function and class templates, type_traits and constexpr if.

In this session, we look at variadic templates together with fold expressions by using a Printf like function as an example. This knowledge is then used to talk about template specializations.

At this point we will briefly talk about SFINAE. We compare it to the tag-dispatching pattern and see how C++20s Concepts make SFINAE way less scary. Next on the plate are variable templates as well as template template parameters.

This session is for developers with C++ experience who have avoided templates so far. After attending this talk, attendees have learned techniques like SFINAE and template specializations.

Speakers

Andreas Fertig

Unique Code

Tuesday September 15, 2020 12:00 - 13:00 MDT
Back to Basics

Back to Basics

Level Beginner
Tags Back to Basics, SFINAE, generic programming, metaprogramming, templates

12:00 MDT

Embedded: Customizing Dynamic Memory Management in C++

Dynamic memory allocation is a natural solution for many common programming problems. In C++, new-expressions allocate dynamic memory through a function called operator new. Unfortunately, the compiler-provided implementation of operator new is often expensive to run, non-deterministic, and risks fragmenting memory over time. As a result, too many resource-constrained systems (e.g., embedded, real-time, or high-performance applications) avoid using new-expressions altogether. This is unfortunate because C++ new-expressions were designed to be highly customizable for such purposes.

This session shows how to implement customized dynamic memory managers for use in resource-constrained systems. It presents multiple forms of operator new and operator delete and explains the language mechanisms behind them. It shows how you can replace the compiler-provided operator new and operator delete with your own implementation, either globally or for individual classes. You’ll leave with a clearer understanding of how new and delete work and how you can tailor them to meet the demands of many resource-constrained applications.

Speakers

Ben Saks

Chief Engineer, Saks & Associates

Tuesday September 15, 2020 12:00 - 13:00 MDT
Embedded

• Embedded

Level Intermediate, Advanced
Tags alignment, embedded, memory, nothrow, replacing delete, replacing new

12:00 MDT

Building a Coroutine based Job System without Standard Library

A job system is a common game engine component to improve total CPU throughput. In this talk, I will walk through building a coroutine-based job system and explain the advantages of using coroutines over the typical ways to build a job system.

We shipped coroutines in C++20, but why does it matter for users, especially since there’s no standard library support? The answer is the coroutine semantics. Developers can customize the behavior of `co_return`, `co_yield`, `co_await` to build their own systems without any dependency of the standard library. For game developers, this is important because many game studios forbid the use of the standard library. The coroutine language feature itself is flexible enough to build a system with 100% control, which is exactly what engine developers want—no black box, no magic.

I will discuss the design decision I made, trade-offs, and current limitations. This talk is a crash course for system developers who want to build systems independently from the standard library and will also discuss possible future directions for this language feature.

This is an advanced coroutine talk and I expect attendees to have basic understanding about how (c++)coroutine works. Here is a useful link for some related materials if you want more information before attending this talk: https://gist.github.com/MattPD/9b55db49537a90545a90447392ad3aeb

Speakers

Tanki Zhang

Real-time Rendering Engineer, NVIDIA

Tanki is a real-time rendering engineer at NVIDIA. He has been an active member of both the C++ community and the graphics community. As a game developer focused on game engine technics, he is passionate about different new knowledge and is excited to try things out.

Tuesday September 15, 2020 12:00 - 13:00 MDT
generate_n()

• Future of C++

Level Intermediate, Advanced
Tags asynchronous, coroutines, games, job system

12:00 MDT

Closing the Gap between Rust and C++ Using Principles of Static Analysis

Did you know that 70% of serious security bugs are a result of memory safety issues? As a C++ developer, you may have heard about the safety benefits of Rust language. Although both Rust and C++ are high-performing system programming languages, we are increasingly hearing from customers and security researchers to have stronger safety and correctness guarantees in C++. Safety and correctness are no longer viewed as an opt-in behavior. The new adage is – if it compiles, it works. Static analysis has proved to be a valuable tool in empowering developers write modern C++. In this talk, I will share some ideas on how we can use the same principles in modern C++ code to provide strong statically-checked guarantees out-of-the-box. I will demonstrate some of these techniques live using MSVC’s code analysis tool.

Speakers

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 September 15, 2020 12:00 - 13:00 MDT
count_if()

• Safety/Error Handling

Level Beginner, Intermediate, Advanced, Expert
Tags code analysis, correctness, static analysis, tooling, type safety

13:00 MDT

AMA: Tanki Zhang

Join Tanki Zhang for a hallway-style discussion on:

Game and Game Engine Development
Computer Graphics
General C++

Speakers

Tanki Zhang

Real-time Rendering Engineer, NVIDIA

Tuesday September 15, 2020 13:00 - 13:20 MDT
generate_n()

• Education/Coaching

13:05 MDT

BoF: Meson Build System

Jussi has requested a Birds of a Feather meeting for attendees interested in Meson.

Please meet at Table 2 in the AMA Room.

Note that this table only holds eight participants. If you see that the table is full and you are just lurking, please consider surrendering your seat to another attendee.

Attendees interested in discussing Meson and other tools, can join the discussion channel at #sig_tooling.

Moderators

Jussi Pakkanen

Consultant, Rakettitiede oy

Jussi Pakkanen is the very model of a modern coder general. He programs in styles typed, scripted and functional. He's dealt with historical build systems quite cadaverous, replacing them with Meson files short, snappy and glamorous. In creating apps embedded, kernel, gui and terminal... Read More →

Tuesday September 15, 2020 13:05 - 13:25 MDT
_1

• Compilers/Tooling

13:30 MDT

Back to Basics: Templates (part 2 of 2)

Speakers

Andreas Fertig

Unique Code

Tuesday September 15, 2020 13:30 - 14:30 MDT
Back to Basics

Back to Basics

Level Beginner
Tags Back to Basics, SFINAE, generic programming, metaprogramming, templates

13:30 MDT

40 Years Of Evolution from Functions to Coroutines

The evolution of a callable stands for the evolution of C++. Here are the main evolution steps.

It all started with a function. Additionally, C++98 supports objects that behave like functions. These function-like objects are called function objects, and can have state.
C++11 added lambda expressions to the C++ standard. Lambda expressions behave like data and support in-place invocation and capturing of state. Lambdas can be generic in C++14, constant expressions in C++17, or templates in C++20.
C++20 generalizes the idea of something callable. Functions in C++20 are pausable and resumable. These generalized functions are known as coroutines and are the means of choice to program asynchronously.

Each step in this long evolution is way more than just syntactic step. Each step empowers new and more powerful ways to solve challenging programming tasks.

Speakers

Rainer Grimm

C++ trainer, Modernes C++

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 →

Tuesday September 15, 2020 13:30 - 14:30 MDT
destroy_n()

• Algorithms/Functional

Level Beginner, Intermediate
Tags callables, coroutines, function objects, functions, lambda expressions

13:30 MDT

Dealing with Embedded Limitations

Many embedded systems have requirements on latency, memory usage, and resource consumption. This is especially true of safety-critical and security-related systems. Many programmers and organizations worry that using C++ features will prevent them from meeting these requirements. Some avoid using specific features such as exception handling, while others avoid using C++ entirely.

This panel will discuss the challenges and benefits of using C++ in embedded contexts. We will explore ways that embedded systems can leverage the power of Modern C++ features to meet their guarantees. We will discuss which concerns are based in fact and which concerns are based on misconceptions.
Feel free to bring your own questions about anything that you believe inhibits your use of modern C++ on an embedded system. We will discuss pre-selected questions as well as audience submissions.

Moderators

Ben Saks

Chief Engineer, Saks & Associates

Speakers

Brett Searles

Principal Architect, Attobotics

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 →

Michael Wong

Distinguished Engineer, VP, Codeplay

Inbal Levi

Software Engineer, SolarEdge

Daniel Papke

Software Engineer, Collins Aerospace

Tuesday September 15, 2020 13:30 - 14:30 MDT
Embedded

• Embedded

13:30 MDT

C++20 STL Features: One Year of Development on GitHub

At CppCon 2019, Microsoft open-sourced its implementation of the C++ Standard Library. In the year since then, we've worked with many contributors on GitHub, adding dozens of C++20 features. In this talk, we'll explore some of these C++20 features and how you can use them in your code (even if you don't use our implementation). We'll also take a tour of microsoft/STL development on GitHub and our intensive code review process.

Examples of C++20 features we'll explore: span which makes working with contiguous sequences easier, constexpr algorithms which make it possible to verify that lookup tables are sorted at compile time (or just sort them at compile time!), erase_if() which finally supersedes the "erase-remove idiom", integer comparison functions which make it easier to write correct code without worrying about the Usual Arithmetic Conversions, and make_shared() for arrays which extends the classic "single allocation" optimization.

We're using GitHub issues and pull requests for all development, and we're recording a detailed Changelog in a GitHub wiki page. If you want to follow our progress, this talk will explain how to find what we're working on and what remains to be done. This talk will also show how we use a GitHub project to track PRs as they go through multiple stages of review. (The span PR accumulated almost 700 comments before being merged!) If you're interested in contributing, whether it's a small improvement or an entire feature, seeing this process should help.

Speakers

Stephan T. Lavavej

Programmer-Archaeologist, Microsoft

Stephan T. Lavavej is a Principal Software Engineer at Microsoft, maintaining Visual C++'s implementation of the C++ Standard Library since 2007. He also designed a couple of C++14 features: make_unique and the transparent operator functors. He likes his initials (which people can... Read More →

Tuesday September 15, 2020 13:30 - 14:30 MDT
generate_n()

• Future of C++

Level Intermediate, Advanced
Tags C++20, Microsoft Visual C++, STL, open source

15:00 MDT

Lightning Talks

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

Moderators

Michael Caisse

Ciere, Inc.

Tuesday September 15, 2020 15:00 - 16:00 MDT
destroy_n()

• Education/Coaching

07:30 MDT

AMA: Bjarne Stroustrup

Here is your chance to ask the creator of C++ what he was thinking. 😀

Moderators

Herb Sutter

Software architect, Standard C++ Foundation

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++.

Speakers

Bjarne Stroustrup

Professor, Columbia University

Wednesday September 16, 2020 07:30 - 08:30 MDT
count_if()

• Education/Coaching

07:30 MDT

Lightning Talks

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

Moderators

Michael Caisse

Ciere, Inc.

Wednesday September 16, 2020 07:30 - 08:30 MDT
destroy_n()

• Education/Coaching

09:00 MDT

Back To Basics: Lambda Expressions

Lambdas were first introduced into C++ with the release of the groundbreaking C++11 standard. New capabilities like generic lambda expressions and generalized captures were added in C++14. A few years ago, with the release of C++17, additional new features like constexpr lambda expressions were added. With the new release of C++20 even more features will added, some of which may change the way lambda expressions are used.

There are several parts to a lambda expression and in order to use them efficiently and effectively, you really need to master all the pieces. Do you know when to capture by value or capture by reference? Can the lifetime of variables be altered by a lambda expression? What are the ways to pass a lambda expression and is this a good idea? Our goal is to answer these questions and talk about the constraints lifted with each new version of C++. Multiple examples will be shown to illustrate what can be done with lambda expressions.

During this presentation developers will have the opportunity to learn or review the fundamentals about lambda expressions by studying the terminology. Once someone clearly understands the difference between a function object, function pointer, functor, and anonymous function, we have a great foundation for lambda expressions. We will be able to use our knowledge to reason about generalized captures and what it really means to capture "this".

Speakers

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 →

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 September 16, 2020 09:00 - 10:00 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, generalized capture, lambda expressions

09:00 MDT

No Touchy! A Case Study of Software Architecture with Immutable Objects

Our mission at ViewRay's is to conquer cancer by reenvisioning radiation therapy

Part of this is a piece of software which supports many workflows involving communication with various external agents such as an MRI scanner, a radiotherapy linear accelerator, a database, and, of course, the human operator. This software was started from scratch at the beginning of 2019 and is developed primarily in C++17.

This talk covers the multi-threaded and multi-process architecture of the software. It focuses on one of its elements: immutable objects. This is a pattern which started with functional programming. It was popularized by Haskell and it's hugely popular in web development — the React-Redux stack, for example — but it is not that popular in C++ software development. We will talk about how we ended up sticking with immutable objects, how they helped (and sometimes hindered) our development, what we invented in order to make them practical in C++, and problems and solutions we encountered along the way.

Speakers

Borislav Stanimirov

Staff Software Engineer, ViewRay

Borislav has been a C++ programmer for more than 17 years. The majority of his career has been in video games and in the past two years he's been working on software for medical devices. He has worked on C++ software for all kinds of platforms: desktops, mobile devices, servers, and... Read More →

Wednesday September 16, 2020 09:00 - 10:00 MDT
generate_n()

• Design

Level Intermediate, Advanced, Expert
Tags immutable objects, reactive programming

09:00 MDT

Practical Memory Pool Based Allocators For Modern C++

Runtime-deterministic memory allocations are a crucial aspect of any safety-critical real-time system. One of the simplest and widely adopted allocation mechanisms used in such systems is a memory pool with fixed block sizes. Unfortunately, the need to know the exact sizes of the memory blocks makes any practical usage of memory pools with standard C++ allocator-based approach rather problematic since users often “hide” real properties of allocations which are made under the hood. For example: STL’s node-based containers like 'std::map' as well as other standard mechanisms like 'std::promise' or 'std::allocate_shared'.

Being a company which focuses on real-time safety-critical applications, we still see a significant value in keeping compatibility with the standard allocator model as well as in following common conventions which are familiar to every C++ developer.

This talk presents an approach which uses a combination of a memory allocator implementation which instruments the code, and an external LLVM-based tool which extracts the instrumentation information and generates static memory pool definitions, allowing the allocator to switch from the heap to a memory pool without any further changes to the code. The presentation will walk through a simplest possible implementation of this approach.

Speakers

Misha Shalem

C++ Architect, Apex.AI

C++ developer with 16+ years of experience. Currently holds position of C++ Architect at Apex.AI, Palo Alto, CA

Wednesday September 16, 2020 09:00 - 10:00 MDT
Embedded

• Embedded

Level Intermediate, Advanced
Tags ISO 26262, allocators, embedded, memory pool, safety critical

09:00 MDT

Heterogeneous Programming in C++ with SYCL 2020

Computer system architecture trends are constantly evolving to provide higher performance and computing power, to support an increasing demand for high-performance computing domains including AI, machine learning, image processing and automotive driving aids. The most recent being the move towards heterogeneity, where a system has one or more co-processors, often a GPU, working with it in parallel. These kinds of systems are everywhere, from desktop machines and high-performance computing supercomputers to mobile and embedded devices.

In 2018 we presented SYCL; an open-standard, single-source standard C++ programming model for heterogeneous platforms, looking specifically at programming GPUs. Since then, as the momentum behind SYCL continues to grow, the SYCL working group within Khronos has been working hard with various hardware vendors, applications developers and universities across the industry to release an update to the standard.

The latest revision of the SYCL specification is SYCL 2020, and it brings a number of significant new features that will dramatically improve how you can program heterogeneous systems in C++.

Firstly, SYCL 2020 will introduce support for unified shared memory (USM) a new option for managing memory in SYCL alongside the existing buffer/accessor abstract which allows pointers and pointer-based structures to be passed directly to device functions. USM also provides a new explicit data management API which provides more fine-grained control over how data is allocated and moved between devices.

SYCL 2020 will also introduce a generalization of the SYCL specification which, while not altering the API in any significant way, allows SYCL implementations to target additional backends to OpenCL such as CUDA, HIP, OpenMP, etc. The most notable example of this is in the recent addition to the open-source SYCL implementation Data-Parallel C++ (DPC++) to support a CUDA backend, allowing SYCL applications to target Nvidia GPUs using the native CUDA driver.

SYCL 2020 will bump the minimum required C++ version to C++17 and will introduce a number of new features that will improve the user experience of writing SYCL applications, as well as further, align SYCL with ISO C++. This includes using class template argument deduction (CTAD) to reduce the verbosity of the SYCL AP and alignment with atomic_ref and the parallel algorithms.

Finally, SYCL 2020 will introduce a number of features which will allow applications to gain better performance by better utilising the hardware including sub-groups, group-based algorithms and optimized reductions.

This talk will present the current state of the SYCL ecosystem, including the supported implementations of which now there are four; ComputeCpp, DPC++, hipSYCL and triSYCL, as well as the range of platforms that are now supported by SYCL via these implementations. It will take a close look specifically at supporting Nvidia GPUs via DPC++’s CUDA backend, as this was a widely requested feature by SYCL developers in the C++ community.

This talk will then take a deep dive into the new features that SYCL 2020 is introducing and how these will improve SYCL application development for C++ developers.

Finally, this talk will end with a look at the SYCL standard, and where we hope to see it going in the future.

Speakers

Michael Wong

Distinguished Engineer, VP, Codeplay

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 →

Wednesday September 16, 2020 09:00 - 10:00 MDT
destroy_n()

• GPU/Graphics Programming

Level Beginner, Intermediate
Tags CUDA, OpenCL, concurrency, general purpose GPUs, heterogeneous computing

09:00 MDT

Dynamic Polymorphism with Metaclasses and Code Injection

Dynamic polymorphism in C++ has historically meant virtual functions and inheritance. However, these form only one possible design for solving this problem, and they bring several implications on performance, ergonomics and flexibility. Type erasure is another way to implement dynamic polymorphism, as demonstrated in several talks by Sean Parent and adopted in other languages, such as Rust’s trait objects. But implementing type erasing objects which provide ergonomic interfaces in C++ is cumbersome and error-prone, leading to a large family of types and libraries with subtly different semantics and lower adoption rates compared to inheritance.

This talk will present a possible future design for interface-based type erasure in C++ that marries the convenience of inheritance to the benefits which it otherwise lacks. It will introduce the code injection and metaclasses facilities which are proposed for inclusion in C++ along with a prototype implementation of the design based on the experimental metaclasses Clang fork.

Speakers

Sy Brand

Microsoft

Wednesday September 16, 2020 09:00 - 10:00 MDT
count_if()

• Metaprogramming/Reflection

Level Intermediate, Advanced, Expert
Tags metaclasses, metaprogramming, polymorphism, reflection, type erasure

09:00 MDT

Quickly Testing Qt Desktop Applications with Approval Tests

You've inherited some Qt GUI code: it's valuable, but it doesn't have tests, and it wasn't designed to be testable, so you need to start refactoring. But you can't refactor safely until the code has tests, and you can't add tests without refactoring! How can you ever break out of this loop?

The talk will review the challenges and potential sources of error that are specific to code that uses the Qt cross-platform graphical user interface library, and then describe how to guard against them.

There are many options for unit-testing Qt code, including Qt Test, Google Test and Catch. As well as covering those, and general principles for applying them, I will present a small but surprisingly effective C++11 library for applying "Approval Tests" to cross-platform Qt code.

Finally, the talk will briefly cover some other tools that can aid with inspecting and maintaining Qt code, which can in turn improve testability.

Attendees will discover some quick, practical techniques to help write unit tests and integration tests for Qt code.

Speakers

Clare Macrae

Director, Clare Macrae Consulting Ltd

Clare has worked in software development for over 30 years, and in C++ for 20 years. Since 2017, she has used her spare time to work remotely with Llewellyn Falco on [ApprovalTests.cpp](https://github.com/approvals/ApprovalTests.cpp), to radically simplify testing of legacy code... Read More →

Wednesday September 16, 2020 09:00 - 10:00 MDT
Fuzzing/Testing

• Testing

Level Beginner, Intermediate
Tags Qt, cross-platform, desktop, legacy code, productivity, testing

10:00 MDT

AMA: Gordon Brown and Michael Wong

Join Gordon Brown and Michael Wong for a hallway-style discussion on:

Heterogeneous computing
SYCL
Executors

Speakers

Michael Wong

Distinguished Engineer, VP, Codeplay

Gordon Brown

Principal Software Engineer, Codeplay Software

Wednesday September 16, 2020 10:00 - 10:20 MDT
destroy_n()

• Education/Coaching

10:00 MDT

AMA: Sy Brand

Join Sy Brand for a hallway-style discussion on:

Visual Studio, VS Code, MSVC, Vcpkg
Functional programming in C++
Metaclasses
Inclusivity and diversity

Speakers

Sy Brand

Microsoft

Wednesday September 16, 2020 10:00 - 10:20 MDT
count_if()

• Education/Coaching

10:30 MDT

Performance Matters

Performance is one of the chief reasons why many C++ programmers love the language. In the past, Moore's Law meant that our programs ran faster every year. Now that Dennard scaling has ended, C++ programmers have to work harder to get high performance for their applications. In this talk, I'll first discuss some of the significant and surprising challenges facing C++ programmers trying to achieve high performance on modern hardware platforms: performance is far less stable and predictable than you might think! I'll present some experimental evidence that strongly suggests we can't count on compiler optimizations to help us out of this hole: in particular, I'll show -- using a new experimental methodology -- that the difference between clang's -O2 and -O3 optimization levels is essentially indistinguishable from noise.

Since compiler optimizations have run out of steam, we need better profiling support, especially for modern concurrent, multi-threaded applications. I'll talk about a new approach to profiling, which I call "causal profiling". Causal profiling lets programmers optimize for throughput or latency, and which pinpoints and accurately predicts the impact of optimizations. It works by running performance experiments, based on the idea of "virtual speedups". We've built a causal profiler called Coz, which now ships as part of standard Linux distros, and which also works for C++ and Rust (there's even a Java version). Using it, we find that Coz can unlock previously unknown optimization opportunities. Guided by Coz, we improved the performance of Memcached (9%), SQLite (25%), and accelerated six other applications by as much as 68%; in most cases, this involved modifying less than 10 lines of code and took under half an hour (without any prior understanding of the programs!).

Speakers

Emery Berger

Professor, University of Massachusetts Amherst

Emery Berger is a Professor of Computer Sciences at the University of Massachusetts Amherst, the flagship campus of the UMass system. Emery and his collaborators have built numerous widely adopted software systems including Hoard, a fast and scalable memory manager that accelerates... Read More →

Wednesday September 16, 2020 10:30 - 11:30 MDT
all_of()

• Deep Magic

Level Intermediate, Advanced
Tags performance

10:30 MDT

[Overflow] Performance Matters

If the all_of() track is full, then join us in generate_n() as the overflow room.

Performance is one of the chief reasons why many C++ programmers love the language. In the past, Moore's Law meant that our programs ran faster every year. Now that Dennard scaling has ended, C++ programmers have to work harder to get high performance for their applications. In this talk, I'll first discuss some of the significant and surprising challenges facing C++ programmers trying to achieve high performance on modern hardware platforms: performance is far less stable and predictable than you might think! I'll present some experimental evidence that strongly suggests we can't count on compiler optimizations to help us out of this hole: in particular, I'll show -- using a new experimental methodology -- that the difference between clang's -O2 and -O3 optimization levels is essentially indistinguishable from noise.

Since compiler optimizations have run out of steam, we need better profiling support, especially for modern concurrent, multi-threaded applications. I'll talk about a new approach to profiling, which I call "causal profiling". Causal profiling lets programmers optimize for throughput or latency, and which pinpoints and accurately predicts the impact of optimizations. It works by running performance experiments, based on the idea of "virtual speedups". We've built a causal profiler called Coz, which now ships as part of standard Linux distros, and which also works for C++ and Rust (there's even a Java version). Using it, we find that Coz can unlock previously unknown optimization opportunities. Guided by Coz, we improved the performance of Memcached (9%), SQLite (25%), and accelerated six other applications by as much as 68%; in most cases, this involved modifying less than 10 lines of code and took under half an hour (without any prior understanding of the programs!).

Speakers

Emery Berger

Professor, University of Massachusetts Amherst

Wednesday September 16, 2020 10:30 - 11:30 MDT
generate_n()

• Deep Magic

Tags performance

12:00 MDT

A Relaxed Guide to memory_order_relaxed

The out-of-thin-air (OOTA) and read-from-untaken-branch (RFUB) properties of the specification of memory_order_relaxed have resulted in considerable consternation over the years. Although there are no known instances of full-blown OOTA behavior, and no known RFUB-induced failures of production code, the theoretical possibility of these properties severely complicates automated analysis of large C and C++ code bases. Thus far, attempts to eliminate OOTA and RFUB properties from the memory model have resulted in otherwise needless added overheads on weakly ordered systems on the one hand or excessive implementation complexity on the other. However, memory_order_relaxed never was intended to be used in arbitrary code, but rather as a part of deliberate application of specific concurrency designs. This talk provides an initial catalog of patterns underlying such designs.

Speakers

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 →

Hans Boehm

Google

Hans is a software engineer at Google, where he has been since March 2014. He now works mostly on concurrent programming issues, both generally, and focussed on Android. Hans is an ACM Fellow, and a past Chair of ACM SIGPLAN (2001-2003). Until late 2017 he chaired the ISO C++ Concurrency... Read More →

Wednesday September 16, 2020 12:00 - 13:00 MDT
Embedded

• Concurrent/Async/Parallel

Level Intermediate
Tags concurrency, memory model, verification

12:00 MDT

Just-in-Time Compilation: The Next Big Thing?

JITting code is a feature of many languages but has not yet landed in C++. However, there has been some work to integrate JITting into Clang by Hal Finkel. Having a JIT compiler offers flexibility at runtime without sacrificing compile-time performance, and can take advantage of late optimizations that maybe even better than those available at compile-time.

C++ is still in the early stages of exploring JIT capabilities. In this talk, we'll expand the boundaries and the possibilities of JITting in C++ by combining C++20 features with the clang-jit compiler work introduced in P1609. We'll show some use cases we find non-obvious and exciting and that may change the future of compile-time programming by blurring the boundary between compile-time and runtime.

Speakers

Ben Deane

Quantlab

Ben was in the game industry for 23 years, at companies like EA and Blizzard. For the last couple of years he's been working in the finance industry at Quantlab. He's always looking for useful new techniques in C++, and he geeks out on algorithms, APIs, types and functional progr... Read More →

Kris Jusiak

Senior Software Engineer, Quantlab Financial, LLC

Kris is a Senior Software Engineer passionate about programming and 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... Read More →

Wednesday September 16, 2020 12:00 - 13:00 MDT
destroy_n()

• Future of C++

Level Advanced
Tags C++20, Clang/LLVM, Cling, JIT, concepts, reflection

12:00 MDT

Exploration of C++20 Meta Programming

In this talk, we will take the journey to compile-time.

We will start with adding templates to existing program, and overview overload resolution and conditioning at compile time.

We will continue with exploring the latest version of template metaprogramming updated by the release of C++20.

Finally, we will present techniques to control the compiled-time logic when instantiating templates, on C++20 and beyond.

Speakers

Inbal Levi

Software Engineer, SolarEdge

Wednesday September 16, 2020 12:00 - 13:00 MDT
count_if()

• Metaprogramming/Reflection

Level Beginner, Intermediate
Tags functional, metaprogramming, templates

12:00 MDT

Cross-Platform Pitfalls and How to Avoid Them

C++ cross-platform development is difficult. These difficulties are compounded by the fractured solution field, where every project seems to use a different combination of build systems, package managers, and diagnostic tools to address shared challenges. Join us for a discussion and demo of C++ cross-platform development centered on common pitfalls and widely adopted tooling.

Learn how to leverage CMake to seamlessly build across operating systems and platforms. Untangle your dependencies with tools like vcpkg and Conan to avoid inconsistencies between system package managers. Debug your projects across multiple platforms with Visual Studio and Visual Studio Code. We’ll also take a brief look into how to use CI and testing to get in front of issues before they even happen.

Speakers

Erika Sweet

Program Manager, Microsoft

Erika is a Program Manager on the Visual C++ Team at Microsoft. She likes math and mystery novels. She is currently working on developer tools to support C++ cross-platform development.

Wednesday September 16, 2020 12:00 - 13:00 MDT
generate_n()

• Software Evolution/Portability

Level Beginner, Intermediate
Tags CMake, Visual Studio, cross-platform, tooling

12:00 MDT

Back to Basics: Unit Tests

Automated unit tests can accelerate software development by quickly identifying regressions, clarifying interface requirements, and encouraging more modular designs. However, actually incorporating unit tests into your development process can be intimidating. Choosing a unit testing framework can be a daunting task because there are so many frameworks with such wide-ranging capabilities. Moreover, even when using a really good framework, crafting effective tests is a skill that takes time to master.

This session takes you through the process of writing automated unit tests for realistic code, working from very simple tests up to more complex ones. It starts with a brief introduction to automated testing and test-driven development. It shows you the first steps toward using automated unit tests in your development process.

In this session, you’ll learn the practical benefits of a unit testing framework through examples using Google Test. You’ll see how you can simplify difficult tests using dependency injection and Google Mock in addition to Google Test. Along the way, you’ll learn about different testing strategies, as well as concepts such as test coverage and ordering dependencies. Whether you’re new to automated testing or looking for a way to test challenging components, this session will help you take the next step toward more reliable, test-driven software.

Speakers

Ben Saks

Chief Engineer, Saks & Associates

Wednesday September 16, 2020 12:00 - 13:00 MDT
Back to Basics

• Testing

Level Beginner, Intermediate, Advanced
Tags Back to Basics, maintainability, mocking, robustness, testing

13:05 MDT

BoF: Build Systems

Rob has requested a Birds of a Feather meeting for attendees interested in Build Systems.

Please meet at Table 2 in the AMA Room and then overflow into tables 3, 4, etc. as necessary.

Note that each table only holds eight participants.

Attendees interested in discussing build systems and other tools, can join the discussion channel at #sig_tooling.

Moderators

Robert Boehne

Sr. Software Architect, Datalogics

This year, I'm using Clang Sanitizers, CMake and Conan to deliver our legacy library with the highest quality possible. I'd like to learn more about how to use Docker and Jenkins (together or not) to run static analysis or other checks.I've been a C++ developer since 1997, most... Read More →

Wednesday September 16, 2020 13:05 - 13:25 MDT
_1

• Compilers/Tooling

13:30 MDT

Effective Remote C++ Development with Codespaces

The rise of remote work and the growth of team sizes present a challenge for C++ developers. Many C++ projects have complex hardware and software requirements, making onboarding of new team members and productive coding from home harder than they need to be. We need tools to ease configuration of your team's development environments and grant them access to the processing power they need from wherever they are in the world.

This presentation will show how Codespaces can use the power and flexibility of the cloud to address these issues. Codespaces give you the ability to quickly create a managed online development environment specific to your project that you can access from anywhere. We'll look at the problems which hit C++ developers particularly hard, like long build times and dependency management. Finally, we'll show the tool in action to give you a feel for how your teams could leverage it, and more broadly get you to think about what parts of your team's development process can be streamlined.

Speakers

Nick Uhlenhuth

Program Manager, Microsoft

Wednesday September 16, 2020 13:30 - 14:00 MDT
generate_n()

• Compilers/Tooling

Level Intermediate
Tags Visual Studio, collaboration, remote work, work from home

13:30 MDT

C++20 String Formatting Library: An Overview and Use with Custom Types

C++20 introduced a nice formatting library with std::format(). This session will explain what the formatting library provides, how to use all of its functionality, and most importantly, how you can customize it so that you can use formatting strings that include your very own custom types and custom formatting parameters, and of course, how to handle errors.

Speakers

Marc Gregoire

Software Architect, Nikon Metrology

Wednesday September 16, 2020 13:30 - 14:00 MDT
count_if()

• Future of C++

Level Intermediate, Advanced, Expert
Tags C++20, formatting, std::format

13:30 MDT

Back to Basics: Algebraic Data Types

One of the hallmarks of "modern C++" is a transition from classic object-orientation to value semantics with algebraic data types such as `variant` and `tuple`. In this session we'll explain the math behind the name, and we'll delve deep into the meaning and usage of all of the algebraic data types in C++17: pair, tuple, optional, and variant. These types have some commonalities, such as the use of type-traits to access their component types, and a common approach to implicit conversions and comparisons. We'll show how to use std::optional for deferred initialization and how to replace dynamic polymorphism with visitation over a std::variant. We'll even deliver some guidance on when NOT to return a tuple, and on how you should think about variant's "valueless by exception" state.
Attendees will leave this session with a newfound appreciation for C++'s algebraic data types.

Speakers

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 September 16, 2020 13:30 - 14:30 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, STL, algebraic types, modern C++

13:30 MDT

Constructing Generic Algorithms: Principles and Practice

"You have all these algorithms at your disposal. *Learn them.*"
-- Sean Parent, GoingNative 2013.

Great advice, and the algorithms can do a lot. But they can't do everything, and
the fixed set in the standard was never meant to be the last word in every
problem. Sometimes we do need to write our own solutions. What are the best
practices for that?

This talk examines how to build our own algorithms. We'll start with a raw loop
that solves a nontrivial problem, and turn it into a generic algorithm capable
of supporting a wide variety of use cases without loss of expressivity or
efficiency.

Along the way we'll consider algorithmic patterns, how to structure the
interface, how the types interact, iterator category concerns, testing, and
more. We'll look at how ranges and concepts help us to refine and focus things.
We'll also see where the existing algorithms fall short, and take a look at some
non-obvious use cases, including some minor modifications or wrappings that give
us extra flexibility.

Speakers

Ben Deane

Quantlab

Wednesday September 16, 2020 13:30 - 14:30 MDT
destroy_n()

• Algorithms/Functional

Level Intermediate, Advanced
Tags algorithms, concepts, generic programming, templates

13:30 MDT

Get Off My Thread: Techniques for Moving Work to Background Threads

If you're writing a GUI application and you want the interface to feel "responsive" to the user then you need the code that response to UI events to be short and fast. Similarly, if you are handling network I/O you may not want the processing of one request to prevent the system receiving further input.

If the work to be done in response to an event is complex and time consuming then you can maintain the "responsiveness" of the system by passing the work off to a background thread.

This talk will look at the ways of doing this, including managing ongoing work, providing progress updates, and cancelling work if it is no longer needed.

Speakers

Anthony Williams

Just Software Solutions Ltd

Anthony Williams is the author of C++ Concurrency in Action.

Wednesday September 16, 2020 13:30 - 14:30 MDT
Embedded

• Concurrent/Async/Parallel

Level Intermediate, Advanced, Expert
Tags concurrency

14:10 MDT

The Many Shades of reference_wrapper

You may have heard of std::reference_wrapper's role in make_tuple, but this is not today's topic. The role that reference_wrapper plays is larger than unwrapping references in C++ standard library API. It is the language's response to the need for references with rebinding semantics, which may explain why such a small utility is still receiving love and polishes in C++20.
To put it in the other way, every reference in Python is rebindable -- with garbage collection, of course. But the semantics in common implies that reference_wrapper may be very useful. This talk will go through these use cases, see how reference_wrapper's design carefully enables them through details. The talk will also compare reference_wrapper with other facilities in the language and the standard library to give you hints about how to choose from the reference-like types.

Speakers

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 →

Wednesday September 16, 2020 14:10 - 14:40 MDT
count_if()

• Deep Magic

Level Beginner, Intermediate
Tags C++20, assign-through, data structure, pointers, reference rebinding

14:10 MDT

Design Patterns for Handling and Reporting Errors in C++ Programs Using Parallel Algorithms and Executors

C++17 already has parallel algorithms. Executors (P0443, hopefully in C++23) will add asynchronous execution to parallelism. The usual C++ error handling approach, exceptions, will not work "out of the box." We need to build up new patterns for error handling.

C++ parallel algorithms and executors have several challenges handling errors. First, errors can happen nonlocally -- in parallel tasks other than my own -- yet they can affect correctness of an entire parallel algorithm. Second, notification of errors may be deferred: I may not find out about an error right away. Third, I may need to take explicit action to find out about an error. Fourth, checking whether an error has occurred somewhere might have a performance cost. Finally, letting exceptions propagate across certain boundaries may have unfortunate consequences: the program might crash without respecting destructors and stack unwinding, or it might even "hang" (become unresponsive).

I'm not offering canned solutions to these issues. However, we don't have to start from scratch: this situation shares much in common with others that have been around for decades. Examples include non-C++ interfaces to C++ libraries, boundaries between graphical user interface and back-end code, and distributed-memory parallel code. My experience is mainly with distributed-memory parallel code that uses MPI, the Message Passing Interface that has seen nearly 30 years of continuous use and evolution. In this talk, I'll show how design patterns already exist for parallel error handling, and I'll apply these design patterns to C++17 parallel algorithms, executors (P0443r13), and parallel algorithms for executors (P1897r3).

Speakers

Mark Hoemmen

Scientific software developer, Stellar Science

Mark Hoemmen has a B.S. in mathematics and computer science from the University of Illinois, and a PhD in computer science from the University of California Berkeley. His background is in numerical linear algebra and parallel computing. Mark has 20 years' professional experience as... Read More →

Wednesday September 16, 2020 14:10 - 14:40 MDT
generate_n()

• Safety/Error Handling

Level Intermediate, Advanced, Expert
Tags concurrency, executors

14:40 MDT

AMA: Mark Hoemmen

Mark Hoemmen has been developing parallel libraries and applications for over a decade.

He is working with others on a linear algebra library for the C++ Standard.

Speakers

Mark Hoemmen

Scientific software developer, Stellar Science

Wednesday September 16, 2020 14:40 - 15:00 MDT
generate_n()

• Education/Coaching

14:40 MDT

AMA: Zhihao Yuan

Join Zhihao Yuan for a hallway-style discussion on:

C++ features he gets involved, such as CTAD, designated initializers, etc.
FreeBSD.
Teaching C++ as a first programming language.
C++ vs. Python.
The standards committee.
China.
Open-source.

Speakers

Zhihao Yuan

R&D Software Engineer, Broadcom Inc.

Wednesday September 16, 2020 14:40 - 15:00 MDT
count_if()

• Education/Coaching

15:00 MDT

BoF: Game Development

Nathan has requested a Birds of a Feather meeting for attendees interested in Game Development.

Please meet at Table 2 in the AMA Room and overflow into Tables 3, 4, 5, etc.

Note that each table only holds eight participants.

Attendees interested in discussing game development, can join the discussion channel at #sig_game_development.

Moderators

Nathan Ward

Software Engineer, Quantlab

C++, functional programming, Rust, Game Dev

Wednesday September 16, 2020 15:00 - 15:30 MDT
_1

• Deep Magic

15:00 MDT

Lightning Talks

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

Moderators

Michael Caisse

Ciere, Inc.

Wednesday September 16, 2020 15:00 - 16:00 MDT
destroy_n()

• Education/Coaching

15:45 MDT

ArcGIS Runtime for Qt

A brief introduction to the ArcGIS Runtime SDK for Qt

This will be a 10 minute presentation, followed by a 5 minute Q/A session.

* This session will be held in the Esri Expo Room. *

Speakers

James Ballard

Developer Lead, esri

Lead Software Engineer for the ArcGIS Maps SDK for Qt.https://developers.arcgis.com/qt/

Wednesday September 16, 2020 15:45 - 16:00 MDT
_1

• Deep Magic

16:30 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!

Staff

Arthur O'Dwyer

C++ Trainer

Wednesday September 16, 2020 16:30 - 18:30 MDT
generate_n()

Social

07:30 MDT

Community Organizers Panel

Are you a C++ community leader? Would you like to be?

If you are or would like to be working to build a C++ community, either on-line or in meat space, we'd like to hear from you about your challenges and your successes.

We'll hear from successful community leaders, answer questions, and share resources and ideas. We'll discuss user groups, conferences, podcast, and online communities and forums.

Moderators

Jon Kalb

Conference Chair, Jon Kalb, Consulting

Jon Kalb is using his decades of software engineering experience and knowledge about C++ to make other people better software engineers. He trains experienced software engineers to be better programmers. He presents at and helps run technical conferences and local user groups.He is... Read More →

Speakers

Jens Weller

Meeting C++ / Community Organizer, Meetingcpp GmbH

Jens Weller has worked, since 2007, as a freelancer in C++, specialising in consulting, training and programming C++. He started with programming C++ back in 1998. He is an active member of the European C++ community and the founder of the Meeting C++ platform and conference. Jens... Read More →

Inbal Levi

Software Engineer, SolarEdge

Thursday September 17, 2020 07:30 - 08:30 MDT
generate_n()

• Education/Coaching

07:30 MDT

Lightning Talks

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

Moderators

Michael Caisse

Ciere, Inc.

Thursday September 17, 2020 07:30 - 08:30 MDT
destroy_n()

• Education/Coaching

07:30 MDT

C++ Committee's Library Evolution Working Group

Come join the leaders of the C++ Committee's Library Evolution Working Group to discuss the latest developments in and future of the C++ Standard Library.

Moderators

Ben Craig

Speakers

Billy Baker

Software Architect, FlightSafety International

Billy Baker has developed deterministic real-time flight simulation software using C++ for FlightSafety International, Evans and Sutherland and Boeing since 1997. At C++ committee meetings, he can be found in library groups including chairing SG18, Library Evolution Working Group... Read More →

Tom Honermann

Sr Staff Software Engineer, Synopsys

Tom Honermann is a software engineer at Synopsys where he has been working on the Coverity static analyzer for the past 9 years. His first C++ standard committee meeting was Lenexa in 2015. He currently chairs the SG16 text and Unicode study group and participates SG15 tooling... Read More →

Corentin Jabot

Corentin Jabot is a freelance developer and member of the C++ committee and is mainly interested in portability and API design.

Thursday September 17, 2020 07:30 - 08:30 MDT
count_if()

• Future of C++

08:40 MDT

Supercharge your productivity with CLion and just a few easy tricks

Think that learning to be productive with a complex tool like CLion takes a big investment? You might be surprised just how much you can get down with just a handful of simple shortcuts. One of them even makes it easy to find everything else you might need. We'll look at navigating code like a pro, finding and fixing code issues on the fly, refactoring and even generating code.

Join us in the JetBrains Demo Room.

(This demo is also presented at 14:45 today.)

Speakers

Phil Nash

Developer Advocate, Sonar

Thursday September 17, 2020 08:40 - 08:55 MDT
_1

09:00 MDT

Back to Basics: Smart Pointers

From the library's perspective, an essential feature in C++11 was smart pointers.

Since C++11, we have four different smart pointer: std::auto_ptr, std::unique_ptr, std::shared_pointer, and std::weak_ptr. With C++17 std::auto_ptr was removed and with C++20, we get an std::atomic＜std::shared_ptr＞, and std::atomic＜std::weak_ptr＞.

Each smart pointer models a specific ownership semantic and has a particular purpose. The crucial question is, therefore: When should you use which smart pointer? The answer to this question becomes more sophisticated when you think about the arguments or the return value of a function. You have to answer the following question for the function arguments:

- What does it mean to take the function arguments by pointer, by std::unique_ptr, or by std::shared_ptr?
- Should the function take the smart pointer by value or by reference?
- Should the argument be const or not?

The answers to those questions are not the end of the story. When you have a factory function creating something, the question immediately arises: Should the factory function return its product by a pointer, by std::unique_ptr, or by std::shared_ptr?

Smart pointers are more than pointers decorated with smartness. Smart pointer models ownership semantic. Understanding the ownership semantic of smart pointers is the main topic of my talk and, therefore, your takeaway.

Speakers

Rainer Grimm

C++ trainer, Modernes C++

Thursday September 17, 2020 09:00 - 10:00 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, ownership semantic, shared_ptr, smart pointer, unique_ptr, weak_ptr

09:00 MDT

Pipes: How Plumbing Can Make Your C++ Code More Expressive

In code we work with collections of objects all the time, yet it's not always easy to operate on them with concise and expressive code.

Traversing collections with for loops gets ugly and brittle as soon as they have more than a few lines.
STL algorithms are a big step further, but they don't compose well (ever had the need for a "transform_if" algorithm?)
Ranges are another big step further, but like every library they don't cover all cases (Did you know about the transform-filter performance problem? Or that you're not allowed to use rvalues as inputs? Or that you have to use tuples when working on several collections?)

In this talk you will discover pipes, another way to write expressive code to operate with collections: write your code as plumbing through which your data flows.

Like every library pipes also have their limitations, which we will present, but using them as a complement of ranges and STL algorithms will bring you the following benefits:
- An efficient transform-filter
- zip two collections without using tuples
- send data to several outputs
- use rvalues as inputs and as intermediate results
- pick up the data coming out of STL algorithms
- integrate results in destination containers
- pipes are very easy to implement, so you can add new ones

Come see how pipes can improve your code!

Speakers

Jonathan Boccara

Lead Principal Software Engineer, Murex

Jonathan Boccara is a Principal Engineering Lead at Murex where he works on large codebases in C++.His primary focus is searching how to make code more expressive. He has dedicated his blog, Fluent C++, to writing expressive code in C++. He also gives internal trainings on C++ every... Read More →

Thursday September 17, 2020 09:00 - 10:00 MDT
count_if()

• Algorithms/Functional

Level Intermediate, Advanced, Expert
Tags algorithms, collections, pipes, ranges

09:00 MDT

A Multi-threaded, Transaction-Based Locking Strategy for Containers

With the concurrency tools available in the modern C++ standard library, it is easier than ever to create multi-threaded programs. When we write such applications, there are sometimes cases in which a container simply must be shared among multiple threads. Of course, sharing is trivial if the only operations on the container are reads. In the case where reads greatly outnumber writes, acceptable performance is often attainable with a reader/writer mutex type, like std::shared_mutex. But suppose that the number of writes is similar to, or even greater than, the number of reads -- how does one then perform simultaneous reads and writes on a single container?

One common usage pattern is that, for a given operation, sets of related records are read and updated together. In order to prevent data races and inconsistent views of the data, such sets must be locked together as a unit before any of them can actually be read or updated. Further, it is very easy to accidentally create deadlocks by choosing a seemingly correct locking order. In order to avoid these problems, we would like a locking algorithm that provides three important properties: atomicity, consistency, and isolation.

This talk will describe an algorithm, implemented in C++, that performs such locking based on the concept of strict timestamp ordering. Using only facilities from the C++17 standard library, it employs a straightforward approach to multi-threaded, transactional record locking that requires minimal spatial overhead and yet fulfils the requirements of atomicity, consistency, and isolation. We'll discuss the pros, cons, and limitations of the algorithm, and provide some performance measurements.

Speakers

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Thursday September 17, 2020 09:00 - 10:00 MDT
Fuzzing/Testing

• Concurrent/Async/Parallel

Level Intermediate, Advanced, Expert
Tags concurrency, containers

09:00 MDT

What’s in a Name? What’s a Name In?

If it weren't for names, we would all be programming in a machine language of zeroes and ones.

C++ gives us an incredibly rich collection of language features for declaring and accessing names and their associated program artifacts. For example, C++ has several kinds of id-expressions (not just names), several kinds of scopes (not just blocks and namespaces), several kinds of declarations, and a plethora of name lookup algorithms (some with several variations).

This talk will provide deeper insights into what these language features do, how they interact, and how we programmers can take best advantage of them. Using numerous examples, we will touch upon such related topics as friendship and hidden friends, hiding and overriding, inline namespaces, labels, overloading, points of declaration, using-declarations and using-directives, visibility, and more.

Speakers

Walter E Brown

With broad experience in industry, academia, consulting, and research, Dr. Walter E. Brown has been a computer programmer for almost 60 years, and a C++ programmer for more than 40 years.He joined the C++ standards effort in 2000, and has since written circa 175 proposal papers. Among... Read More →

Thursday September 17, 2020 09:00 - 10:00 MDT
generate_n()

• Design

Level Beginner, Intermediate, Advanced, Expert
Tags name lookup algorithms, naming, scopes, visibility of names

09:00 MDT

Modern C++ Safety and Security At 20

The C++20 standard is now complete and the features and changes to the language promise to be more extensive than even C++11, which started the modern age. Engineers who work in safety critical applications, security or even applications that get abused by customers every day have special needs from the language. But what does the new standard give us as far as writing clean, safe, secure code?

In this talk, we'll look at the new features and changes to the standard and see how they affect outcomes for code written for safety critical and secure environments or even code that just needs survive the day with whatever your users throw at it.

Among the features we'll look at are: ranges, concepts, std::format, std::span, std::atomic＜std::shared_ptr＞＞, co-routines, designates initializers, spaceship operator, attributes, using enum.

As we'll see, some new features are huge wins for safety and security while others look like wins but come with their own problems.

Then we'll look ahead at what the standards committee is working on for C++23. C++20 has a lot of changes and new features. When this talk is over you'll know which features help your write clean, safe, secure code.

And which don't.

Speakers

Matthew Butler

Laurel Lye Consulting

Matthew Butler has spent the last three decades as a systems architect and software engineer developing systems for network security, law enforcement and the military. He primarily works in signals intelligence using C, C++ and Modern C++ to build systems running on hardware platforms... Read More →

Thursday September 17, 2020 09:00 - 10:00 MDT
Embedded

• Embedded

Level Beginner, Intermediate, Advanced, Expert
Tags embedded, modern C++, security

09:00 MDT

The Shapes of Multi-Dimensional Arrays

In 2020, linear algebra is still not a part of standard C++. Worse than that, beyond the good old C-style multidimensional arrays, the standard library still does not provide modern tools to handle such objects. In the era of machine learning and artificial intelligence, this is starting to get embarrassing. But why is that? Why does everything is always so much more complicated in C++ than in other higher level language?

In this talk we will focus on one of the many problems involved: how to handle the shapes and dimensions of high-performance multidimensional arrays? To prevent template metaprogramming wizards from providing a completely unusable answer, we will add one requirement: it has to be concise, expressive, and understandable by humans.

To answer this question, we will see how C++20's Non-Type Template Parameters can be leveraged to build a mini-embedded compile-time language to specify the size of matrices while combining expressiveness and conciseness. We will see how this technique can allow to mix static and dynamic dimensions while ensuring the highest level of performance. We will also discuss how it could be exploited to express parallelization and vectorization, as well as sparse storage patterns. At the big picture level, this talk will also explore why bringing generic Non-Type Template Parameters may have opened a very nice Pandora's box in C++.

Speakers

Vincent Reverdy

Researcher, CNRS

Vincent Reverdy is a Full Researcher in Computer Science and Astrophysics at French Center for Scientific Research (CRNS) and located at the Annecy Laboratory for Particle Physics (LAPP) in the French Alps. He also is a member of the French delegation to the C++ Standards Committee... Read More →

Thursday September 17, 2020 09:00 - 10:00 MDT
destroy_n()

• Future of C++

Level Advanced, Expert
Tags domain specific langauge, linear algebra, mdspan, non-type template parameters, numerics

10:05 MDT

BoF: Bazel Builds

Mark has requested a Birds of a Feather meeting for attendees interested Bazel builds.

We will hold this BoF in a Zoom meeting.

Topic: Bazel Builds BoF
Time: Sep 17, 2020 05:00 PM LondonJoin Zoom Meeting
https://zoom.us/j/93200206644?pwd=V3lzSG1Ybm5BODlZYWZsQnlEZFh2UT09

Meeting ID: 932 0020 6644
Passcode: 346349

Attendees interested in discussing Bazel builds and other tools, can join the discussion channel at #sig_tooling.

Speakers

Mark Zeren

Sr. Staff, VMware Inc.

Mark is a staff engineer at VMware where he works on Bazel builds, C++ libraries, coding standards, and toolchains.

Thursday September 17, 2020 10:05 - 10:25 MDT
_1

• Compilers/Tooling

10:30 MDT

Neighborhoods Banding Together: Reasoning Globally about Programs

Our most detailed reasoning about programs is done locally: we consider a neighborhood of a program — usually a single function and the interfaces surrounding it — and reason about its behavior without reference to the remainder of the program. But this reasoning is in service of a larger goal: we want to ensure that the entire program behaves correctly.

In this talk, I will take local reasoning for granted, and look at the process of joining neighborhoods of local reasoning together, and the global reasoning that ensures they form a coherent whole. I will show how we can prevent incoherent joining, and prevent the emergence of unbounded non-local recursion as the program is linked together.

This talk builds upon the discussion of local reasoning in last year's talk "The Truth of a Procedure,” but is intended to be understandable independently.

Speakers

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 →

Thursday September 17, 2020 10:30 - 11:30 MDT
all_of()

• Design

Tags assertions, correctness, indirect calls, interfaces, recursion

10:30 MDT

[Overflow] Neighborhoods Banding Together: Reasoning Globally about Programs

If the all_of() track is full, then join us in generate_n() as the overflow room.

Our most detailed reasoning about programs is done locally: we consider a neighborhood of a program — usually a single function and the interfaces surrounding it — and reason about its behavior without reference to the remainder of the program. But this reasoning is in service of a larger goal: we want to ensure that the entire program behaves correctly.

In this talk, I will take local reasoning for granted, and look at the process of joining neighborhoods of local reasoning together, and the global reasoning that ensures they form a coherent whole. I will show how we can prevent incoherent joining, and prevent the emergence of unbounded non-local recursion as the program is linked together.

This talk builds upon the discussion of local reasoning in last year's talk "The Truth of a Procedure,” but is intended to be understandable independently.

Speakers

Lisa Lippincott

Software Architect, Tanium

Thursday September 17, 2020 10:30 - 11:30 MDT
generate_n()

• Design

Level Intermediate, Advanced, Expert
Tags assertions, correctness, indirect calls, interfaces, recursion

12:00 MDT

C++20 Ranges in Practice

Among the many new additions to C++20 are Ranges, a modern revision of the STL offering updated algorithms and new “views” with lazy evaluation.

In this example-based talk we’ll work through several practical demonstrations of how the new Ranges functionality may be used to solve everyday problems concisely, elegantly and efficiently. In addition, we’ll offer tips on how to avoid common errors in your Ranges code, and demonstrate a couple of useful utility functions which you can drop into your codebase today.

Speakers

Tristan Brindle

C++ London Uni

Tristan Brindle is a C++ consultant and trainer based in London. With over 15 years C++ experience, he started his career working in high-performance computing in the oil industry in Australia before returning home to his native UK in 2018. He is an active member of the ISO C++ Standards... Read More →

Thursday September 17, 2020 12:00 - 13:00 MDT
generate_n()

• Algorithms/Functional

Level Beginner, Intermediate
Tags C++20, Standard Library, algorithms, ranges

12:00 MDT

Managarm: A Fully Asynchronous OS Based on Modern C++

C++20 and future C++ standards are expected to massively improve the ergonomics of asynchronous I/O within the C++ ecosystem. Yet, the vast majority of current operating systems (OSes) were designed without considering asynchronous I/O to be a first-class citizen. For example, Linux is only able to perform general-purpose asynchronous I/O since the recent addition of io_uring. Even with this new asynchronous mechanism in place, many I/O operations still have to fall back to a thread-based emulation within the kernel.

In this talk, we present Managarm, an OS designed around C++20 coroutines and the upcoming C++ sender/receiver model. Its main goal is to fully support asynchronous I/O through the entire system. All I/O operations are asynchronous in Managarm, with a single blocking system call to wait for their completion. The OS implements primitive asynchronous operations using (a variant of) the C++ sender/receiver model. These primitives comprise the system call layer and basic asynchronous data structures. We discuss how this low-level functionality can be integrated into high-level C++ code that is based on coroutines. High-level coroutine code constitutes the majority of the system and enables fully asynchronous drivers and servers. This approach enables high programmer productivity and excellent performance at the same time. At the end of the talk, we discuss open challenges for system programming that C++20 does not solve yet and give a perspective on vital future work in this area.

Speakers

Alexander van der Grinten

Postdoctoral Researcher, Humboldt-Universität zu Berlin

Alexander is a postdoctoral researcher at Humboldt-University of Berlin. He is also a founder of Managarm, a fully asynchronous operating system that is written in modern C++. Alexander obtained his PhD in computer science from University of Cologne in 2018. He is professionally... Read More →

Thursday September 17, 2020 12:00 - 13:00 MDT
destroy_n()

• Concurrent/Async/Parallel

Level Intermediate, Advanced
Tags asynchronous I/O, coroutines, executors, operating systems, sender/receiver

12:00 MDT

The Surprising Costs of void() (and Other Not-Quite-Innocuous Evils)

There are some things that might pass us by without us noticing them as evil or, as they have come to be known, Bad Code Smells.

Many of these little things are acceptable in some cases, and thus pass unnoticed in some code reviews. They are respectful of language rules, and thus pass unnoticed through the compiler's virtual hands. They might even lead to working code... and if it works, it's fine, no?

The idea for this talk came about when discussing with colleagues about such suspicious code and coding patterns, and hearing such questions as "but why is that a problem?". It's about those little evils that creep in code and poison our practice in subtle ways (making memory consumption higher than it should be, making execution slower than it should be, making reuse harder than it should be, etc.).

Speakers

Patrice Roy

Professor, Université de Sherbrooke

Thursday September 17, 2020 12:00 - 13:00 MDT
count_if()

• Deep Magic

Level Intermediate
Tags SG20, code quality

12:00 MDT

Back to Basics: Design Patterns

Design Patterns are reusable elements of design that may help aid in making software more maintainable, flexible, and extensible. The term 'design patterns' can be traced back to at least the 1970s, although the term has been largely popularized by the 'Gang of Four' book Design Patterns, in which common software design patterns were defined and categorized. In this talk, you will learn the fundamentals of the creational, structural, and behavior design patterns. This talk is aimed at beginners who have some C++ knowledge working on a software project, but are starting to think about larger software problems. This talk will also be useful for folks who have been working in C++ for a while, but have never had a chance to study design patterns and need some resources to help orient them.

Learning about design patterns and where to apply them can at the least give you a way to think about how you solve unknown problems, or otherwise organize your software--think about design patterns as another tool to add to your developer toolbox. We will start this talk by introducing the taxonomy of design patterns at a high level, how to read a UML diagram (as a quick refresher), a refresher on inheritance vs composition, and then spend the rest of the time on walking through the implementation of several design patterns. Attendees will leave this talk ready to implement and use design patterns in C++.

Speakers

Mike Shah

Professor / (occasional) 3D Graphics Engineer, Northeastern University

Mike Shah is an Associate Teaching Professor at Northeastern University in the Khoury College of Computer Sciences. His primary teaching interests are in computer systems, computer graphics, and software engineering. His research interests are related to performance engineering (dynamic... Read More →

Thursday September 17, 2020 12:00 - 13:00 MDT
Back to Basics

• Design

Level Beginner
Tags Back to Basics, design patterns

12:00 MDT

Fuzzing Class Interfaces for Generating and Running Tests with libFuzzer

Although various frameworks support the writing of unit tests, creating a well designed effective unit test suite is still a non-trivial manual work. In this presentation we show how fuzzing can be used to automatically generate and run test cases based only on the class' interface.

Imagine you want test a container like the std::deque, essentially a vector of fix sized buffers with push/pop operations at both ends. You write tests for the empty container, then for push_back, but then how to continue? Write test for push_back then pop_back or push_back then pop_front and then push_front etc... We see that there is an explosion of the number of possible test cases with regarding all the interface operations. Should we write all the combinations of all interface calls? Is there a value writing a test with 5 or 15 push_backs? Will we miss to write test for 16 push_backs when the implementation is forced to allocate new block?

In this presentation we show a method when the clang libFuzzer library is used to generate and run unit test cases automatically based on the class interface description. Instead of using the libFuzzer generated byte string as an input, we interpret it as a list of member function calls and their arguments. Driven by the coverage guidance of libFuzzer, we are able to generate more and more complex combinations of interface calls. Giving optional preconditions for the interface functions we can filter out invalid combinations, like calling pop_back before inserting elements to a container. We check class invariants between every method call and various sanitizers can also be applied. The implementation uses only language native solutions, no code generations or external scripts are required.

Like other fuzzer solutions this automatic tester can run for arbitrary time to discover edge cases the programmer ignored. The close to minimal subset of discovered test cases providing the maximum coverage can be stored as a "regression test" to re-run later. The implemented prototype performed well both on artificial test cases and real world C++ containers. The prototype is available at: https://gitlab.com/wilzegers/autotest

Speakers

Barnabás Bágyi

Software Developer, Ericsson

Barnabás is a graduating master student at Eötvös Loránd University, Budapest. Currently he is working at Ericsson. He gained experience using C++ in the automotive and the telecom industry.

Thursday September 17, 2020 12:00 - 13:00 MDT
Fuzzing/Testing

• Testing

Level Intermediate, Advanced, Expert
Tags Clang/LLVM, fuzzing, libFuzzer, testing

13:30 MDT

Back to Basics: Move Semantics

Move semantics was one of the many powerful additions to C++11, solving several classes of programming problems that had vexed C++ developers for years. But move semantics can be easily misused, and the details are sometimes tricky to get right. This back-to-basics session will give you a solid foundation in move semantics, covering rvalue references, std::move, move constructors, and move assignment operators. More importantly, it will present a set of clear guidelines for when and how to use these tools, and describe some situations where move semantics are most useful. This session will be helpful both for those who are still learning how to write solid, robust C++ code, and for those who already know everything about move semantics and would like a refresher. Attendees will leave this session having learned, among other things, how to read code sprinkled with calls to std::move and how to write classes that behave correctly and efficiently when moved.

Speakers

David Olsen

Software engineer, NVIDIA

David Olsen has more than two decades of software development experience in a variety of programming languages and development environments. For the last seven years he has been the lead engineer for the NVIDIA HPC C++ compiler, focusing on running standard parallel algorithms on... Read More →

Thursday September 17, 2020 13:30 - 14:30 MDT
Back to Basics

Back to Basics

Level Beginner, Intermediate
Tags Back to Basics, move semantics

13:30 MDT

Monoids, Monads, and Applicative Functors: Repeated Software Patterns

Forget factories, singletons, and proxies; What are the real patterns in software development? This talk explores abstract mathematical structures that commonly recur in software development. Once a mind is trained to recognize these patterns, it becomes easy to identify the fundamental operations for domain specific classes and how to put the pieces together. This discussion is for those who enjoy math, abstract concepts, and expanding their minds.

Speakers

David Sankel

Principal Architect, Adobe

David Sankel is a Principal Scientist at Adobe 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. He is a frequent... Read More →

Thursday September 17, 2020 13:30 - 14:30 MDT
generate_n()

• Algorithms/Functional

Level Advanced, Expert
Tags functional, libraries, metaprogramming

13:30 MDT

Making Games Start Fast: A Story About Concurrency

A common complaint in game development is that games take to long to start up. Players hate it and developers waste a long time watching loading screens.
Last spring I dived into my game's startup code and figured out ways to shave tens of seconds out of the time to reach main menu, and was able to introduce similar benefits to most of our other titles by looking into threading efficiency.

In this port-mortem analysis, I will present the various steps I took to analyze concurrency, improve threading performance and reduce lock contention.
Attendees will be shown how Intel vTune can be used to profile threading issues, how "thread safe" APIs can be misleading and how re-architecturing code in a lock-free fashion can drastically improve throughput.
We will also briefly touch how user-facing application can cheat and achieve perceived speedups by knowing the users' workflow.

Speakers

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 September 17, 2020 13:30 - 14:30 MDT
destroy_n()

• Concurrent/Async/Parallel

Level Beginner, Intermediate, Advanced
Tags concurrency, games, post-mortem

13:30 MDT

OO Considered Harmful

Is C++ on OO language? What does it mean to be an OO language anyway? What were the original goals, and how have they turned out?

What other approaches are there? Some say there was nothing wrong with Structured Programming and we should go back to that. Others push for a more Functional approach. There's also Logic Programming and others. Is there one right answer? Does it depend? Does it blend?

Experienced C++ programmers think of C++ as a Multi-Paradigm language, capable of moving between paradigms as needed. But is it particularly good at any particular one? Is that focus shifting? Where is it going, and why? What can we learn from other languages.

If all this sounds very abstract, be assured that we will look at real code and techniques you can apply today or, in some cases, the near future - as well as a glimpse of what may be down the road. More importantly we try to put it in a context that helps answer "why?"

Along the way we'll take a tour through C++'s approach to OO, Generic Programming and Functional Programming.

Speakers

Phil Nash

Developer Advocate, Sonar

Thursday September 17, 2020 13:30 - 14:30 MDT
count_if()

• Design

Level Beginner, Intermediate, Advanced, Expert
Tags functional, object-oriented, paradigms

13:30 MDT

The Science of Unit Tests

Unit testing has emerged as one of the foundations of modern software development. There are plenty of good talks on how to write tests, full of good advice, guidelines, and procedures: "Test using only the public interface", "Use Test-Driven Development", "Write Behavior-Driven Tests".

But what are the fundamentals that lie beneath all the good advice? What principles should guide our testing?

This talk will start by reviewing the basics of good testing, and then explore the close relationship between unit testing and the scientific method. Unit tests are, in some sense, small scientific instruments to detect phenomena in our source code. When seen in this light, we can start to see *why* the good advice we've been getting is good, and how an empirical approach can help guide decisions about what, when, and how to test our code.

Speakers

Dave Steffen

Software Lead, 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 →

Thursday September 17, 2020 13:30 - 14:30 MDT
Fuzzing/Testing

• Testing

Level Intermediate, Advanced, Expert
Tags behavior-driven development, testing

14:45 MDT

Supercharge your productivity with CLion and just a few easy tricks

Speakers

Phil Nash

Developer Advocate, Sonar

Thursday September 17, 2020 14:45 - 15:00 MDT
_1

15:00 MDT

Lightning Talks

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

Moderators

Michael Caisse

Ciere, Inc.

Thursday September 17, 2020 15:00 - 16:00 MDT
destroy_n()

• Education/Coaching

15:00 MDT

C++ Committee's Library Evolution Working Group

Come join the leaders of the C++ Committee's Library Evolution Working Group to discuss the latest developments in and future of the C++ Standard Library.

Moderators

Bryce Adelstein Lelbach

CUDA C++ Core Libraries Lead, NVIDIA

Speakers

Inbal Levi

Software Engineer, SolarEdge

Nevin Liber

Computer Scientist, Argonne National Laboratory

Nevin ":-)" Liber is a C++ Committee member and a veteran C++ developer, having first discovered the language over three decades ago while at Bell Labs. His professional career has taken him from operating systems to embedded systems, and from low latency trading platforms to analyzing... Read More →

Fabio Fracassi

Senior Lecturer, CODE University of Applied Sciences

Fabio has been a C++ Enthusiast for over a decade. He was initially drawn by graphical user applications, especially in the medical field, but started to focus on development processes and software quality more and more over the Years.He is now working as a university instructor... Read More →

Thursday September 17, 2020 15:00 - 16:00 MDT
count_if()

• Future of C++

15:45 MDT

ArcGIS Runtime for Qt

A brief introduction to the ArcGIS Runtime SDK for Qt

This will be a 10 minute presentation, followed by a 5 minute Q/A session.

* This session will be held in the Esri Expo Room. *

Speakers

James Ballard

Developer Lead, esri

Lead Software Engineer for the ArcGIS Maps SDK for Qt.https://developers.arcgis.com/qt/

Thursday September 17, 2020 15:45 - 16:00 MDT
_1

• Deep Magic

16:00 MDT

C++ Pub Quiz

The Pub Quiz so nice, we're doing it twice! A new batch of questions for a new evening. You're welcome to join us no matter whether you attended Wednesday evening's session or not. You're encouraged to mix up the existing teams and choose new team names. Teams are also encouraged to leave an empty chair at their table; you never know who might drop in during the game!

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!

Staff

Arthur O'Dwyer

C++ Trainer

Thursday September 17, 2020 16:00 - 18:30 MDT
generate_n()

Social

16:15 MDT

Student Reception

An opportunity for student attendees and CppCon student program coordinators to informally meet in the Hallway Track. Come in, have a seat, move around to different tables as you like, and get to know each other in a virtual setting. We'll meet on the top floor (10th) and imagine a view of the Rocky Mountains and the Denver skyline.

Note that this event targets students, but anyone that wants to engage with students is welcome.

(If the 10th floor overflows, meet on the 9th.)

Thursday September 17, 2020 16:15 - 17:45 MDT
Hallway Track

Social

07:45 MDT

ArcGIS Runtime for Qt

A brief introduction to the ArcGIS Runtime SDK for Qt

This will be a 10 minute presentation, followed by a 5 minute Q/A session.

* This session will be held in the Esri Expo Room. *

Speakers

James Ballard

Developer Lead, esri

Lead Software Engineer for the ArcGIS Maps SDK for Qt.https://developers.arcgis.com/qt/

Friday September 18, 2020 07:45 - 08:00 MDT
_1

• Deep Magic

08:00 MDT

BoF: Functional Programming

Nathan has requested a Birds of a Feather meeting for attendees interested functional programming.

We will hold this BoF in a Zoom meeting. To join the Zoom Meeting
https://zoom.us/j/93313834474?pwd=Z1lUY2dvaUh6NU1VZ0FNVUlhM0tNQT09

Attendees interested in discussing functional programming, can join the discussion channel at #sig_functional_programming.

Moderators

Nathan Ward

Software Engineer, Quantlab

C++, functional programming, Rust, Game Dev

Friday September 18, 2020 08:00 - 08:45 MDT
_1

• Algorithms/Functional

08:00 MDT

BoF: Game Development

Colleen has requested a Birds of a Feather meeting for attendees interested game development.

We will hold this BoF in a Zoom meeting. To join the Zoom Meeting
https://zoom.us/j/93793148520?pwd=TDgzSXk1eThSbE1ReWU5KytOUmI0QT09

Attendees interested in discussing game development, can join the discussion channel at #sig_game_development.

Speakers

Colleen Finnegan

Digital/Micropro HW, Sr, Mitre

Friday September 18, 2020 08:00 - 08:45 MDT
_1

• Deep Magic

09:00 MDT

Structure and Interpretation of Computer Programs: SICP

This talk will summarise what can be learned from the infamous MIT textbook the Structure and Interpretation of Computer Programs, the book that some engineers have referred to as their "bible." Concepts that are taught in the book will be shown in modern C++ (as opposed to Scheme or a LISP dialect that is used in the textbook). Some of the concepts include: functions, higher order functions, abstract data representations, concurrency & streams and metalinguistic abstraction.

This is the first book that the The Programming Languages Virtual Meetup (PLVM) worked their way through. The PLVM had their first meeting in May 2020 and have been working their way through the book since then.

Link to free copy of SICP: https://web.mit.edu/alexmv/6.037/sicp.pdf)
Link to PLVM: https://www.meetup.com/Programming-Languages-Toronto-Meetup

Speakers

Conor Hoekstra

Senior Library Software Engineer, NVIDIA

Conor (he/him) is a Senior Library Software Engineer at NVIDIA working on the RAPIDS team. He is extremely passionate about programming languages, algorithms and beautiful code. He is the founder and organizer of the Programming Languages Virtual Meetup, he has a YouTube channel and... Read More →

Friday September 18, 2020 09:00 - 10:00 MDT
destroy_n()

• Algorithms/Functional

Level Beginner, Intermediate
Tags Scheme, education, lisp, programming languages, racket

09:00 MDT

Adventures in SIMD-Thinking (part 1 of 2)

SIMD capabilities are virtually ubiquitous in modern computing hardware, and yet much of that computing capacity often goes unused. This talk will provide a high-level overview of the SSE, AVX, and AVX-512 instruction set architecture provided by Intel microprocessors, and provide some specific examples of real-world problems where additional performance can be gained by thinking "vertically".

We'll begin with a quick, high-level description of the features provided by the SSE, AVX, and AVX-512 instruction sets. We'll then use C++ to compose a simple API employing various compiler intrinsics implementing those instruction sets. At the lowest level, the API will wrap some primitive operations, and then build some very useful basic operations (like multi-register shift) upon those primitives. We'll then build some facilities for comparison and arithmetic, and finally round out the API with functions for load and store. During all of this, we'll use C++ to provide type safety, reduce complexity, and maximize performance.

Next, we'll take a look at how this simple API can be used to improve performance for a handful of interesting problems, like sorting the values stored in a register to create a very fast 1-D median filter, or high-speed convolution and correlation with kernels that fit within a single register. Finally, we'll revisit the UTF-8 to UTF-32 conversion techniques presented at CppCon two years ago to see whether using AVX can make an already fast conversion algorithm even faster.

Speakers

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Friday September 18, 2020 09:00 - 10:00 MDT
Embedded

• Concurrent/Async/Parallel

Level Beginner, Intermediate, Advanced
Tags AVX, SIMD, low level

09:00 MDT

Taskflow: A General-purpose Parallel and Heterogeneous Task Programming System Using Modern C++

The Taskflow project addresses the long-standing question: "How can we make it easier for developers to write parallel and heterogeneous programs with high performance and simultaneous high productivity?" Modern scientific computing relies on a heterogeneous mix of computational patterns, domain algorithms, and specialized hardware to achieve key scientific milestones that go beyond traditional capabilities. However, programming these applications often requires complex expert-level tools and a deep understanding of software methodologies. Specifically, the lack of a suitable software environment that can overcome the complexity of programming large parallel and heterogeneous systems has posed a significant barrier for many organizations to facilitate transformational discoveries.

Taskflow develops a simple and powerful task programming model to enable efficient implementations of heterogeneous decomposition strategies. Our programming model empowers users with both static and dynamic task graph constructions to incorporate a broad range of computational patterns including hybrid CPU-GPU computing, dynamic control flow, and irregularity. We develop an efficient heterogeneous work-stealing strategy that adapts worker threads to available task parallelism at any time during the graph execution. We have demonstrated promising performance of Taskflow on both micro-benchmark and real-world applications. As an example, we solved a large machine learning workload by up to 1.5× faster, 1.6× less memory, and 1.7× fewer lines of code than two industrial-strength systems, oneTBB and StarPU, on a machine of 40 CPUs and 4 GPUs.

This talk will cover three aspects: (1) heterogeneous task programming model using modern C++, (2) an efficient work-stealing strategy generalizable to arbitrary heterogeneous domains, and (3) user experience we have obtained and suggested roadmap for C++ in face of future heterogeneity.

The Taskflow project is available at https://taskflow.github.io/

Speakers

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 →

Friday September 18, 2020 09:00 - 10:00 MDT
Fuzzing/Testing

• Concurrent/Async/Parallel

Level Beginner, Intermediate, Advanced
Tags modern C++, parallel and heterogeneous programming, task parallelism

09:00 MDT

Retiring the Singleton Pattern: Concrete Suggestions for What to use Instead

“The worst part of this whole topic is that the people who hate singletons rarely give concrete suggestions for what to use instead.” - stackoverflow

In this talk, we will explore just such an approach that will transform currently untestable code containing underlying singletons with a fully testable solution. These code changes are transparent to the original callers of that function so no calling code changes are required.

This approach will be further expanded to handle multiple interdependent singletons. The replacement of error prone specific order of initialization calls to the singletons will be exchanged for "hard to misuse" automatic initialization using features of the language.

A host of other potential real world problems with replacing singletons are shown with solutions presented for both legacy and modern C++.

This alternative approach has been successfully employed in multiple areas in Bloomberg where developers believed there was no other feasible choice.

Speakers

Peter Muldoon

Senior Engineering Lead, Bloomberg

Pete Muldoon has been using C++ since 1991. Pete has worked in Ireland, England and the USA and is currently employed by Bloomberg as a senior Engineering Lead. A consultant for over 20 years prior to joining Bloomberg, Peter has worked on a broad range of projects and code bases... Read More →

Friday September 18, 2020 09:00 - 10:00 MDT
count_if()

• Design

Level Beginner, Intermediate, Advanced, Expert
Tags dependency injection, design patterns, legacy

09:00 MDT

Halide: A Language for Fast, Portable Computation on Images and Tensors

Halide is an open-source, domain-specific language for optimizing image processing, machine learning, and general array processing. It is used by major companies like Google, Adobe, and Qualcomm to optimize performance-critical software. It processes every photo taken with a Pixel phone, composites layers in every Photoshop document, and handles video processing at scale at YouTube.

We will explore how Halide achieves top-tier performance in a fraction of the development time by separating the algorithm (what to compute) from the schedule (how to optimize it). Halide's schedules determine trade-offs between parallelism, vectorization, cache locality, and memory management in a simple, modular way. Programmers can easily target different CPUs and GPUs by writing multiple schedules. Halide integrates tightly with C++ and provides both a JIT and a C++ compatible ahead-of-time compiler.

Speakers

Alex Reinking

Programming Languages Researcher, UC Berkeley

Alex is a Ph.D. student at UC Berkeley working with Jonathan Ragan-Kelley on designing domain-specific languages for high-performance computing. He has previously worked at Microsoft Research and Facebook AI+R. He holds an MS in Computer Science from UC Berkeley and a BS in Computer... Read More →

Friday September 18, 2020 09:00 - 10:00 MDT
generate_n()

• GPU/Graphics Programming

Level Intermediate, Advanced
Tags domain specific langauge, high-performance computing, image analysis, scientific computing

09:00 MDT

Back to Basics: Exceptions

Exceptions are the native error propagation mechanism in C++. If used properly, exceptions enable us to write simpler, more readable and more robust code. However, the path there can be tricky and unfortunately the exception mechanism isn't without flaws. This talk sheds somelight on the current issues with exceptions and why a large part of the C++ community isn't using them. It also gives guidelines and best practices on how to deal with exceptions and how touse them properly. It will go into detail about the exception safety guarantees, explains the tradeoffs between them, and demonstrates by example the individual steps necessary to reach them.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Friday September 18, 2020 09:00 - 10:00 MDT
Back to Basics

• Safety/Error Handling

Level Beginner, Intermediate
Tags Back to Basics, RAII, error handling, exception handling, readability, robustness

10:00 MDT

AMA: Klaus Iglberger

Join Klaus Iglberg for an open question session.

Klaus offers training in C++ is the author of the Blaze C++ math library.

Speakers

Klaus Iglberger

C++ Trainer/Consultant, Freelancer

Friday September 18, 2020 10:00 - 10:20 MDT
Back to Basics

• Education/Coaching

10:00 MDT

AMA: Peter Muldoon

Join Peter Muldoon for an open question session on removing singletons from code bases.

Speakers

Peter Muldoon

Senior Engineering Lead, Bloomberg

Friday September 18, 2020 10:00 - 10:20 MDT
count_if()

• Education/Coaching

10:30 MDT

Adventures in SIMD-Thinking (part 2 of 2)

Speakers

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Friday September 18, 2020 10:30 - 11:30 MDT
Embedded

• Concurrent/Async/Parallel

Level Beginner, Intermediate, Advanced
Tags AVX, SIMD, low level

10:30 MDT

Back to Basics: Concurrency

One of C++11's flagship features was the introduction of std::thread, along with a complete suite of synchronization primitives and useful patterns such as thread-safe static initialization. In this session, we'll motivate C++11's threading model and explain how to use std::thread effectively. We'll compare and contrast the C++11 synchronization primitives (mutex, condition variable, reader-writer lock, and once-flag) as well as the primitives that are new in C++20 (semaphore, latch, and barrier). In particular, we'll show how to make a mutex and a condition variable work together.
When using threads, it's important to avoid shared mutable state. We'll show how to tame that state via the "blue/green deployment" pattern, and briefly discuss how to use std::future and std::async to safely handle threads that produce answers.
Attendees will leave this session with a strong grasp on "multithreading tactics" in C++11 and beyond.

Speakers

Arthur O'Dwyer

C++ Trainer

Friday September 18, 2020 10:30 - 11:30 MDT
Back to Basics

• Concurrent/Async/Parallel

Level Beginner, Intermediate
Tags Back to Basics, concurrency, concurrency

10:30 MDT

Not Leaving Performance On The Jump Table

In this laptop I will use to talk to you, std::function is measured to have, for normal use cases, a latency overhead of over 79% for dispatching compared to just using function pointers. Our colleagues at Facebook improve in folly::Function by over 14%, however the open source Zoo libraries’ implementations I will talk to you about improves upon folly’s at least another 24% (35% over libc++) while at the same time dramatically reducing the object code size and allowing lots of practical features being proposed for what Arthur O’Dwyer calls “the design space of std::function“, all with top performance. When I report these findings colleagues have a hard time believing them, the presumption is by this time we should know well how to implement this with nearly theoretical maximum performance; then I must be wrong, my implementation has got to be severely flawed in some way... yet this library is used extensively in a mobile app that has over 200 million daily active users, in Android, iOS, and Windows, Mac OS X apps.

The improvements come from performance oversights that indeed have lasted for decades, once I tell you what they are, together with simple yet rigorous benchmarks and compiler explorer links, you will have no trouble to understand the improvements and realizing there are general principles we could learn from. That’s what this presentation is about.

Improving std::function is just the tip of the iceberg, when it comes to dispatching to behavior specified at runtime, there are many performance mistakes concerning the design of callbacks, event subscription/publishing mechanisms, and even the very language supports runtime polymorphism in a way that is very hostile to performance, among other problems. I hope to tell you all about the solutions we have found for these problems in the presentation “Type Erasing The Pains Of Runtime Polymorphism”, here we will focus exclusively on attaining nearly maximal performance while dispatching to runtime specified user code.

The techniques to be discussed are not processor architecture specific but general, directly applicable to components such as std::function, std::variant, their hybrids, throwing exceptions, error handling, the visitor design pattern, and the whole of runtime polymorphism. Furthermore, the examples are from real life improvements.

Speakers

Eduardo Madrid

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 September 18, 2020 10:30 - 11:30 MDT
generate_n()

• Deep Magic

Level Intermediate, Advanced, Expert
Tags benchmarking, callback design, calling convention, runtime polymorphism, type erasure, vtable

10:30 MDT

Lakos’20: The “Dam” Book is Done!

Writing reliable and maintainable C++ software is hard. Designing such software at scale adds a new set of challenges. Large-scale systems require more than just a thorough understanding of the logical design concepts addressed in most popular texts. To be successful on an enterprise scale, developers must also address physical design, a dimension of software engineering that may be unfamiliar even to expert developers.

After more than two decades in the making, Large-Scale C++, Volume I: Process and Architecture, is finally here. Drawing on his over 30 years of hands-on experience building massive, mission-critical enterprise systems, John Lakos, using select excerpts from this glisteningly new volume, elucidates the essential value of (and several techniques needed for) creating and growing hierarchical reusable software a.k.a. Software Capital as the foundation for developing C++ software at virtually unbounded scale.

Speakers

John Lakos

Software Engineer, Bloomberg

John Lakos, author of Large-Scale C++ Software Design [Addison-Wesley, 1996], serves at Bloomberg LP in New York City as a senior architect and mentor for C++ software development worldwide. He is also an active voting member of the C++ Standards Committee’s Evolution Working... Read More →

Friday September 18, 2020 10:30 - 11:30 MDT
destroy_n()

• Design

Level Intermediate, Advanced, Expert
Tags architecture, large-scale, physical design, process, software engineering

10:30 MDT

Exceptions Under the Spotlight

The exceptions mechanism is a complex topic and has been enthusiastically discussed in the last WG21 committee meeting.

In this talk we will dive into the world of exceptions.

We will start by understanding the error handling mechanism.

We will explore the evolution of exceptions, and the design decisions that led to the current version.

Next, we will see its usage as part of the program, and analyze the overhead by breaking the exceptions mechanism to bits.

Last, we will describe and analyze the alternatives, and potential directions for the exceptions mechanism in a future C++ versions.

Speakers

Inbal Levi

Software Engineer, SolarEdge

Friday September 18, 2020 10:30 - 11:30 MDT
Fuzzing/Testing

• Embedded

Level Intermediate, Advanced
Tags control-flow, embedded, errors, exception handling, performance, run-time

12:00 MDT

The Networking TS from Scratch: I/O Objects

The facilities of the Networking TS provide a framework within which testable, extensible, asynchronous programs may be written in C++. Alongside this the Networking TS provides concrete “I/O object” types which provide means of performing I/O and thereby allow the authoring of such programs immediately.

Invariably these provided I/O objects will not be sufficient. Datagram and stream sockets do not describe the entire universe of asynchronous I/O. When the time comes to author new I/O objects it will be important to do so within the framework of the Networking TS thereby providing facilities ripe for reuse and composition.

The talk will explore the task of authoring new I/O object types by motivating and illustrating the facilities and patterns the Networking TS provides for this purpose.

Speakers

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 →

Friday September 18, 2020 12:00 - 13:00 MDT
generate_n()

• Concurrent/Async/Parallel

Level Intermediate, Advanced, Expert
Tags I/O, asynchronous, low level, networking

12:00 MDT

Some Things C++ Does Right

People often complain about C++: to some, it's not memory-safe enough, not type-safe enough. Some will tell you that some (or all!) of its defaults are wrong. Many complain that it's too expert-friendly.

There's often a grain of truth in criticism, and C++ surely has a bit of each of these alleged warts; it's a language that has history, obviously, and that has evolved organically over the years, and it has the imperfections we can expect for a tool used by millions to perform high-performance or safety- critical tasks in various application domains.

However, there are a significant number of things C++ does right, and there are a number of reasons why we love this language... and love it so much that we gather together to trade ideas, learn about it, understand it better... and enjoy it all!

This talk is about some of the things C++ does right. It does not aim to provide an exhaustive list (far from it!), or to throw arrows at other languages (although there will be comparisons), nor does it aim to offer an apologetic perspective on C++. This talk is about some of those things one misses when using other languages, and aims to remind us of some of those things that make C++ beautiful, fun and efficient.

Speakers

Patrice Roy

Professor, Université de Sherbrooke

Friday September 18, 2020 12:00 - 13:00 MDT
count_if()

• Design

Level Intermediate
Tags generic programming, object-oriented, value-based programming

12:00 MDT

How C++20 Changes the Way We Write Code

The upcoming C++20 standard is the biggest update in a decade. Its feature set and their impact on how we write C++ will be as large, and possibly larger than that of C++11.

In this talk we will look at how new features like concepts, coroutines, and modules will fundamentally change the way we design libraries, the way we think about functions, and even the way we compile our code. We will also mention some long-standing warts in C++ which are finally cured.

Speakers

Timur Doumler

Independent, Independent

Timur Doumler is the co-host of CppCast and an active member of the ISO C++ standard committee, where he is currently co-chair of SG21, the Contracts study group. Timur started his journey into C++ in computational astrophysics, where he was working on cosmological simulations. He... Read More →

Friday September 18, 2020 12:00 - 13:00 MDT
destroy_n()

• Future of C++

Level Beginner, Intermediate
Tags C++20, concepts, coroutines, modules, ranges

12:00 MDT

Functional Error and Optional-value Handling with STX

Error-handling is arguably the most divergent part of C++. Many coding guidelines partially allow exceptions or totally ban it and this leads to many projects supporting multiple error-handling interfaces such as exceptions, the error-prone c-style error-handling, and/or custom error-handling types. This also leads many C++ developers to not use exceptions and instead roll their in-house error and optional-value handling facilities which are duplicated across the ecosystem.

This divergence has birthed numerous projects like boost.expected, boost.outcome, boost.leaf, tl::optional, tl::expected, and many others that have done a great job at addressing these issues.

This talk introduces STX; a C++ library that tries to address some of these concerns with error and optional-value handling in the C++ ecosystem and also tries to unify some of these efforts/implementations.

Speakers

Basit Ayantunde

Student, University of Ilorin

Basit Ayantunde is an undergraduate at the University of Ilorin, Nigeria where he majors in Mechanical Engineering. Basit has 4 years of experience writing industrial software both as a contract software developer and intern. He is one of the C++Now 2020 scholars, he contributes to... Read More →

Friday September 18, 2020 12:00 - 13:00 MDT
Embedded

• Safety/Error Handling

Level Intermediate
Tags compatibility, embedded, error handling, tooling, type safety

12:00 MDT

Introducing Microsoft’s New Open Source Fuzzing Platform

This native code security talk is a joint presentation by Principals from Windows Security (COSINE) and Microsoft Research. The work by Google and other contributors to the llvm ecosystem on libfuzzer, ASan, and sancov have “shifted left” the field of fuzz testing from the hands of hackers and security auditors directly to CI/CD developers. Rather than waiting for an auditing gate, developers should be able to receive fuzz testing results directly from their build system: quickly, cheaply, and reliably without false positives. To this end, Microsoft is adopting this testing paradigm via continuous cloud-based fuzzing of dedicated test binaries.

Microsoft is currently fuzzing Windows continuously in Azure using libfuzzer and a fuzzing platform developed at Microsoft Research that we are releasing as Open Source at CppCon. Developers continuously building libfuzzer-based test binaries utilizing sanitizers and coverage instrumentation can now launch fuzzing jobs in the cloud with a single command line. This talk will introduce the framework and its capabilities including a live demo. Features include:

• Composable fuzzing workflows: Open Source allows users to onboard their own fuzzers, swap instrumentation, introduce corpora,
• Built-in ensemble fuzzing: By default, fuzzers work as a team that shares strengths, swapping inputs of interest between fuzzing technologies
• Programmatic triage & result deduplication: Get unique flaw cases that always reproduce
• On-demand live-debugging of found crashes: Summon a live debugging session on-demand or from your build system
• Observable & Debug-able: Transparent design allows introspection into every stage
• Detailed telemetry: Easily monitor all your fuzzing from ‘fuzztop’
• Fuzz on Windows & Linux OSes: Multi-platform by design
• Crash reporting notification callbacks: Currently supporting Microsoft Teams
• Code Coverage KPIs: Monitor your progress and motivate testing using code coverage as key metric

Speakers

Michael Walker

Senior Director, Microsoft

Mike Walker is a Senior Director at MSR Special Projects. Prior to joining Microsoft, Mike led DARPA’s Cyber Grand Challenge, a two-year $58M contest to construct & compete the first prototypes of reasoning cyberdefense systems. Mike has worked in a policy advisory role, testifying... Read More →

Justin Campbell

Microsoft

Justin Campbell is a Principal at Microsoft COSINE whose group is focused on Windows OS security: vulnerability testing at scale, sandboxing and mitigations. Justin was previously VP of Cyber Operations at Novetta and served as CTO at Ocean’s Edge.

Friday September 18, 2020 12:00 - 13:00 MDT
Fuzzing/Testing

• Testing

Level Intermediate
Tags fuzzing, sanitizers, testing

13:00 MDT

AMA: Patrice Roy

Join Patrice Roy for a hallway-style discussion on any topic such as:

C++ in academia
teaching C++
game development

Speakers

Patrice Roy

Professor, Université de Sherbrooke

Friday September 18, 2020 13:00 - 13:20 MDT
count_if()

• Education/Coaching

13:00 MDT

AMA: Timur Doumler

Join Timur Doumler for a free-wheeling hallway-style discussion.

Timur is a long time audio dev and is very active in the C++ developer community. Be sure to ask him about the Audio Developer Conference coming up in November!

Speakers

Timur Doumler

Independent, Independent

Friday September 18, 2020 13:00 - 13:20 MDT
destroy_n()

• Education/Coaching

13:30 MDT

Empirically Measuring, and Reducing, C++’s Accidental Complexity (“Simplifying C++” #7 of N)

We often hear “C++ is more complex than it needs to be,” typically demonstrated using anecdotes and “gotcha” examples. Those can be valid and demonstrate real pain points, but it would be nice to have more quantifiable data that we could analyze to measure sources of complexity. This talk reports work to systematically catalog and measure C++’s unneeded complexity, how some current evolution proposals may address its major sources, and presents specific suggestions on what we might be able to do about it in the context of a future-evolution proposal to simplify parameter passing and provide meaningful initialization guarantees in C++.

Speakers

Herb Sutter

Software architect, Standard C++ Foundation

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++.

Friday September 18, 2020 13:30 - 14:45 MDT
all_of()

• Future of C++

Level Intermediate, Advanced, Expert
Tags complexity, simplification

13:30 MDT

[Overflow] Empirically Measuring, and Reducing, C++’s Accidental Complexity (“Simplifying C++” #7 of N)

If the all_of() track is full, then join us in generate_n() as the overflow room.

We often hear “C++ is more complex than it needs to be,” typically demonstrated using anecdotes and “gotcha” examples. Those can be valid and demonstrate real pain points, but it would be nice to have more quantifiable data that we could analyze to measure sources of complexity. This talk reports work to systematically catalog and measure C++’s unneeded complexity, how some current evolution proposals may address its major sources, and presents specific suggestions on what we might be able to do about it in the context of a future-evolution proposal to simplify parameter passing and provide meaningful initialization guarantees in C++.

Speakers

Herb Sutter

Software architect, Standard C++ Foundation

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++.

Friday September 18, 2020 13:30 - 14:45 MDT
generate_n()

• Future of C++

Tags complexity, simplification

15:00 MDT

CppCon 2021 Kick-off Meeting / Feedback Session

Wow! CppCon 2020 was not what anyone would have expected a year ago. 😁
Who knows what CppCon 2021 will be like? You could help determine that.

Bob is going to moderate a Zoom meeting to discuss what went right and what went wrong at CppCon 2020 with an eye to what we want to create for CppCon 2021.

CppCon is and always has been a product by and for the C++ community. This is your chance shape that product for 2021.

Join Zoom Meeting
https://us02web.zoom.us/j/83727755426?pwd=WGV6M25SdGdJb05oTlI3ZG5DSVFKQT09

Moderators

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Friday September 18, 2020 15:00 - 16:00 MDT
_1

Business

08:00 MDT

CppCon 2021 Kick-off Meeting / Feedback Session

Moderators

Bob Steagall

Chief Cook and Bottle Washer, KEWB Computing

Saturday September 19, 2020 08:00 - 09:00 MDT
_1

Business

09:00 MDT

C++ Concepts: Constraining C++ Templates in C++20 and Before

C++ Concepts: Constraining C++ Templates in C++20 and Before is a two-day online training course with programming exercises taught by Mateusz Pusz. It is offered online from 11AM to 3PM Eastern Time (EDT), Monday September 21st and Tuesday September 22nd, 2020 (after the conference).

In order to be able to follow the workshop, you should be current with C++ and have some recent experience with writing simple C++ templates. C++11/14 knowledge is suggested but not mandatory.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Mateusz Pusz

Principal Engineer | C++ Trainer, Epam Systems | Train IT

Monday September 21, 2020 09:00 - 13:00 MDT
Classroom-Pusz

Class

09:00 MDT

Portable Parallelism using Modern C++ and Thread Building Blocks

Portable Parallelism using Modern C++ and Threading Building Blocks is a two-day online training course with programming exercises taught by Michael Voss and Pablo Reble. It is offered online from 11AM to 3PM Eastern Time (EDT), Monday September 21st and Tuesday September 22nd, 2020 (after the conference).

Knowledge of C++11/14 (including templates)
As an online class:
- A reliable internet connection is necessary
- The exact conference-call software will be announced later
To participate in hands-on examples:
- Option 1: (the primary delivery method): Using the Intel ® DevCloud for oneAPI
  - A limited, but hopefully sufficient, number of instances will be pre-arranged for attendee use
  - All necessary software will be pre-installed on those systems
- Option 2: On the attendee’s local system
  - A C++ compiler supporting C++14 or later
  - git
  - Due to time constraints, we will offer limited assistance for students that choose this option

Course and instructor details are available here.

This course requires separate registration which is available here.

Monday September 21, 2020 09:00 - 13:00 MDT
Classroom-Reble-Voss

Class

09:00 MDT

C++17: All You Need to Know

C++17: All You Need to Know is a two-day training course with programming examples taught by Vittorio Romeo. It is offered online from 11AM to 5PM Eastern Time (EDT), Monday September 21st through Wednesday September 23rd, 2020 (after the conference).

Good knowledge of C++11.

Course and instructor details are available here.

This course requires separate registration which is available here.

Monday September 21, 2020 09:00 - 15:00 MDT
Classroom-Romeo

Class

09:00 MDT

Classic STL: Algorithms, Containers, Iterators

Classic STL: Algorithms, Containers, Iterators is a three-day online training course with programming exercises taught by Arthur O’Dwyer. It is offered online from 11AM to 5PM Eastern Time (EDT), Monday September 21st through Wednesday September 23rd, 2020 (after the conference).

Attendees should have basic to intermediate knowledge of C++11, including at least one or two years of programming experience. A basic understanding of pointers, templates, data structures, and C++11 move semantics will be assumed.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Arthur O'Dwyer

C++ Trainer

Monday September 21, 2020 09:00 - 15:00 MDT
Classroom-ODwyer

Class

09:00 MDT

GPU Programming in Modern C++

GPU Programming in Modern C++ is a two-day training course with programming exercises taught by Gordon Brown and Michael Wong. It is offered online from 11AM to 5PM Eastern Time (EDT), Monday September 21st through Wednesday September 23rd, 2020 (after the conference).

This course requires the following:

Working knowledge of C++11.
Working knowledge of Git.
Working knowledge of CMake.

We will also encourage attendees to pre-setup a SYCL implementation on the laptop they attend with. Attendees will be contacted about this before the class.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Michael Wong

Distinguished Engineer, VP, Codeplay

Gordon Brown

Principal Software Engineer, Codeplay Software

Monday September 21, 2020 09:00 - 15:00 MDT
Classroom-Brown-Wong

Class

09:00 MDT

Modern C++ Template Common Knowledge

Modern C++ Template Common Knowledge is a two-day training course with programming exercises taught by Steve Dewhurst. It is offered online from 11AM to 5PM Eastern Time (EDT), Monday September 21st through Wednesday September 23rd, 2020 (after the conference).

Attendees should be experienced software developers with basic knowledge of C++ templates.

Course and instructor details are available here.

This course requires separate registration which is available here.

Speakers

Stephen Dewhurst

President, Semantics Consulting, Inc.

Monday September 21, 2020 09:00 - 15:00 MDT
Classroom-Dewhurst

Class

09:00 MDT

C++ Concepts: Constraining C++ Templates in C++20 and Before

Speakers

Mateusz Pusz

Principal Engineer | C++ Trainer, Epam Systems | Train IT

Tuesday September 22, 2020 09:00 - 13:00 MDT
Classroom-Pusz

Class

09:00 MDT

Portable Parallelism using Modern C++ and Thread Building Blocks

Knowledge of C++11/14 (including templates)
As an online class:
- A reliable internet connection is necessary
- The exact conference-call software will be announced later
To participate in hands-on examples:
- Option 1: (the primary delivery method): Using the Intel ® DevCloud for oneAPI
  - A limited, but hopefully sufficient, number of instances will be pre-arranged for attendee use
  - All necessary software will be pre-installed on those systems
- Option 2: On the attendee’s local system
  - A C++ compiler supporting C++14 or later
  - git
  - Due to time constraints, we will offer limited assistance for students that choose this option