: Standard C++

Home » Blog » Categories »

CppCon 2025 Cache Me Maybe: The Performance Secret Every C++ Developer Needs -- Michelle D'Souza

By Blog Staff | Apr 3, 2026 10:14 AM | Tags: None

Registration is now open for CppCon 2026! The conference starts on September 12 and will be held in person in Aurora, CO. To whet your appetite for this year’s conference, we’re posting videos of some of the top-rated talks from last year's conference. Here’s another CppCon talk video we hope you will enjoy – and why not register today for CppCon 2026!

Cache Me Maybe: The Performance Secret Every C++ Developer Needs

by Michelle D'Souza

Summary of the talk:

Calling all code detectives! Grab your trench coats and magnifying glasses ... it's time to crack the case of sluggish C++ performance. In this thrilling investigation, we'll uncover the hidden world of your computer's built-in cache and how to harness it to turbocharge your code.

We'll comb through the fundamentals of caches like seasoned sleuths, uncover clues on optimizing access patterns, and interrogate suspects like false sharing and cache unfriendly data structures. We will also examine benchmark evidence based on real-world production code, exposing how each technique delivers the goods.

By the end of this mission, you'll be armed with a detective's toolkit of cache savvy strategies, ready to solve cross-platform performance mysteries and bring blazing fast code to justice. Cache you at this session, maybe!

std::vector — Four Mechanisms Behind Every push_back() -- Gracjan Olbinski

By Gracjan Olbinski | Apr 2, 2026 04:47 PM | Tags: None

A walkthrough of four mechanisms working behind every push_back() call — exponential growth and amortized O(1), the growth factor's effect on memory reuse, cache performance from contiguity, and the silent noexcept trap in move semantics during reallocation.

std::vector — Four Mechanisms Behind Every push_back()

by Gracjan Olbinski

From the article:

"You call push_back() a thousand times. The vector reallocates about ten. Behind that simple interface, four mechanisms are working together — each one invisible during normal use, each one shaping your performance in ways that push_back() will never tell you about."

CppCon 25 Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization -- Aliaksei Sala

By Blog Staff | Mar 31, 2026 10:10 AM | Tags: None

Matrix Multiplication Deep Dive || Cache Blocking, SIMD & Parallelization

by Aliaksei Sala

Summary of the talk:

Matrix multiplication is a fundamental operation in scientific computing, game development, AI, and numerous high-performance applications. While its mathematical definition is simple, achieving optimal performance in C++ is far from trivial.

In this talk, we will explore different optimization techniques for matrix multiplication, from naive implementations to highly tuned versions leveraging modern hardware features. We will cover key performance-enhancing strategies such as loop unrolling, cache blocking, SIMD vectorization, parallelization using threads and more. Through benchmarking and profiling, we will measure the real impact of these optimizations.

By the end of this session, attendees will gain insights into two critical questions:

How hard is it to implement an optimized matrix multiplication in C++? How effective is C++ for achieving peak performance in this task?

This talk is suitable for developers interested in performance optimization, computational efficiency, and modern C++ techniques for numerical computing.

The hidden compile-time cost of C++26 reflection -- Vittorio Romeo

By Vittorio Romeo | Mar 30, 2026 06:18 PM | Tags: None

How much does C++26 Reflection actually cost your build?

In this article, we'll perform some early compilation time benchmarks of one of the most awaited C++26 features.

The hidden compile-time cost of C++26 reflection

by Vittorio Romeo

From the article:

Fast compilation times are extremely valuable to keep iteration times low, productivity and motivation high, and to quickly see the impact of your changes.

I would love to see a world where C++26 reflection is as close as possible to a lightweight language feature [...]

So, I decided to take some early measurements.

Stop Choosing: Get C++ Performance in Python Algos with C++26 -- Richard Hickling

By Blog Staff | Mar 27, 2026 12:10 PM | Tags: None

In algorithmic trading, the Python-vs-C++ debate is usually framed as flexibility versus speed — rapid strategy development on one side, ultra-low-latency execution on the other. But with C++26 reflection, that trade-off starts to disappear, making it possible to generate Python bindings automatically while keeping the core logic running at native C++ performance.

Stop Choosing: Get C++ Performance in Python Algos with C++26

by Richard Hickling

From the article:

The “religious war” between Python and C++ in algorithmic trading usually boils down to a single trade-off: Python is faster for getting ideas to market, while C++ is faster for getting orders into the book.

But why choose? With the advent of C++26 Reflection, you can now have the flexibility of a Python-based strategy without the performance penalty of slow loops.

Bring in C++ Rapidly: How Reflection Works

The biggest hurdle in hybrid trading systems has always been the “bridge.” Traditionally, if you wrote a complex pricer in C++, you had to manually write “boilerplate” code to tell Python how to talk to it. If you added a new function, you had to update the bridge. It was tedious and error-prone.

Reflection changes the game by allowing the code to “look in the mirror”. Instead of you manually describing your C++ functions to Python, the compiler does it for you. It programmatically inspects your classes and generates the bindings automatically.

CppCon 2025 Practical Reflection With C++26 -- Barry Revzin

By Blog Staff | Mar 26, 2026 10:07 AM | Tags: None

Practical Reflection With C++26

by Barry Revzin

Summary of the talk:

With the adoption of Reflection for C++26, the landscape of what is possible has shifted. This talk will focus on implementing Struct-of-Arrays for an arbitrary aggregate, but will also take some detours to cover some techniques that will prove useful for solving a wide range of problems.

A Brief History of Bjarne Stroustrup, the Creator of C++ -- CultRepo

By Blog Staff | Mar 25, 2026 12:06 PM | Tags: None

In this portrait, we meet Bjarne Stroustrup where we talk about his childhood, his accidental entry into computer science (what is "datologi" anyway?), and the ideas that shaped one of the most influential programming languages ever made -- among many, many other things... like how pronouncing his last name involves a potato.

A Brief History of Bjarne Stroustrup, the Creator of C++

by CultRepo

Watch now:

<iframe width="560" height="315" src="https://www.youtube.com/embed/uDtvEsv730Y?si=QD_WmemwpsAfNsVI" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>

Announcing Meeting C++ 2026

By Meeting C++ | Mar 25, 2026 10:01 AM | Tags: meetingcpp community c++26 c++20

This years Meeting C++ conference is special, as its the 15th conference in total that Meeting C++ has organized, and its also the 5th time the event is hybrid!

Announcing Meeting C++ 2026

by Jens Weller

From the article:

We'll be meeting from the 26th - 28th November in Berlin! You have the unique chance to spend the 1st advent in Berlin with C++ and Christmas Markets open!

With Mateusz Pusz and Kate Gregory I've chosen two well known speakers for the keynotes this year. Mateusz is well known for his units library, which currently also is proposed for the standard. It is also an important contribution to making C++ more safe and secure, the big topic of last year. Then Kate Gregory will be visiting us in Berlin again, she is known for her ability to create great talks around technical and social aspects in our daily lives as devs. You might remember her from giving a keynote in 2017, or speaking about the aging programmer two years ago.

For the 15th time Meeting C++ will organize a great event for 3 days filled with lots of content about C++, like last year the plan is to host 3 tracks in parallel in Berlin, with an optional 4th track. The 4th track will be unlocked either by sponsorships or ticket sales. You can be a part of this great C++ event by attending onsite and online. There is already great news for onsite attendees: Hudson River Trading is again this years t-shirt sponsor, a great and unique Meeting C++ 2026 t-shirt is an exclusive perk for onsite attendees!

CppCon 2025 Threads vs Coroutines: Why C++ Has Two Concurrency Models -- Conor Spilsbury

By Blog Staff | Mar 23, 2026 10:04 AM | Tags: None

Threads vs Coroutines: Why C++ Has Two Concurrency Models

by Conor Spilsbury

Summary of the talk:

The C++11 standard introduced a powerful set of tools for concurrency such as threads, mutexes, condition variables, and futures. More recently, C++20 introduced another powerful but fundamentally different concurrency abstraction in the form of coroutines. But coroutines are not just an evolution or a replacement for threads. Instead, they each solve different problems in different ways. Choosing the right tool for the job requires understanding how each works under the hood and where they shine. This talk will help build that intuition by looking at how each interacts with the operating system and hardware which will help make better decisions when choosing which to use.

We'll explore how threads and synchronization primitives work at the operating-system and hardware level, from thread creation and scheduling to where context switching and synchronization introduce performance costs. We’ll then contrast this to the coroutine model introduced in C++20 which takes a fundamentally different approach by using a cooperative model based on the suspension and resumption of work.

Given this understanding, we’ll finish by applying this intuition to a set of real-world scenarios to identify whether threads or coroutines are a better fit for the problem at hand.

C++26: std::is_within_lifetime -- Sandor Dargo

By Blog Staff | Mar 19, 2026 12:02 PM | Tags: None

When I first came across std::is_within_lifetime, I expected another small type-traits utility — not a feature tied to checking whether a union alternative is active. But once you look closer, this seemingly narrow addition turns out to solve a surprisingly fundamental problem in constant evaluation.

C++26: std::is_within_lifetime

by Sandor Dargo

From the article:

When I was looking for the next topic for my posts, my eyes stopped on std::is_within_lifetime. Dealing with lifetime issues is a quite common source of bugs, after all. Then I clicked on the link and I read Checking if a union alternative is active. I scratched my head. Is the link correct?

It is — and it totally makes sense.

Let’s get into the details and first check what P2641R4 is about.

What does std::is_within_lifetime do?

C++26 adds bool std::is_within_lifetime(const T* p) to the <type_traits> header. This function checks whether p points to an object that is currently within its lifetime during constant evaluation.