Schedule

We'll talk about the schedule, sessions and share information.

What optimization actually turns into when using TCMalloc (which is just able and knows about hot and cold allocations), how much the application becomes faster or slower.

An overview of past tools for working with C++ projects.

Developing a graphics engine is a difficult task, and most of the work is creating a good user interface. But what if we try to use Microsoft Visual Studio as a frontend?

Building digital 3D models of architectural landmarks and entire cities is a large-scale and computationally demanding problem. In this talk, we will discuss the engineering aspects of an algorithm published at ICCV 2021 that reconstructs a surface as a triangular 3D mesh from depth maps and/or LiDAR scans.

You'll learn what coroutines are and how to use them in the best way.

Let's look at how debugging works in VS Code and where the performance of the standard C++ extension is lost. Let's show how we designed our own debug adapter for Kaspersky OS and got fast and predictable debugging.

A user-level scheduler that replaces the heavy model of system threads and I/O functions with lighter fibers and more efficient I/O models without changing the application code.

An analysis of certain software patterns that require acceleration and the possibility of implementing them using RISC-V Vector. A deep dive into the challenges of modern out-of-order CPUs from the perspective of an RTL engineer, verification engineer, and programmer.

Summing up the results of the conference, remembering the highlights and talking about plans.

Talking about schedule, sessions, and sharing information.

We'll introduce the open-source SpaceBallistics template C++ library based on our other DimTypes library.

Let's talk about the overhead of providing additional security in the Rust language, as well as other properties that affect performance, and look at ways to improve program performance.

Let's talk about the VK team's tool for verifying the correctness of competitive data structures.

At this workshop, participants will practice both GPU programming and creating an extension for the popular PyTorch framework.

Learn how std::simd summarizes best practices and provides a single interface for vectorization, eliminating the need to juggle with intrinsics and rely on the vagaries of an auto-vectorizer.

How we implemented server support for MySQL and PostgreSQL protocols using Boost.Asio and corutines.

std::vector<T> is an important type, and push_back() is an important operation. It is vital to understand how it works.

We'll cover the theory and then speed up the code that uses push_back().

In the second part, we will supplement our knowledge of branch prediction with advanced prediction algorithms.

I'll talk about the basics of reflection in the C++26 standard and show you how to use it to formalize well-known programming patterns.

I'll look at what Slang is, what tasks it solves, and consider the Reflection API and its practical application.

The talk describes the evolution from the classical Chandy—Lamport algorithm for consistent state capture of a distributed system to fault tolerance mechanisms and non-stop scaling of distributed streaming data processing systems. Unsolved problems of elasticity of streaming data processing systems are also presented.

I'll tell you how and why I made the research fork ClickHouse.

A comparison of modern JIT libraries in the context of developing a high-performance RISC-V architecture simulator with dynamic binary translation (DDT).

This master class is for young professionals or students who want to better understand the architecture of the Linux kernel and how it interacts with real hardware.

The talk is about the Binary Optimization and Layout Tool (BOLT), a post-compilation optimization tool included in the LLVM ecosystem. We will analyze how BOLT improves the performance of executable files without changing the source code and recompiling.

Optimizations that can be considered.

20-minute talks on a free topic in any format, and live discussions.

Let's talk about aliasing, one of the most important and underrated programming topics. Let's see why the development of this direction in the C++ language will take a very long time.

At the workshop, we will solve puzzles on the userver. You can work with AI assistants, or you can do it without.

Going beyond the capabilities of C++ through static reflection. Practical examples from product development.

Get ready to crack the code on memory safety! Our talk will reveal how algebraic techniques can be used to analyze and verify C/C++ programs, making it easier to identify and fix memory-related bugs.

An applied talk on embedding other programming languages into C++ and using C++ from those languages (Embedding/Extending), covering technical details such as exception handling, as well as how these concepts influence different aspects of software development.

The talk examines the practical experience of protecting a C++ gaming client.

Let's look at the current eBPF compilation process in the Linux kernel and its disadvantages, as well as how we matched LLVM and the kernel and what result we got.

Let's take a look inside the network code of computer games.

Error injection is a method of artificially introducing various kinds of malfunctions to test program code for errors.

I'll tell you how we implemented this method, what advantages its use in fuzzing tests gives, and what results we got from its implementation.

I will share my experience of creating an effective runtime environment for compute shaders as part of the Adept open source project.

In the talk, I will share the experience of SberDevices: how we configured clang-tidy so that it became not just a linter, but actually replaced our internal coding standard.

Using practical examples, let's look at the capabilities of the analyzer and the problems that we had to face.

Summing up the results of the conference, remembering the highlights and talking about plans.