Meeting C++ 2020 | Schedule | Speaker | Talks | Ticketshop | Sponsoring

40 Years Of Evolution from Functions to Coroutines

Speaker: Rainer Grimm

Audience level: Beginner | Intermediate

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

Template Shenanigans: Testing, debugging and benchmarking template code

Speaker: Jonathan O'Connor

Audience level: Beginner | Intermediate

Modern C++ is all about templates, but how do you develop that code? This talk looks at some simple and not so simple techniques and tools to help write correct and efficient template code. We look at some tricks to debug template code, both at compile and run time. Then we look at some techniques to test templated code. Finally, we investigate how to see what template instantiations the compiler creates.


How C++20 changes the way we write code

Speaker: Timur Doumler

Audience level: Beginner | Intermediate

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.

Lambdas, uses and abuses

Speaker: Dawid Zalewski

Audience level: Intermediate | Advanced

Lambdas are the powerhouse of modern C++. It's hard to imagine applying a standard algorithm without writing a lambda expression. Sadly, despite their versatility, that's also where lambdas end up most of the time. Yet, there is so much more.
This talk is about discovering the hidden potential of lambda expressions. After going through a range of common, unusual, and often unexpected usage patterns of lambdas you'll be better equipped to apply them in your projects.

We'll start with a review of the lambda syntax, including the newest C++20 additions. While doing so, we'll identify the opportunities for using lambdas to simplify existing code. This will be followed by more advanced topics including immediately invoked lambda expressions or lambdas that return lambdas to achieve levels of indirection previously available only to fully fledged classes. Finally, we'll explore the fascinating technique of inheriting from lambdas and demonstrate how it enables powerful abstractions (composition, recursion, partial application) that make applying design patterns like the chain of responsibility with lambdas trivial.


Partially-Formed Objects For Fun And Profit

Speaker: Marc Mutz

Audience level: Beginner | Intermediate | Advanced

Lately, partially-formed states have gained some traction as the natural state of moved-from objects. Alexander Stepanov, in his landmark book Elements of Programming (EoP), defines them as a state in which the only valid operations are assignment and destruction. This state was, and continues to be, essential to high-performance code, and to the C++ guarantee of "don't pay for what you don't use".


Calling Functions: A Tutorial

Speaker: Klaus Iglberger

Audience level: Beginner | Intermediate

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.


Hidden Features and Traps of C++ Move Semantics

Speaker: Nicolai Josuttis

Audience level: Beginner | Intermediate | Advanced

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 details of move semantics. And style guides still recommend different consequences for programming even of trivial classes. And even in the C++ community we still discuss semantic details.


The Static Initialization Order Fiasco - How to Properly Initialize Global State

Speaker: Jonathan Müller

Audience level: Beginner | Intermediate

Global variables are initialized before main() runs, but the relative initialization order is not necessarily well-defined. As such, accessing global state while you initialize your global variables, might not work the way you expect.

OO Considered Harmful

Speaker: Phil Nash

Audience level: Beginner | Intermediate | Advanced

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.


Building an Intuition for Composition

Speaker: Sy Brand

Audience level: Intermediate | Advanced

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


C++ Concepts vs Rust Traits vs Haskell Typeclasses vs Swift Protocols

Speaker: Conor Hoekstra

Audience level: Beginner | Intermediate | Advanced

C++20 comes with Concepts - one of the four major featurs of the C++20. This talk will explore what Concepts are and how to use them - and how they are different and similar to "adjacent" language features such as Rust Traits, Haskell Typeclasses and Swift Protocols. This talk will be a "must see" for programming language enthusiasts.