Basic usage of PMRs for better performance

Speaker: Marek Krajewski

Audience level: [ Beginner | Intermediate ]

The C++ allocators were a constant source of complaints, so in C++11, C++14 and C++17 there were a series of improvements which were introduced. Last one of them were polymorphic memory resources included in the C++17 standard. However, the PMRs seem to be perceived as a rather difficult and obscure topic.

Abstraction: The True Superpower Of C++

Speaker: Guy Davidson

Audience level: [ Beginner | Intermediate | Advanced ]

What do we mean by abstraction, and why is C++ so good at providing them?

Lets Talk: Extend and Embed Python with C++

Speaker: Rainer Grimm

Audience level: [ Beginner | Intermediate ]

Python is very communicative. On the one hand, it is very easy to call C++ functionality from Python (extend), and on the other hand, Python can be used directly from a C++ runtime (embed). Extending allows you to offload performance-critical parts of your program to C++ or to overcome the GIL (global interpreter lock) in Python. Thanks to embedding a Python interpreter in your C++ application, the C++ application has a scripting interface.


Standard C++ toolset

Speaker: Anastasia Kazakova

Audience level: [ Beginner | Intermediate ]

Programming languages nowadays are often packed with a standard set of tools that form an ecosystem around it. Compilers and debuggers, static analyzers, build systems, dependency managers, and unit testing frameworks are essential for adoption and evolve with the language.

Nth pack element...: A Case Study

Speaker: Kris Jusiak

Audience level: [ Intermediate | Advanced ]

Varadic packs have been with us since C++11, however getting the nth element efficiently out of a variadic pack still remains not optimal/difficult.
During the years, with new standards emerging, more and more approaches have been discovered but no silver bullet has been found yet or has it?
If understanding of how std::get<N>(tuple) works sounds compeling then this session is for you!

In this case study we will explore different techniques of accessing the nth element of a variadic pack... starting from naive aproaches, through template meta-programming tricks, to compiler intrinsics. We will also focus and deep dive into C++20 features which enables new techniques in order to understand modern ways of dealing with varadic packs...
Comparison against different solutions also will be conducted including compilation times as well as readability.

At the end of this session, the audience will have a better understanding of C++20 features and how to deal with variadic packs...

Let's get ready to get all elements at Meeting C++ 2022!


How C++23 changes the way we write code

Speaker: Timur Doumler

Audience level: [ Beginner | Intermediate ]

C++20 was a huge release: coroutines, concepts, ranges, and modules profoundly changed the way we write code and think about C++. In comparison, C++23 is a lot smaller in scope: its primary mission is to complete C++20, to fill holes, and to fix issues. Nevertheless, some great new features made the cut this time around, both in the standard library and in the core language. This is even more remarkable considering that the entire feature design phase of C++23 took place during the COVID-19 pandemic, challenging the ISO C++ committee to completely reinvent how we work together.


Petri nets: What are and how can help us

Speaker: Gabriel Emanuel Valenzuela

Audience level: [ Beginner ]

A Petri net is a particular type of directed bipartite graph (or digraph) together with an initial state called initial mark. It contains two types of nodes, places and transitions. The idea of this talk is to develop the essential concepts of petri nets, to demonstrate how it can be expressed mathematically and its applications in computer science.

std::execution from the metal up

Speaker: Paul Bendixen

Audience level: [ Intermediate | Advanced ]

Asynchrony is a very important part of modern computing, from handling interrupts to reading from disks and networking.

Coroutines, from scratch

Speaker: Phil Nash

Audience level: [ Intermediate | Advanced ]

C++ 20 introduced coroutines into the language. Coroutines have the potential to greatly simplify some types of code - particularly, but not limited to, anything asynchronous in nature. But early adoption has been hindered by both the lack of library support in the standard and the inherent complexity of the feature itself (which, due to that lack of library support, you are typically more exposed to).


Just Enough Assembly for Compiler Explorer

Speaker: Anders Schau Knatten

Audience level: [ Beginner ]

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

Living comfortably at HEAD with Bazel

Speaker: Šimon Tóth

Audience level: [ Beginner | Intermediate ]

Polyrepo environments have been gaining popularity as the ergonomics of package managers such as Conan or vcpkg improve, giving teams the desired autonomy and independence. Despite that, a polyrepo environment is not a one size fits all solution. Choosing a monorepo might be the perfect match for your organization.

Enough TMP to write a variant (proper) with C++20

Speaker: Denis Yaroshevskiy

Audience level: [ Beginner | Intermediate ]

Writing a variant is one of the more popular exercises in Tempate Meta Programming (TMP). We are going to have a look at problems that are commonly ommitted by the explanations: a.i. harder parts of visit (multiple-dispatch, return type deduction, sfinae, noexcept) and constexpr support. The talk aims at people who do not have prior TMP expirience: one should be able to get the gist and have some key takeaways regardless of the prior expirience. More expirienced people might be interested in seeing how almost clean the modern implementation is compared to the nightmare of 11 (never mind 03).


C++ Standard Parallelism

Speaker: David Olsen

Audience level: [ Beginner | Intermediate ]

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

Lambdas—how to capture everything and stay sane

Speaker: Dawid Zalewski

Audience level: [ Beginner | Intermediate ]

Lambdas have been around for over a decade. Yet, as they continue to rapidly evolve, the understanding of how some of their features work is far from widespread among developers. Not surprisingly, given that even such routine tasks as capturing are governed by complex and ever-changing rules.

Experimenting with type erasure/external polymorphism in C++17

Speaker: Olivia Quinet

Audience level: [ Beginner ]

This talk showcases a concrete example, a SAS7BDAT file reader, using type erasure also known as external polymorphism design pattern. This work was originally inspired by a conference of Klaus Iglberger about Breaking Dependencies: Type Erasure - A Design Analysis.