Talks

This talk will cover an approach to software design that allows only non-copyable move-only types called "linear types". We'll see all the C++ features that make and enforce types like these.

We had been using С++11 in Visual Studio 2013 (only for Windows). Now we're using С++17 in Visual Studio 2017 (for Windows) and GCC 7.3 (for Linux). We'll tell how we solved different challenges that appeared during this transition.

We're going to see examples of how higher-order functions can be used in practice to increase the quality of production code and the productivity of developers. A new abstraction proposed to the Standard Library for C++20, function_ref, will also be covered and compared to other techniques for the implementation of higher-order functions.

This talk's aimed at C++ developers already familiar with basic capabilities of default smart pointers. From this talk they'll learn several handy tricks of using both default and custom smart pointers.

This talk's purpose is to introduce allocators to the audience, show which allocators to use in which cases, tell how allocator propagation model works for nested containers, and discuss what allocator support can bring to library developers.

Valentin intends to convince you that the combination of ranges with a bit of metaprogramming makes for a very elegant solution to the text formatting problem.

We'll discuss monadic parsers: what's the difference between this parsing approach and the other ones, what are its advantages and disadvantages, and what's the role of such important concepts of functional programming as functors, applicative functors, and monads.

Brief overview of developer tools, libraries and features of the Rust language.

We'll discuss metaprogramming through the ages and the right way to work with type lists.

This talk will give you a solid idea of which error handling strategy to use when, what's coming next, and how to approach code now that will play nicely in that possible future.

We'll discuss methods of giving information about data in use and actions performed on them to the compiler.

We'll talk about designing and implementing PostgreSQL driver with user-friendly interface, using almost all C++17 features available at the moment.

Andrey will give some advices on what the libraries developers should pay extra attention to at their code review.

The talk provides an overview of the structure and algorithms of the memory hierarchy in a modern CPU.

This talk will provide insights into why compilation (and linking) take so long for C++ and will then provide an exhaustive list of techniques and tools to mitigate the problem.

We'll discuss concepts in general a little and how it simplifies the implementation of generic classes.

Javier intends to make clear the difference between API and ABI, source and binary compatibility. He'll point out the extreme relevance that ABI compatibility has for library developers and give examples of things that affect the ABI and some techniques to minimize that pain.

In this talk, we will discuss the past, present, and future of initialisation in C++, the different types of initialisation and syntaxes for them, and how to use them correctly.

Sergey will tell how you can implement metaclasses support in the form of an external utility (based on clang frontend) and what you can/should do to integrate the results of that utility's work into your code.

Few advices how to write metaprograms minimizing stress of compiler.

Every trendy programming language goes out of its way to claim that it's faster, more reliable and in general better than C++ in all possible ways. Let's separate facts from fables. Let the battle between C++ и Asm/Rust/Go/Java/C#... begin!

We will talk about the architectural benefits of immutability and show how a very efficient and powerful persistent vector type can be built using state-of-the-art structures (Relaxed Radix Balanced Trees). We will also show an example application (a text editor) built using the architectural style proposed here. Not only is its code extremely simple, it outperforms most similar programs. Don't believe it? Come and see!

Threads, atomic variables, mutexes, and conditional variables are the basic building blocks of any concurrent application in C++, which are a big challenge even for the experienced C++ programmers. This massively changed with C++17 and even more with C++20/23. Let's discuss what did we get with C++17 and what can we hope for with C++20/23.

This talk is a reactive programming tutorial. Step by step we'll uncover how this approach allows us to disengage ourselves from working with complicated asynchronous code and simplifies testing it.

Pavel will tell about asynchronous programming capabilities that the C++ standard library offers now and that are slated to be added in the future, about concurrency::task from PPL as an illustration for possible implementation, and how using coroutines can make writing and understanding of code much easier.

This talk will list and discuss C++17 traps, explain the reasons for the underlying design, and give guidance how to deal with them. As a side effect you will learn a lot about some cool new features of C++17.

We had to invent a new kind of pointer which could be used to carefully manage object modifications. In this talk, we'll cover the mechanics of implementing these pointers, details of how they can be used for complex data structures, and examples of the capabilities of modern C++ which are necessary for the implementation.

Anton will tell about specific aspects of using modern C++ standards in World of Tanks game engine.