C++ Podcasts & Conference Talks (week 50, 2025)

Hi r/cpp! Welcome to another post in this series brought to you by Tech Talks Weekly. Below, you'll find all the C++ conference talks and podcasts published in the last 7 days:

# 📺 Conference talks

# CppCon 2025

1. **"Implementing Your Own C++ Atomics - Ben Saks - CppCon 2025"** ⸱ +4k views ⸱ 04 Dec 2025 ⸱ 01h 01m 38s
2. **"The Dangers of C++: How to Mitigate Them and Write Safe C++ - Assaf Tzur-El"** ⸱ +3k views ⸱ 03 Dec 2025 ⸱ 00h 50m 09s
3. **"Building Secure C++ Applications: A Practical End-to-End Approach - CppCon 2025"** ⸱ +2k views ⸱ 05 Dec 2025 ⸱ 01h 02m 01s
4. **"Back to Basics: How to Refactor C++ Code - Amir Kirsh"** ⸱ +2k views ⸱ 08 Dec 2025 ⸱ 01h 04m 13s
5. **"Is The Future of C++ Refactoring Declarative? - Andy Soffer - CppCon 2025"** ⸱ +1k views ⸱ 09 Dec 2025 ⸱ 01h 00m 49s

# ACCU York

1. **"Agentic Debugging Using Time Travel - Greg Law - ACCU York"** ⸱ +100 views ⸱ 09 Dec 2025 ⸱ 01h 06m 26s

# LMPL 2025

1. **"\[LMPL'25\ Challenges in C++ to Rust Translation with Large Language Models: A Preliminary(…)"](https://youtube.com/watch?v=HQDxhlxE1o&utmsource=techtalksweekly&utmmedium=email) ⸱ **<100 views** ⸱ 05 Dec 2025 ⸱ 00h 18m 10s

# OOPSLA 2025

1. [**"\[OOPSLA'25\] Fuzzing C++ Compilers via Type-Driven Mutation"**](https://youtube.com/watch?v=je8uYrTNfys&utmsource=techtalksweekly&utmmedium=email) ⸱ **<100 views** ⸱ 05 Dec 2025 ⸱ 00h 14m 13s
2. [**"\[OOPSLA'25\] Fast Constraint Synthesis for C++ Function Templates"**](https://youtube.com/watch?v=6pxVhEi-bc&utmsource=techtalksweekly&utmmedium=email) ⸱ <100 views ⸱ 05 Dec 2025 ⸱ 00h 13m 28s

# 🎧 Podcasts

1. **"C++ Memory Management • Patrice Roy & Kevin Carpenter"** ⸱ GOTO ⸱ 09 Dec 2025 ⸱ 00h 32m 20s

This post is an excerpt from the latest issue of ***Tech Talks Weekly*** which is a free weekly email with all the recently published Software Engineering podcasts and conference talks. Currently subscribed by +7,500 Software Engineers who stopped scrolling through messy YT subnoscriptions/RSS feeds and reduced FOMO. Consider subscribing if this sounds useful: *https://www.techtalksweekly.io/*

Let me know what you think. Thank you!

https://redd.it/1pjqqob
@r_cpp

I optimized my Order Matching Engine by 560% (129k → 733k ops/sec) thanks to your feedback

Hey everyone,

A while back I shared my C++ Order Matching Engine here and got some "honest" feedback about my use of std::list and global mutexes.

I took that feedback to heart and spent the last week refactoring the core. Here are the results and the specific optimizations that worked:

The Results:

Baseline: \~129,000 orders/sec (MacBook Air)
Optimized: \~733,000 orders/sec
Speedup: 5.6x

The Optimizations:

1. Data Structure: `std::list` -> `std::deque` + Tombstones
Problem: My original implementation used std::list to strictly preserve iterator validity. This killed cache locality.
Fix: Switched to `std::deque`. It offers decent cache locality (chunked allocations) and pointer stability.
Trick: Instead of erase() (which is O(N) for vector/deque), I implemented "Tombstone" deletion. Orders are marked active = false. The matching engine lazily cleans up dead orders from the front using pop_front() (O(1)).
2. Concurrency: Global Mutex -> Sharding
Problem: A single `std::mutex` protected the entire Exchange.
Fix: Implemented fine-grained locking. The Exchange now only holds a Shared (Read) lock to find the correct OrderBook. The OrderBook itself has a unique mutex. This allows massively parallel trading across different symbols.
3. The Hidden Bottleneck (Global Index)
I realized my cancelOrder(id) API required a global lookup map (`OrderId` \-> `Symbol`) to find which book an order belonged to. This map required a global lock, re-serializing my fancy sharded engine.
Fix: Changed API to cancelOrder(symbol, id). Removing that global index unlocked the final 40% performance boost.

The code is much cleaner now

I'd love to hear what you think of the new architecture. What would you optimize next? Custom Allocators? Lock-free ring buffers?

PS - I tried posting in the showcase section, but I got error "unable to create document" (maybe because I posted once recently, sorry a little new to reddit also)

Github Link - https://github.com/PIYUSH-KUMAR1809/order-matching-engine

https://redd.it/1pk5iv3
@r_cpp

Should I store a helper object as a class member or create it locally inside a method in C++?

I have a base Layer class that I expose from a DLL. My application loads this DLL and then defines its own layer types that inherit from this base class. Here is the simplified definition:

class Layer
{
public:
virtual ~Layer() {};
virtual void OnUpdate() {};
virtual void OnEvent() {};
virtual void OnRender() {};
Rescaler rescaler;
};

All other layer types in my application inherit from this class.


The Rescaler object is responsible for scaling all drawing coordinates.
The user can set a custom window resolution for the application, and Rescaler converts the logical coordinates used by the layer into the final resolution used for rendering.

This scaling is only needed during the OnRender() step and it is not needed outside rendering.

Given that:

1. the base Layer class is part of a DLL,
2. application-specific layers inherit from it,
3. Rescaler is only used to scale rendering coordinates based on user-selected resolution,

my question is:

Should Rescaler remain a member of the base Layer class, be moved only into derived classes that actually need coordinate scaling, or simply be created locally inside OnRender()?

What is the recommended design in this scenario?

https://redd.it/1pk7x36
@r_cpp

I've built a text adventure game engine on top of the C++ Standard...

Why? I have no idea.

But it's a learning tool with quests and time travel and artifacts and NPC's and XP and ... well, you just have to check it out:

https://cppevo.dev/adventure

It's probably my favorite why to browse and search the standard now, but there's probably a few errors lurking in the conversion and maybe in the quests.

It's built on top of my C++ Standard -> markdown tool https://github.com/lefticus/cppstdmd and my C++ Evolution viewing tool https://cppevo.dev

Everything is cross linked where possible with other sites, and of course code samples NPCs give are linked back to Compiler Explorer.

https://redd.it/1pkasf6
@r_cpp

How Modern C++ Parses a Word Document in a Clean Functional Pipeline

Working with old document formats often turns into archaeology — XML digging, platform-specific hacks, or very verbose parsing chains.

But modern C++20 allows a surprisingly clean, composable approach.

Here’s what a full MS Word (.doc or .docx) parsing pipeline looks like today using an operator-pipe style:

std::filesystem::path("data_processing_definition.doc")
| content_type::detector{}
| office_formats_parser{}
| PlainTextExporter()
| out_stream;

ensure(out_stream.str()) ==
"Data processing refers to the activities performed on raw data...";



No COM.
No platform-specific APIs.
No manual XML manipulation.
Just a functional, readable pipeline.

I'm honestly curious how other languages express a similar parsing chain.
If you work with Python, Rust, Go, Java, C#, or JS — how would you model this?

Would love to see your idiomatic equivalents.

https://redd.it/1pkekq6
@r_cpp

Show and Tell I optimized my Order Matching Engine by 560% (129k → 733k ops/sec) thanks to your feedback

Hey everyone,

A while back I shared my C++ Order Matching Engine here and got some "honest" feedback about my use of std::list and global mutexes.

I took that feedback to heart and spent the last week refactoring the core. Here are the results and the specific optimizations that worked:

The Results:

Baseline: \~129,000 orders/sec (MacBook Air)
Optimized: \~733,000 orders/sec
Speedup: 5.6x

The Optimizations:

1. Data Structure: `std::list` -> `std::deque` + Tombstones
Problem: My original implementation used std::list to strictly preserve iterator validity. This killed cache locality.
Fix: Switched to `std::deque`. It offers decent cache locality (chunked allocations) and pointer stability.
Trick: Instead of erase() (which is O(N) for vector/deque), I implemented "Tombstone" deletion. Orders are marked active = false. The matching engine lazily cleans up dead orders from the front using pop_front() (O(1)).
2. Concurrency: Global Mutex -> Sharding
Problem: A single `std::mutex` protected the entire Exchange.
Fix: Implemented fine-grained locking. The Exchange now only holds a Shared (Read) lock to find the correct OrderBook. The OrderBook itself has a unique mutex. This allows massively parallel trading across different symbols.
3. The Hidden Bottleneck (Global Index)
I realized my cancelOrder(id) API required a global lookup map (`OrderId` \-> `Symbol`) to find which book an order belonged to. This map required a global lock, re-serializing my fancy sharded engine.
Fix: Changed API to cancelOrder(symbol, id). Removing that global index unlocked the final 40% performance boost.

The code is much cleaner now

I'd love to hear what you think of the new architecture. What would you optimize next? Custom Allocators? Lock-free ring buffers?

PS - I tried posting in the showcase section, but I got error "unable to create document" (maybe because I posted once recently, sorry a little new to reddit also). If anything is wrong with post, like wrong section etc. Please let me know how to fix it.

Github Link - https://github.com/PIYUSH-KUMAR1809/order-matching-engine

https://redd.it/1pkjpjw
@r_cpp

The State of C++ 2025 (JetBrains survey)
https://lp.jetbrains.com/the-state-of-cpp-2025/

https://redd.it/1pkozlz
@r_cpp

What makes a game tick? Part 8 - Data Driven Multi-Threading Implementation · Mathieu Ropert
https://mropert.github.io/2025/12/11/making_games_tick_part8/

https://redd.it/1pktgc3
@r_cpp

Parallel C++ for Scientific Applications: Introduction to Parallelism
https://www.youtube.com/watch?v=kA7A5sWFstw

https://redd.it/1pkueou
@r_cpp

C++26 Reflection appreciation post

I have been tinkering with reflection on some concrete side project for some times, (using the Clang experimental implementation : https://github.com/bloomberg/clang-p2996 ) and I am quite stunned by how well everything clicks together.
The whole this is a bliss to work with. It feels like every corner case has been accounted for. Every hurdle I come across, I take a look at one of the paper and find out a solution already exists.

It takes a bit of getting used to this new way of mixing constant and runtime context, but even outside of papers strictly about reflection, new papers have been integrated to smooth things a lot !

I want to give my sincere thanks and congratulations to everyone involved with each and every paper related to reflection, directly or indirectly.

I am really stunned and hyped by the work done.

https://redd.it/1pl7t3p
@r_cpp

How to make my C++ project portable.

So about 15 years ago when I was at ITT Tech, I made a simple project. Basically a Mega Man 2 BGM selection menu. I ran into 2 issues when I actually presented my project.

\#1 I tried to be clever and assign the file directory to my thumb drive. At the time it was my D: drive. When I went to present the project, the computer reassigned my thumb drive's letter because the presenting computer (unbeknownst to me) already had a D: drive. So the program broke because it couldn't reference the locations of the music files it was playing. Ok no problem. I grab my own laptop and continue on.

\#2 A few weeks ago, I go back and take a look at the program. My son is taking a computer science class in high school, and I want to show him what I was doing when I started getting into programming. Kinda an inspiration, idea jogging type of thing. So I go to load the program. I start researching how to fix the reference issue. Ok I got that. Cool so I can now send my program to him, and my own high school buddy who is getting into programming himself a little bit.

They get the file and try to run the exe. They get 4 errors:
\-"The code execution cannot proceed because MSVCP140D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because VCRUNTIME140D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because VCRUNTIME140_1D.dll was not found. Reinstalling the program may fix this problem."

\-"The code execution cannot proceed because ucertbased.dll was not found. Reinstalling the program may fix this problem."


There's nothing to install. It's just an executable compiled by Visual Basic compiler. Maybe that's the problem. How do I get these 4 files, and how can I send them in such a way that my program can be run (or installed to run) on another computer. I'm guessing I have the files on my laptop because they came with Visual Basic? I'm not sure, but it seems like a big ask to have end users download Visual Basic just to run an exe.

https://redd.it/1plcbb1
@r_cpp

Boost::MSM New C++17 back-end with significantly improved compilation times and new features

Hi reddit,

I'm excited to announce that a new back-end has been released for MSM in Boost version 1.90!

This new back-end requires C++17, below are the most noteworthy features:

Significantly improved compilation times and RAM usage
It compiles up to 10x faster and uses up to 10x less RAM for compilation than the old back-end by utilizing Boost's Mp11 library, which provides excellent support for metaprogramming with variadic templates.
In my benchmarks it even surpasses the compile time of SML, compiling up to 7 times faster and using up to 4 times less memory when building large hierarchical state machines.

Support for dependency injection
It allows the configuration of a context, of which an instance can be passed to the state machine at construction time. This context can be used for dependency injection, and in case of hierarchical state machines it is accessible from all sub state machines.

Access the root state machine from any sub state machine
When hierarchical state machines are used, we often have the need to access the upper-most, "root" state machine from any sub state machine. For example to trigger the processing of events further up in our state machine hierarchy.
For this need the back-end supports the configuration of the upper-most state machine as a root_sm. Similar to the context, the root state machine is accessible from all sub state machines.

New universal visitor API
The visitor functionality has been reworked, the result being a universal visitor API that supports various modes to traverse through a state machine's states:

Ability to select either only the currently active states or all states
Visit the sub state machines recursively (in DFS mode) or visit only the immediate sub states & sub machines without recursion

This API can be utilized for many advanced use cases, and the back-end uses it extensively in its own implementation. For example for the initialization of the context parameter in all sub state machines.

Benchmarks, the denoscription of further features and instructions how to use the new MSM back-end are available in the MSM documentation.

https://redd.it/1plfg9b
@r_cpp

looking for a technical person to build an open-source CAD prototype.

im a final year undergrad mechanical engineer working on a small and open-source parametric CAD prototype software for the past 1 year. some stuff which I have built have attracted small MSMEs and other founders who are working on text-to-CAD and generative CAD.

the goal is not a solidworks or any other CAD software replacement, but a clean and a fundamental approach to CAD. some of the features include parametric design and gd&t etc. i need someone who has a bit of CAD knowledge and the problems faced in the CAD software industry also some other stuff mentioned below.

current focus:
- parametric solid modeling (small scope)
- clean geometry core (likely opencascade / c++ or rust)
- simple architecture

i’m looking for a technical/core contributor who enjoys:
- computational geometry
- cad kernels / brep / csg
- c++ or rust systems work
- building things from first principles

this is open-source first, no hype and no guaranteed money in the beginning.

if this sounds interesting, comment or dm me with:
what you’ve built
what part you’d like to work on
happy to share more details privately.

ps: this is not just some text-to-CAD idea or where you inject AI/LLMs wherever you get to in this. i need someone who is really interested in building from scratch and especially who focuses on their fundamentals.

https://redd.it/1plgecz
@r_cpp

Surgery on Chromium Source Code: Replacing DevTools' HTTP Handler With Redis Pub/Sub
https://www.deadf00d.com/post/chromium-pub-sub-redis.html

https://redd.it/1plo625
@r_cpp

A response to the question "Does Microsoft still support C++?": (Quote) ".... still the largest single team of C++ toolset engineers employed by any one company."
https://www.reddit.com/r/cpp/comments/1pl7t3p/comment/ntsak6s/

https://redd.it/1plpzv8
@r_cpp

Faster double-to-string conversion
https://vitaut.net/posts/2025/faster-dtoa/

https://redd.it/1plrt81
@r_cpp

Certificates for c++

Hello guys I learned c++ but never had anything like a certificate. So I wanted to ask if I could get somewhere one for free for completing a course or so. Thx for replies.

https://redd.it/1pm2tlr
@r_cpp

Guildeline for becoming a pro c++ developer

Hey everyone,
I’d really appreciate some guidance from experienced engineers, especially those working at strong tech or trading firms (like Optiver, Squarepoint, Da Vinci, Rubrik, etc.).

I’m currently trying to improve my C++ skills and would love to understand how seasoned engineers approached mastering it. If you’re comfortable sharing, what kind of roadmap or focus areas helped you grow into a strong C++ engineer and become competitive for such roles?

Any advice or perspective would be very helpful. Thank you!

https://redd.it/1pm9su3
@r_cpp

Exploring macro-free testing in modern C++

Some time ago I wrote about a basic C++ unit-testing library I made that aimed to use no macros. I got some great feedback after that and decided to improve the library and release it as a standalone project. It's not intended to stand up to the giants, but is more of a fun little experiment on what a library like this could look like.

Library: https://github.com/anupyldd/nmtest

Blogpost: https://outdoordoor.bearblog.dev/exploring-macro-free-testing-in-modern-cpp/

https://redd.it/1pmflde
@r_cpp

SwedenCpp 2025
https://a4z.noexcept.dev/blog/2025/12/14/SwedenCpp-2025.html

https://redd.it/1pmfvza
@r_cpp

C++ Module Packaging Should Standardize on .pcm Files, Not Sources

Some libraries, such as fmt, ship their module sources at install time. This approach is problematic for several reasons:

If a library is developed using a modules-only approach (i.e., no headers), this forces the library to declare and ship every API in module source files. That largely defeats the purpose of modules: you end up maintaining two parallel representations of the same interface—something we are already painfully familiar with from the header/source model.
It is often argued that pcm files are unstable. But does that actually matter? Operating system packages should not rely on C++ APIs directly anyway, and how a package builds its internal dependencies is irrelevant to consumers. In a sane world, everything except libc and user-mode drivers would be statically linked. This is exactly the approach taken by many other system-level languages.

I believe pcm files should be the primary distribution format for C++ module dependencies, and consumers should be aware of the compiler flags used to build those dependencies. Shipping sources is simply re-introducing headers in a more awkward form—it’s just doing headers again, but worse

https://redd.it/1pmh814
@r_cpp