Talks

GDB is more powerful than you probably think. Lots of short and simple examples demonstrating the more advanced features of GDB, Once you know about them you'll be able to debug more productively.

Ilya will tell you how understanding the principles of image processing, you can implement a utility in C++, which generates the entire world in a day. And how the approach to map generalization in 2GIS differs from others.

This talk will address some of the basic ways that design and invariants interact with long-term maintenance and optimization, and some heuristics for deciding whether adding a knob will turn out to be a mistake.

Find out what to expect over the next four days. The hosts will tell you about the schedule, interesting talks and what format they will be held in, as well as how our website works, where the discussions will be, how to connect to the chats, and where to ask questions of the speakers.

Sometimes we want some kind of magic that would call the appropriate handler for a request, and put appropriate request fields into function parameters. We want this magic more when the number of handlers with many parameters grows significantly. In this talk, we will concentrate on type erasure to make a convenient and user-friendly way of organizing request handlers.

Sergey will introduce you to Genode, an open-source framework for creating operating systems.

The evolution of the C++ Concurrency support doesn't stop there: the committee has a continuous stream of new proposals. This talk also introduced some of the most important of these, including the new Executor model.

C++ is written in very different fields - with different requirements, features, and complexities. And if you're not involved with compilers, you may have a rather vague idea of how the developers' work there is different from yours. Maybe you should just drop everything and go there. Or vice versa, it's not your thing at all, and С++ in this area aren't long for it?

Experienced people can help you figure this out. Let's talk about the peculiarities of this area with those who have spent more than a year in it: Evgeny Zuev and Pavel Kosov. And Alexey Veselovsky will help to lead this conversation.

In the last years, asynchronous engines with coroutines are gaining popularity in almost all programming languages. Let's look at how these engines work and what's good about them for I/O-bound applications.

A technical interview is a complicated thing in itself, and not everyone has any idea how it goes. And when the interview has a narrow focus, even more so. The architectural interview (System Design) is one of the most difficult, both for the candidate and the interviewer.

As part of the broadcast from the main studio, one of these interviews will be conducted by Alexander Granin. He will be considering a candidate Pavel Filonov from PC for a C++ developer position in the architecture area.

Let's see how the interview usually goes, what knowledge and skills the candidate needs, and at the same time analyze mistakes that can be made by both sides.

This talk is about the analysis of one problem that is often encountered in practice — the removal of a heavy operation from a UI thread. Another nontrivial part of working with background operations is the implementation of cancellation. We will take a look at how it all can be written one by one, with three main mechanisms of asynchronous programming.

The speaker will discuss the use of Lua scripts to implement typical patterns and solve typical problems in the field of IoT. The use of scripts allows you to increase the flexibility of the system, to easily adapt it to the needs of a particular customer, to avoid rewriting the source code many times when the requirements of the project change. The use of Lua scripts is considered on the example of a simple demo application developed in MFC for MS Windows. The application allows you to modify scripts "on the fly" and study how it affects the logic of the system.

Maksim will talk about how his team worked on JIT compilation of requests and operation GROUP BY in ClickHouse.

We will try to figure out what is wrong with assert, what is contract programming and how so-called right program looks like. We will have a look at the contracts which did not reach C++20, and we will also discuss what to do if we want contracts right now.

C++ is written in very different fields - with different requirements, features, and complexities. And if you're not involved in databases, you may have a rather vague idea of how the developers' work there is different from yours. Maybe you should drop everything and go there. Or, on the contrary, it's not your thing at all, and in general, C++ in this area is not long left?

Experienced people can help you sort this out. Therefore, let's talk about the peculiarities of this area with those who have spent more than a year in it: Konstantin Osipov, Alexei Milovidov and Andrey Aksenov. And Pavel Filonov will help to lead this conversation.

Evgeny will provide a deep dive into exception handling.

In this talk you'll learn the very basics of X86 Assembly and the X86_64 calling convention, just enough to understand the full Assembly listing of simple functions on Compiler Explorer.

In this talk we will delve into the gory details of designing and implementing variant types, with an emphasis on layout, construction, and destruction.

Using Enum is a little feature of C++20 with its little pitfalls. Elena will show helpful, harmful and unexpected examples of using it.

What is Software Quality, and how do we improve it? We look at a set of related principles and practices that help us get there, and along the way define what Quality actually is.

In this talk Pavel will introduce C++ library which unifies AoS and SoA data placement strategy along with quantitative and qualitative analysis.

Denis will tell you about the new C++ 20 library for working with SIMD — EVE and advise you on how to include it in your project.

The talk offers an introduction into the concepts, variety and architectural specifics of embedded systems and reviews the application of the C++ language and the environment for the embedded software development.

In this session, we will look into some changes that templates received with C++20. The biggest change is the introduction of concepts.

Valery will talk about Futures and which optimizations can be used to implement them using the open-source library https://github.com/YACLib/YACLib as an example.

Anna will talk about common practices, useful metrics and crazy requirements of software certified for ISO 26262.

Panel discussion is not recorded

If you think you know all the ways to shoot yourself in the foot in C++ - you could be wrong. Yuri and Phillip invite you to embark upon an exciting journey along the perilous paths of your favorite programming language. You've got some blood, gore, and UB-filled pits to look forward to. So stock up on some popcorn!

In this talk, Sergey will show several examples of C++ errors which may lead to vulnerability. Role of "Security Champion" will be revealed as one of the best practice of "Secure Development Lifecycle". Also, Sergey will explain "Secure By Design" principle which is applied for software based on KasperskyOS.

Panel discussion is not recorded

It is common to have a trade-off between 2 quality attributes. Is it possible to archieve safety without significant performance downgrade? We’d discuss both specific cases and common concerns. We invite you to join the discussion and together find the best solutions

C++ is written in very different fields - with different requirements, features, and complexities. And if you're not involved in Embedded, you may have a rather vague idea of how the developers' work there is different from yours. Maybe you should just drop everything and go there. Or on the contrary, it's not your thing at all, and there's not much time left for C++ in that area anyway?

Experienced people will help you to figure this out. So at the conference, we will talk about the peculiarities of this field with those who have spent more than a year in it: Vladimir Vishnevsky and Ignat Voroshilov. And Kirill Tikhonov will help to lead this conversation.

Panel discussion is not recorded

At the beginning of the year, the team realized that it was possible to optimize time for engineers to participate in hiring so that they could more easily switch context between work tasks. Speakers will share how they looked for moments where it made sense to improve things, and listen to how participants optimize their teams' dating and technical interview processes. We'll discuss how not to waste interviews on the candidate and the interviewer themselves. And we'll just talk about the hard stuff in hiring.

A technical interview is a complicated thing in itself, and not everyone has any idea how it goes. And when the interview is narrowly focused, it is even more so.

Egor Suvorov will conduct an interview with Ilya Shishkov, who will conventionally work with the algorithmic section. The goal is to show how it usually takes place, what knowledge and skills the candidate needs, and at the same time to analyze mistakes that both sides can make.

This talk is dedicated to best practices overview in effective GPU kernels development.

Panel discussion is not recorded

Anxiety is the little sister of fear. Is it a mechanism of evolution that has preserved our biological species, or a brake on the development of our career? How to determine the line that separates benefits from harm, how to learn to control the unwanted consequences of anxiety on development? Oleg is going to share how to identify the causes and show a simple and effective technique for managing your own anxiety.

WebAssembly has become a very popular target platform for C++ developers. However, emscripten does not provide type-safe wrappers to the standard JavaScript APIs. Open source tool "typescripten" has been built on top of three powerful technologies to close this gap, but it easy to say than do, as usually. Sebastian will discuss the challenges we faced and the choices we made when designing this framework.

It is rare to find a program that does not require string manipulation. If you are not limited to Latin ASCII, you have to deal with locales and national alphabets. Denis enjoyed digging through the source code of rantime libraries and discovered a lot of intricacies he wanted to talk about. Let's see what modern C++ has to offer for storing, comparing and processing Unicode strings. How productive are these operations and what assumptions might be wrong?

Last time Alexey analyzed in detail the internal structure of ASan, now it's his turn to tell how TSan works, what is under the hood, what he can and what he cannot.

Let's consider the reasons for using only Modern CMake.

Alexander will talk about:

• Transferring large objects through the border of languages.
• Native types — friend or foe?
• RPC as a way of manipulating big data.

Imagine you have decided to try a static analysis tool for the first time. You launch analysis and get hundreds or thousands of warnings. Among them, of course, there will be false positives. Unfortunately, static analysis is impossible without them. All in all, your impression of the tool will depend on which warnings you see first.

Nikolai's team thought it over and decided to make the Intelligence Diagnostic Filter mechanism that allows you to look through the best warnings. In this report we will see its concrete implementation in a plugin for Visual Studio 2022.

Panel discussion is not recorded

Michael will show you how to add your own checks into clang-tidy and start automatically refactoring your code base. He will give a little tour of the LLVM ecosystem and explain how to look for patterns in AST and how to use this to automate your routine and mini refactoring. Will partially touch on libtooling, clang-query.

Come in to talk about manual and automatic refactoring and try something new.

Oleg will talk about how the team counted the passability of the shops and crossroads with darknet and YOLO9k; how the team optimized matchmaker unit in the cryptocurrency exchange and why C++ remains a good choice.

C++ is written in very different fields - with different requirements, features, and complexities. And if you're not involved in GameDev, you may have a rather vague idea of how the developers' work there is different from yours. Maybe you should just drop everything and go there. Or on the contrary, it's not your thing at all, and there's not much time left for C++ in that area anyway?

Experienced people will help you to figure this out. So at the conference we will talk about the peculiarities of this sphere with those who have spent more than a year in it: Kirill Shabordin, Vladimir Atamanov, and Andrei Aksenov. And Alexander Pirogov will help to lead this conversation.

What happens when you take a person steeped in C++ culture and design choices, and ask them to challenge assumptions in the creation of a new language?

Profile-guided optimization is a powerful technique that can improve application performance. In this talk, we'll understand how this technique works, how to customize it, and how to gain maximum profit from it.

We take stock, remember the bright moments and talk about our plans. Join the broadcast, so you don't miss anything!

C++ is written in very different fields - with different requirements, features, and complexities. And if you're not involved in HFT, you may have a rather vague idea of how the developers' work there is different from yours. Maybe you should just drop everything and go there. Or on the contrary, it's not your thing at all, and there's not much time left for C++ in that area anyway?

Experienced people will help you to figure this out. Therefore, the conference will talk about the features of this area with those who have spent more than a year in it: Michael Matrosov, Oleg Fathiev and Artem Verkhoglyadov. And Pavel Filonov will help to lead this conversation.

Seastar is ScyllaDB’s cooperative runtime. Starting this year it was first to adopt C++20 coroutines for production level system software. In this talk I will walk сover seastar use of coroutines, compiler and standard pitfalls and advantages of coroutines over feature-based programming.

We talk about the environment, processes and development methodologies in Kaspersky Lab either as for an engineer and as for a engineering manager who helps engineers do their work most efficiently.

Alexander will present two cross-platform package managers for C++, will consider the differences in approaches, the opportunities for integration, adding your own libraries.