Talks

Alexander will tell about present-day MessageMQ market and its most outstanding representatives, go over advantages and disadvantages of message brokers, taking into account local import substitution market. Of course, he'll also tell how he wrote his own message broker and why exactly he did it.

A look at common ways data and code are connected in an application, how those relationships are typically represented, and the problems caused by the use and misuse of these paradigms. Then we'll look at ways to model these relationships in C++ and use them to build correct applications.

Atypical and effective solutions for typical tasks:

• Pimpl — but without dynamic allocations;
• Fast logging — but usually without std::ostream and std::locale;
• Conversions from JSON/XML/YAML/... to user-defined types — but with code reuse (almost a function overloading by result type);

Eric Niebler digs into the Standard Committee's search for the basis operations that underpin all asynchronous computation. He will discuss why futures and promises are slow, what an executor is, what callbacks and coroutines have in common, and how the "Task" abstraction — under active R&D at Facebook — might do for async algorithms what the Iterator abstraction did for synchronous ones.

A couple of things about the C++ standard library implementation you might want to know. We'll discuss implementation details and how using of types and algorithms from the standard library may impact the performance of your application.

How C++20 will change the way we program modern C++.

With the linear algebra proposal making its way through the C++ standard committee, the authors are now considering teaching analytical geometry to C++. This talk will tell you about the progress to date.

We'll see how modules in C++ work, how they resemble and differ from similar concepts in other languages, what capabilities were included in the standard and how they will affect code that we write, discuss common misconceptions about modules (where they can and cannot help), look how they affect language tooling and to what extent they can accelerate compilation of real-life projects.

Björn will show modern C++ techniques enabling you to write your own zero-cost abstractions that help getting rid of the patterns that keep repeating in your code.

Based on their own experience of developing a static code analyzer, Andrey and his team came to the conclusion that only premature optimization of everything that is available can save us from continuous declining performance. Speaker would like to share thoughts and techniques that his team apply in the company.

We'll see how coroutines allow for cleaner code, easier abstraction and genericity, composition and avoiding callbacks and inversion of control.

Arno will talk about the main problems surrounding rvalue references and suggest the alternate solution with the help of the library-only approach.

This talk is a comprehensive overview of type punning techniques, including new ones introduced in C++20. We will discuss when and how they can be used safely without causing undefined behaviour, what C++ does and does not allow you to do (and why), existing holes in the C++ language, and how to fix them. In the process, we will cover important C++ concepts such as object lifetime, object representation, and aliasing rules.

The C++ standard library is used by all C++ programs; it needs to be as robust as possible. Marshall will talk about the techniques used by libc++ to ensure robustness. He will cover debug mode, test suites, static analysis, dynamic analysis, code coverage tools, and fuzzing.

C++20 introduces a range of number of new synchronization primitives designed for the modern era; in this talk, you'll learn how to use these new tools to write scalable C++ software.

We will use and explain many new C++ features like fold expressions, concepts, type lists and index sequences, and the code will extensively use move semantics to generate a cleaner assembly code for type instantiation.

С++ is often employed because of its high performance, but you can't achieve maximum performance without thoroughly analysing the code of your application. Alexander will review the process and patterns of performance optimizations.

In this talk, an approach based on thread specialization will be explored. In many cases it allows you to get rid of shared data and write multithreaded programs, asynchronous by nature, in such a way that they look sequential in the code.

Learn how to parse a regular expression pattern in compile-time and generate matcher with finite automaton.

Learn about how cursors and reactive lenses can help designing your code around value-semantics and functions, modernizing legacy code-bases and UI's otherwise written in a referential, object-oriented style.

A comparison between OpenCL, CUDA, C++ libraries and compiler toolchains for heterogeneous computing.

At one moment Timofey and his team realized that development of client application on C++ is long and expensive. And gradually began migrating products to the web. Speaker will tell how the team of C++ developers was able to quickly rewrite C++ code for web with help of Dart.

The talk about modules in C++ and their influence on core language.

The talk will be dedicated to the vcpkg and its pros and cons. We will consider these flaws and fix them, and our vcpkg system will be more competitive than Conan.

Karina will show and talk about the features of writing and building of C++ code with limited resources and the absence of the compiler.

Kirill Tikhonov will tell how to configure the infrastructure around the project and provide the painless service update.

Declaring a variable or a function in C++ might be tricky. When should we make it static and inline? const and constexpr? What about consteval and constinit? How do templates affect this? In this talk, Mikhail will try to sort out all this variety of concepts.

In this talk, Alexander will describe an approach to semi-automatic serialization through getters with help of metaprogramming.

Nikolay will tell how he and his team solved the problem of memory fragmentation and what limitation they had to face in the process.

Roman's talk will demonstrate when building your application with -fno-exceptions makes sense and when you can enjoy C ++ exceptions, knowing that the code has not lost performance.