Talks

Alexey will tell about some unusual applications of protection methods implemented in the MMU, ways to stimulate the interaction of hardware with the central processor through register files.

We will write stateful programs at compile time.

In this talk we will implement a design approach from Haskell, better known as Final Tagless. We will look at what it is and how Final Tagless can be expressed using concepts. We will build the simple eDSL on FT and discuss its properties.

In this talk Guy will fully describe the operation of linear algebra classes and functions, and describe how to customize the objects for particular domains.

In this talk Mateusz will summarize his experience and thoughts gathered during the implementation of the Physical Units Library for C++.

This talk will give an introduction how to write basic fuzz tests for your code. As well as how to integrate those fuzz tests into your CI. This talk also will give technical overview of how coverage guided fuzzing engines works in general.

The C++ Standard Library lacks a thread pool mechanism and it is not always convenient to use Boost, TBB or Qt for these purposes. This talk is about creating your own thread pool step by step without any dependencies except C++17.

Presenting a technique for assuring ABI compatibility for a closed-source library across environments and versions.

The talk presents solutions for three tasks taken from practice and have two common features: values used from several threads are passed through intermediate storage and solutions are mage general and can be tailored to various specific cases.

In this talk, we will overview the C++ ecosystem based on several independently conducted research studies (the most recent will be held at the beginning of 2020), identify the common aligning trends across all the sources, and analyze the reasoning behind them. We’ll also decompose the C++ development into top areas and will analyze C++ usage projected on them.

In this talk Victor will give a comprehensive overview of the the {fmt} library and the C++20 formatting library based on it.

Pavel will tell in detail how exactly C++ coroutines work, and what do we need to do to start using them easily and efficiently.

During this session you will hear about High-Frequency Trading (HFT) and its optimization, including tricks regarding coding and an extensive performance analysis.

In this talk, we will understand how to choose static, inline and constexpr specifiers when declaring a constant. We will compare different ways to declare string constants. As a result, we will come up with universal recommendations.

During this session Danila will consider the cases when C++ STL is fast and not enough — due to some standard reasons or compiler optimizations.

Alexey will tell about one of the main parts of modern C++ development — sanitizers and will share all secrets of working with AddressSanitizer.

This talk is devoted to such a seemingly well-established feature of C++ as thread_local. Despite that this feature was standardized in C++11, not a lot of people understand what machinery is under the hood. How and in what cases we have this functionality for free. And in which cases heavy artillery used.

Getting speed, customization, and flexibility out of a text interface for C++23.

During this session you will learn about the experience of implementing various sanitizers in large-scale Linux-based projects with subsequent support.

In this talk you will find an analysis of random testing, fuzzing and property testing, and also their use in KasperskyOS.

Drawing on his over 30 years of hands-on experience building massive, mission-critical enterprise systems, John Lakos — using never-before-seen 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.

Вместе с приглашенными экспертами обсудим вопросы обучения языку С++.

Ruslan will demonstrate the difference between static and dynamic reflection and also introduce us to syntactic constructions from the P1717 proposal to the C ++ standard and with its implementation.

Anton and Roman will talk about new proposal in the Standard — ultimate copy elision and show how it will improve the life of C++ developers.

What you will have to face when updating the compiler, and how to make this process less painful. Examples for gcc.

Talk is about several ways to speedup std::to_string of integers in libc++ standard library. Allocations optimization, naive approach, and std::to_chars are considered. We will take the careful investigation of why each algorithm is faster than the previous one with profiling results and performance tricks explanation.

Software for Linux is often distributed assembled for a specific version of a certain system. That's because under other systems the same binary will not launch. You built the program on your machine, do SCP on a server, but it doesn't start on the server. How to solve this problem? There are a lot of alternative ways and Alexey will tell about each of them.