Designing for the long term: Invariants, knobs, extensions, and Hyrum's Law

Unexpected things to know about working with Unicode in C++

Programming graphics cards: intruduction into essential practices of GPGPU optimizations

Developing embedded databases: tips, tricks and pitfalls

Deep dive into Futures: Task Parallelism approach

Software development at Kaspersky Lab: how does it work

Anatomy of asynchronous engines

A rich world of Exception Handling

The next level of C++20 Templates: Concepts and more

Genode for C++ developers — the framework for creating operating systems

C++20 coroutines in Seastar

C++ in two atypical projects

Improving the quality of the first introduction to static analysis with the Intelligence Diagnostic Filter

Semi-automatic refactoring of everything with clang-tidy and clang-query

Contract-based programming in C++

PGO: How it works and how to use it properly

Just Enough Assembly for Compiler Explorer

Performance and safety: how to combine

Interchangeable AoS and SoA containers

JIT in ClickHouse

What I learned about language and library design by working on Swift

C++ in the world of embedded systems

EVE: A new, powerful open source C++20 SIMD library

Concurrency in C++20 and beyond

Non-standard application of image processing algorithms on the example of 2GIS maps

Anxiety and career

ThreadSanitizer anatomy

Functional safety: best reliability practices and worst automotive requirements

Typescripten — generating type-safe JavaScript bindings for emscripten

It is time to finally bury CMake 2.x

Integrating Lua scripts into a C++ application to implement the Visitor pattern

Embracing (and also Destroying) Variant Types Safely

Background tasks: Resource management and cancellation

Common errors in C++ which led to vulnerabilities and their mitigation in KasperskyOS

Getting the most out of GDB

Technical interview: Algorithmic section

Less is better: how to optimize interview time

(ab)using enum

Technical Interview: System Design

Why vcpkg is not Conan

Fun with type erasure + dispatching data from abstract structure to function parameters

Zen and the art of code lifecycle maintenance

C++ puzzlers

Hacking modern CMake

Everything you know about colour is wrong

Workshop: Metaprogramming in action (part 1)

Introduction to heterogeneous programming with Data Parallel C++

First steps in SIMD. Implementing STL algorithms with AVX2 vector extensions

Embedded problems or how we left SQLite

Workshop: Metaprogramming in action (part 2)

C++ compilation architecture: Problems and solutions

Trying to build an open source browser in 2020

Unique_pseudofunction — N overloads for the price of one

Interview (part 1)

Crowdsourced bug detection in production: GWP-ASan and beyond

Interview and Q&A: ABI, change, and the future

Variable Length Array: Is it really that scary?

Discussion: C++ interview

Windows, macOS and the Web: Lessons from cross-platform development at think-cell

About memory

Interview (part 2)

Lambda? You keep using that letter

Constructors and destructors: A few things you might want to know

SIMD. Performance you have already paid for

ITM: My least favorite anti-pattern

Annotating ELF files with compile-time information

C++: Before and after concepts

Interview and Q&A: Reluctantly a Verb

Present and future of copy elision

Understanding C++ coroutines by example

Effective continuous fuzzing — C++

std::to_string faster than light

Поговорим про KasperskyOS

Онлайн-использование PVS-Studio с помощью Compiler Explorer

Three etudes on bufferisation

A detailed performance analysis of a simple low-latency trading system

Applying sanitizers to whole Linux distribution

Like in Haskell: Final Tagless and eDSL on concepts

Interview and Q&A with Bjarne Stroustrup

Rethinking the way we do templates in C++

DIY: Homemade Thread Pool

Teaching linear algebra to C++

Примеры интересных багов, обнаруженных с помощью PVS-Studio

Генерация С++ кода из метаописания в игровой разработке

Reflection of the present and the future

Introducing large-scale C++, volume I: Process and architecture

Burning Silicon: Speed for transcoding in C++23

AddressSanitizer anatomy

How to update the compiler and keep sane

How to declare a constant in C++?

Type loopholes in C++: Standard level bug

Thread Local in C++ as it is

C++: Темная сторона

Статический анализ кода в 2020 году

C++ ecosystem: The Renaissance edition

How to build portable binaries for Linux

C++ STL best and worst performance features and how to learn from them

Applying the "hourglass" principle in library design

Panel session: Learning C++

Fuzzy testing for bright programmers

Embedded registers interfaces mocking with exeptions

ECS в UI — правда или вымысел?

Interview and Q&A with Herb Sutter

For your in<format>ion

Better code: Relationships

A state of сompile time regular expressions

The C++ rvalue lifetime disaster

Automate it

C++ exceptions through the prism of compiler optimizations

Teaching geometry to C++

How we switched to vcpkg

Comfort class apartments for actors and handlers

Type punning in modern C++

BareMetal C++

Generators, coroutines and other brain-unrolling sweetness

Using slab allocators in high performance network applications

C++ Enterprise Edition — message brokers

C++ tricks from Yandex.Taxi

Squaring the circle: value-oriented design in an object-oriented system

Premature optimization is evil! All hail premature optimization!

A unifying abstraction for async in C++

The C++20 synchronization library

Insights into the C++ standard library

Dive into the general-purpose GPU programming

Modules in C++20 — real or fake?

Modern techniques for keeping your code dry

Clauses, qualifiers and patterns

Modules: Changes in core language

Hardening the C++ standard template library

Dart as an opportunity to transfer a C++ application to web

The Big Four of C++20

Serialization with blackjack and metaprogramming

Algorithmic and microarchitecture optimizations of C++ applications

Compile-time type tagging

C++17 — the biggest traps

Modern C++ allocators

Metaprogramming evolution: The right way to work with type lists

Know your hardware: CPU memory hierarchy

Compile time optimization

Metaprogramming in game development

Text formatting for a future range-based standard library

Reactive C++

How we were upgrading compiler and supporting cross-platform software

Initialisation in modern C++

Move-only C++ design

What you should pay extra attention to at your library's code review

Concurrency and parallelism in C17 and C20/23

Monadic parsers

ABI compatibility is not a MAJOR problem

Asynchronous C++ programming

Rust programming language — ecosystem review

The hitchhiker's guide to faster builds

Compiler-friendly metaprogramming

C++ smart pointer cookbook

Higher-order functions and function_ref

Concepts: simplifying implementation of std utility classes

Not so dull pointers in ClickHouse

Postmodern immutable data structures

The dawn of a new error

C++ templates and databases

Metaclasses in C++: dream? Reality!

Indispensible C++