-
Stay up-to-date with everything C++! Content directly fetched from the subreddit just for you. Join our group for discussions : @programminginc Powered by : @r_channels
The Memory Safety Continuum
https://memorysafety.openssf.org/memory-safety-continuum/
https://redd.it/1jpxxmr
@r_cpp
CrashCatch Libary - A Lightweight, Header-Only Crash Reporting Library for C++
Hey r/cpp ,
I’m excited to share **CrashCatch**, a new **header-only** crash reporting library for C++ developers.
# Why CrashCatch?
I created **CrashCatch** to make crash diagnostics easier and more efficient in C++ applications. Instead of manually handling crashes or using complex debuggers, **CrashCatch** automatically generates detailed crash reports, including stack traces, exception details, and memory dumps. It’s designed to be **simple**, **lightweight**, and **cross-platform**!
# Key Features:
* **Cross-Platform**: Supports Windows, Linux, and macOS. (Linux and macOS coming soon)
* **Header-Only**: No dependencies. Just include the header and get started.
* **Minimal Setup**: Works with just a one-liner initialization or auto-init macro.
* **Crash Reports**: Generates `.dmp` and `.txt` crash logs, complete with stack traces and exception details.
* **Symbol Resolution**: Helps developers easily understand where the crash occurred.
* **Easy Integration**: Ideal for integrating into existing C++ projects without much hassle.
# Why use CrashCatch?
* **Efficient Debugging**: Captures meaningful data about the crash without needing a debugger attached.
* **Works in Production**: CrashCatch works even when the application is running in production, helping you diagnose issues remotely.
* **Simple and Lightweight**: It's a single header file with no heavy dependencies—easy to include in your project!
# Get Started:
You can easily get started with **CrashCatch** by including the header file and initializing it in just a few lines of code. Check out the full documentation and code samples on GitHub:
🔗 [CrashCatch GitHub Repository](https://github.com/keithpotz/CrashCatch)
# Future Plans:
* Support for **Linux** and **macOS** crash handling (currently only Windows is fully supported).
* **Remote Uploads**: Secure upload of crash logs.
* **Crash Viewer**: A GUI tool to view crash reports.
* **Symbol Upload Support**: For more accurate stack trace resolution.
I got sick of how cumbersome crash reporting can be in C++ and decided to make my own.
Please be sure to star my github repo to help me out (if you want to of course)
Let me know what you think!
https://redd.it/1jprcj4
@r_cpp
Cpp embedded
At what level can I learn cpp for embedded in 5 months as a total beginner? I can dedicate 2 hours every day to studying
https://redd.it/1jponf9
@r_cpp
Qt 6.9 released
https://www.qt.io/blog/qt-6.9-released
https://redd.it/1jplwsq
@r_cpp
Clang 20 has been released
https://releases.llvm.org/20.1.0/tools/clang/docs/ReleaseNotes.html
https://redd.it/1jpimnn
@r_cpp
Coding
How to learn coding ? Can Anybody give .e roadmap
https://redd.it/1jph0ou
@r_cpp
Why is there no support for pointers to members of members?
C++ gives us pointers to data members, which give us a way of addressing data members:
struct S { int x; };
int (S::p) = &S::x;
S s = {.x = 1};
std::println("{}", s.p);
I think of int (S::*) as "give me an S and I'll give you an int". Implementation-wise, I think of it as a byte offset. However, consider the following:
struct Inner { int x; };
struct Outer { Inner i; };
Outer o = {.i = {.x = 1}};
int (Outer::p) = <somehow reference o.i.x>;
This seems reasonable to me, both from an implementation perspective (it's still just an offset) and an interpretation perspective (give me an Outer and I'll give you an int). Is there any technical reason why this isn't a thing? For instance, it could be constructed through composition of member pointers:
// placeholder syntax, this doesn't work
int (Outer::p) = (&Outer::inner).(&Inner::x);
Implementation-wise, that would just be summing the offsets. Type-checker-wise, the result type of the first pointer and the object parameter type of the second pointer have to match.
https://redd.it/1jp2nsm
@r_cpp
Is learning c++ in 2025 worth it?
https://redd.it/1jommgg
@r_cpp
Dependencies Have Dependencies (Kitware-CMake blog post about CPS)
https://www.kitware.com/dependencies-have-dependencies/
https://redd.it/1jobwcn
@r_cpp
Compiler Options Hardening Guide for C and C++
https://best.openssf.org/Compiler-Hardening-Guides/Compiler-Options-Hardening-Guide-for-C-and-C++.html
https://redd.it/1jo6dz6
@r_cpp
perfect forwarding identity function
Recently I've been thinking about a perfect forwarding identity function (a function that takes an argument and returns it unchanged). Since C++20, we have `std::identity` in the standard library with a function call operator with the following signature:
template< class T >
constexpr T&& operator()( T&& t ) const noexcept;
so one might think that the following definition would be a good identity function:
template <class T> constexpr T&& identity(T&& t) noexcept {
return std::forward<T>(t);
}
however, this quickly falls apart when you try to use it. For example,
auto&& x = identity(std::to_string(42));
creates a dangling reference.
This made me wonder.
Would the following be a better definition?
template <class T> constexpr T identity(T&& t) noexcept {
return std::forward<T>(t);
}
Are there any downsides? Why does `std::identity` return `T&&` instead of `T`? Was there any discussion about this when it was introduced in C++20?
What even are the requirements for this identity function? `identity(x)` should be have the same type and value as `(x)` for any expression `x`. Is this a good definition for an identity function? For `std::identity` this is already not the case since `(42)` has type `int` whereas `std::identity()(42)` has type `int&&`.
https://redd.it/1jo0zpp
@r_cpp
What should i start with?
I want to start to learn c++ but i don't know where to start but i have studied c programming and python (a little more than basics). Should i start with a book or follow any youtuber or any other platform (free) . I thought to start with a book and got recommended of "tour of c++" by Bjarne Stroustrup. Is it ok to start with this or should i start with something else. And I also want to complete DSA from c++, so please help me and guide me.
https://redd.it/1jnxp2o
@r_cpp
Safe array handling? Never heard of it
https://pvs-studio.com/en/blog/posts/cpp/1241/
https://redd.it/1jny9j5
@r_cpp
CPP to exe
Hello cpp community. I'm brand new to coding using codeblocks to write.
I used Build, compile run file to turn my code into a desktop application but the exe won't open, I get a .DLL error
What steps should I be taking instead?
https://redd.it/1jnuekg
@r_cpp
The Art of Creating Audio Nightmares with a Human Voice - Sébastien Croteau - [https://youtu.be/oGg7JvAYilg](https://youtu.be/oGg7JvAYilg)
* How To Read Scientific DSP Publications and Turn Them Into Code - Matthijs Hollemans - [https://youtu.be/KdFQDnwav0Y](https://youtu.be/KdFQDnwav0Y)
2025-03-17 - 2025-03-23
* Can Audio Programming be Safe? - Dave Rowland - [https://youtu.be/Uda9h52pzuA](https://youtu.be/Uda9h52pzuA)
* Mind-Matched Audio - Revolutionizing the Reading Experience through Real-Time Sound Synchronization - Luigi Cosi - [https://youtu.be/-InjTgLaUZs](https://youtu.be/-InjTgLaUZs)
* Using JavaScript to Render a DAW User Interface at 60 FPS - Arthur Carabott - [https://youtu.be/t5vbPn\_9j70](https://youtu.be/t5vbPn_9j70)
2025-03-10 - 2025-03-16
* Our Ultra-Processed Interfaces - What Music Technology Can Learn From Doritos - Astrid Bin - [https://youtu.be/b1oNQRGIJw8](https://youtu.be/b1oNQRGIJw8)
* Automated Analog Circuit Modeling - C++, Python, MATLAB, and XML - Eric Tarr - [https://youtu.be/JBxKUXiHzJI](https://youtu.be/JBxKUXiHzJI)
* Engineering Success for Audio Software in a Crowded Market - Randy Young - [https://youtu.be/5bGMyfSIPcM](https://youtu.be/5bGMyfSIPcM)
2025-03-03 - 2025-03-09
* Workshop: Practical Machine Learning - Embed a generative AI model in your app and train your own interactions with it - Anna Wszeborowska, Harriet Drury, Sohyun Im, Julia Läger & Pauline Nemchak - [https://youtu.be/D-FRkvT5Npk](https://youtu.be/D-FRkvT5Npk)
* Keynote: Interfaces are King! - A Practical Look at AI Audio Tools and What Audio Professionals Actually Need - Andrew Scheps - [https://youtu.be/lVF6qFN0Ges](https://youtu.be/lVF6qFN0Ges)
* Challenges in Real-Time Physical Modelling for Sound Synthesis - Silvin Willemsen - [https://youtu.be/6MCS34QsyDQ](https://youtu.be/6MCS34QsyDQ)
2025-02-24 - 2025-03-02
* A Critique of Audio Plug-In Formats - VST, AU, AAX, JUCE and Beyond - Fabian Renn-Giles - [https://youtu.be/nPJpX8GR9d4](https://youtu.be/nPJpX8GR9d4)
* GPU Based Audio Processing Platform with AI Audio Effects - Are GPUs ready for real-time processing in live sound engineering? - Simon Schneider - [https://youtu.be/uTmXpyRKJp8](https://youtu.be/uTmXpyRKJp8)
* Learning While Building - MVPs, Prototypes, and the Importance of Physical Gesture - Roth Michaels - [https://youtu.be/rcKl4PVHMMQ](https://youtu.be/rcKl4PVHMMQ)
**Meeting C++**
2025-03-24 - 2025-03-30
* C++ Memory Management - an Interview with Patrice Roy - [https://www.youtube.com/watch?v=R5e1SwoC53c](https://www.youtube.com/watch?v=R5e1SwoC53c)
2025-03-17 - 2025-03-23
* Beginning with C++ - an Interview with Slobodan Dmitrovic - [https://www.youtube.com/watch?v=BDjp9ScWXMk](https://www.youtube.com/watch?v=BDjp9ScWXMk)
* Not getting lost in translation - Daniela Engert - [https://www.youtube.com/watch?v=SwPy0aCmMEA](https://www.youtube.com/watch?v=SwPy0aCmMEA)
2025-03-10 - 2025-03-16
* Clean CMake for C++ (library) developers - Kerstin Keller - [https://www.youtube.com/watch?v=k76LN8dSxx4](https://www.youtube.com/watch?v=k76LN8dSxx4)
* An Introduction to Swarm Intelligence Algorithms - Frances Buontempo - [https://www.youtube.com/watch?v=ur\_Yv935rJ8](https://www.youtube.com/watch?v=ur_Yv935rJ8)
2025-03-03 - 2025-03-09
* The Aging Programmer - Kate Gregory - [https://www.youtube.com/watch?v=hs8EGgoJpdQ](https://www.youtube.com/watch?v=hs8EGgoJpdQ)
* Stories from a parallel universe - Jana Machutová - [https://www.youtube.com/watch?v=mdKdkVskrJ8](https://www.youtube.com/watch?v=mdKdkVskrJ8)
* The Beman Project: bringing standard libraries to the next level - David Sankel - [https://www.youtube.com/watch?v=GRfTzzVG6vI](https://www.youtube.com/watch?v=GRfTzzVG6vI)
2025-02-24 - 2025-03-02
* Introduction to Sender/Receiver framework - Goran Aranđelović - [https://www.youtube.com/watch?v=wcPbuYQpWPI](https://www.youtube.com/watch?v=wcPbuYQpWPI)
* The Many Variants of std::variant - Nevin Liber - [https://www.youtube.com/watch?v=GrCAb1RShxE](https://www.youtube.com/watch?v=GrCAb1RShxE)
* Testable by Design - Steve Love
Where do I start?
I want to learn C++ and learn how to integrate it for unreal engine. I'm a ComSci major in the first year and I'm pretty decent with C because that's what out prof has been teaching us, but I asked if he will teach his class C++ and he said no because for 2nd years, he's teaching python. Where do I learn C++ that give assignments too so I can learn and apply what I learned for each C++ topic.
https://redd.it/1jpvftk
@r_cpp
C++20 in Chromium (talk series)
https://youtube.com/playlist?list=PL9ioqAuyl6UK-d0CS7KF9ToelBJVzxrkv&si=qd0AWH8DfobdZjAN
https://redd.it/1jpr2sm
@r_cpp
The usefulness of std::optional<T&&> (optional rvalue reference)?
Optional lvalue references (std::optional<T&>) can sometimes be useful, but optional rvalue references seem to have been left behind.
I haven't been able to find any mentions of std::optional<T&&>, I don't think there is an implementation of std::optional that supports rvalue references (except mine, opt::option).
Is there a reason for this, or has everyone just forgotten about them?
I have a couple of examples where std::optional<T&&> could be useful:
Example 1:
class SomeObject {
std::string string_field = "";
int number_field = 0;
public:
std::optional<const std::string&> get_string() const& {
return number_field > 0 ? std::optional<const std::string&>{string_field} : std::nullopt;
}
std::optional<std::string&&> get_string() && {
return number_field > 0 ? std::optional<std::string&&>{std::move(string_field)} : std::nullopt;
}
};
SomeObject get_some_object();
std::optional<std::string> process_string(std::optional<std::string&&> arg);
// Should be only one move
std::optional<std::string> str = process_string(get_some_object().get_string());
Example 2:
// Implemented only for rvalue `container` argument
template<class T>
auto optional_at(T&& container, std::size_t index) {
using elem_type = decltype(std::move(container[index]));
if (index >= container.size()) {
return std::optional<elem_type>{std::nullopt};
}
return std::optional<elem_type>{std::move(container[index])};
}
std::vector<std::vector<int>> get_vals();
std::optional<std::vector<int>> opt_vec = optional_at(get_vals(), 1);
Example 3:
std::optional<std::string> process(std::optional<std::string&&> opt_str) {
if (!opt_str.has_value()) {
return "12345";
}
if (opt_str->size() < 2) {
return std::nullopt;
}
(*opt_str)[1] = 'a';
return std::move(*opt_str);
}
https://redd.it/1jpnz3t
@r_cpp
C++ Show and Tell - April 2025
Use this thread to share anything you've written in C++. This includes:
* a tool you've written
* a game you've been working on
* your first non-trivial C++ program
The rules of this thread are very straight forward:
* The project must involve C++ in some way.
* It must be something you (alone or with others) have done.
* Please share a link, if applicable.
* Please post images, if applicable.
If you're working on a C++ library, you can also share new releases or major updates in a dedicated post as before. The line we're drawing is between "written in C++" and "useful for C++ programmers specifically". If you're writing a C++ library or tool for C++ developers, that's something C++ programmers can use and is on-topic for a main submission. It's different if you're just using C++ to implement a generic program that isn't specifically about C++: you're free to share it here, but it wouldn't quite fit as a standalone post.
Last month's thread: https://www.reddit.com/r/cpp/comments/1j0xv13/c_show_and_tell_march_2025/
https://redd.it/1jpjhq3
@r_cpp
Is there any way to stop generating .bat/.sh generator conan files in time of installing conan package from remote repositories (in conan 2.x)?
I am using conan version 2.12 and this command:
conan install <conanfile> -r <repo-name> --output-folder=<outer-folder> --build=missing
This is the sample code:
from conan import ConanFile
from conan.tools.files import copy
from conan.tools.env import Environment
from conan.tools.files import rm
import os
class ConsumerConan(ConanFile):
requires = "hello/5.0@ab/stable"
def layout(self):
self.folders.source = "."
self.folders.build = "build"
self.folders.generators = "generator"
def generate(self):
for dep in self.dependencies.values():
for incdir in dep.cpp_info.includedirs:
copy(self, "*.h", incdir, os.path.join(self.build_folder, "headers"))
copy(self, "*.cpp", incdir, os.path.join(self.build_folder, "src"))
copy(self, "*", incdir, os.path.join(self.build_folder, "package"))
copy(self, "*.h", os.path.join(os.path.dirname(incdir),"foo"), os.path.join(self.build_folder, "all"))
copy(self, "*.h", os.path.dirname(incdir), os.path.join(self.build_folder, "all2"))
copy(self, "*", incdir, os.path.join(self.build_folder, "all3"))
As per my requirements, I have to copy the package content in the build folder. But I want to stop the autogeneration of .bat/.sh files(which will be generated inside the generator folder) without using any extra cleanup python scipt.
Thanks in advance!
https://redd.it/1jphno6
@r_cpp
Why No Base::function or Parent::function calling?
I understand C++ supports multiple inheritance and as such there COULD be conceivable manners in which this could cause confusion, but it can already cause some confusion with diamond patterns, or even similar named members from two separate parents, which can be resolved with virtual base class…
Why can’t it just know Parent::function() (or base if you prefer) would just match the same rules? It could work in a lot of places, and I feel there are established rules for the edge cases that appear due to multiple inheritance, it doesn’t even need to break backwards compatibility.
I know I must be missing something so I’m here to learn, thanks!
https://redd.it/1jpcl3j
@r_cpp
Evaluate my code design level
#include <iostream>
#include <vector>
#include <functional>
#include <string>
using namespace std;
struct FBodyNodeBase
{
virtual bool CanWork()
{
return true;
}
void ForeachImp(function<void(FBodyNodeBase)> InFunction)
{
InFunction(this);
for (size_t i = 0; i < BodyNodes.size(); i++)
{
BodyNodes[i]->ForeachImp(InFunction);
}
}
vector<FBodyNodeBase> BodyNodes;
string Name;
};
template<typename T>
struct TBodyNode : public FBodyNodeBase
{
void Foreach(function<void(FBodyNodeBase)> InFunction)
{
Node = (T)this;
ForeachImp(InFunction);
Node = nullptr;
}
static T Node;
};
template<typename T>
T TBodyNode<T>::Node = nullptr;
struct FBody : public TBodyNode<FBody>
{
FBody() { Name = "Body"; }
bool Pelvis = false;
};
struct FLeg : public TBodyNode<FLeg>
{
FLeg() { Name = "Leg"; }
bool Ankle = true;
virtual bool CanWork()
{
if (!FBody::Node)
return false;
return FBody::Node->Pelvis;
}
};
struct FFoot : public TBodyNode<FFoot>
{
FFoot() { Name = "Foot"; }
virtual bool CanWork()
{
if (!FLeg::Node)
return false;
return FLeg::Node->Ankle;
}
};
int main()
{
FBody Body = new FBody();
Body->Pelvis = false;
FLeg Leg = new FLeg();
Leg->Ankle = false;
FFoot Foot = new FFoot();
Body->BodyNodes.push_back(Leg);
Leg->BodyNodes.push_back(Foot);
Body->Foreach([](FBodyNodeBase Body)
{
cout << Body->Name << (Body->CanWork() ? " Can work" : " Can't work") << endl;
});
delete Body;
delete Leg;
delete Foot;
return 0;
}
https://redd.it/1jopsel
@r_cpp
Creating a Simple UI (as a C# Developer)
I've been writing C# for over 10yr and am expert level in my field of robotics. I generally only use C for embedded programming but now I want to really learn C++. The issue I often run into with C/C++ is finding a good workflow for development, UI, and deployment. For example, in C# you'll only need to install visual studio and you can have an interactive UI running in under 30s without typing any code. Just drag some buttons on the screen and press run.
There have been times I've tried to create a simple application using C++ but got discouraged because of how difficult it is to just get a UI with a couple buttons and a text window running. I really hate learning from a console application because it's too basic to do anything engaging or to cover a wide range of concepts like threading, flow control, OOP, etc.
At some point, I'd love to have create a simple game like tetris, pong, or even a calculator in C++ to give me some confidence writing C++ but again, I'm finding it difficult to find any UI examples besides console programs. What is the best way to just get some basic UI components on the screen so I can start programming? And what workflow/ide do you recommend I start with? Anything similar to winforms that I'm already used to?
https://redd.it/1joi1yc
@r_cpp
Warning against purchasing Visual Assist
I have been buying their software for years but their support is absolutely horrendous. If you had auto renewal turned on there is no warning and no ability to contact support. They simply charge you full amount and when you try and get assistance from them they give you rude responses. Their software updates are slow which forces you to purchase new licenses if you need crucial features. Software like rider has all of its features and more and doesn't do shady practices like them. I would highly recommend against purchasing visual assist.
https://redd.it/1jo6lka
@r_cpp
Sourcetrail 2025.4.1 released
Hi everybody,
Sourcetrail 2025.4.1, a C++/Java source explorer, has been released with updates to the Java Indexer and macOS build, namely:
Java: Add Support for record classes
macOS: Fix vcpkg build. Thanks to ChristianWieden for the help
https://redd.it/1jo0g73
@r_cpp
Is OpenGL immediate mode still relevant?
I'm trying to make a windows application that does a bit of spline editing and 3D rendering. Basically I want to edit a set of 2D contours and procedurally generate a 3D mesh. (I know I could potentially do it as a Fusion360 or Blender plugin, but the use case is simple enough that I am considering just making a standalone application.)
I did something similar 10 years ago by setting up the UI as a basic win32 window with OPENGL viewport, catching mouse events to rotate the 3D view and add/move points. Rendering was done via OpenGL immediate mode, e.g. by saying "glBegin(GL_TRIANGLES)" and then giving a list of glVertex3f.
It's been a while, so I'm just curious if there is a better more "modern" way of doing things now? The core processing and mesh generation is in C++ and I don't really want to change that, so I'm not terribly interested in messing around with C#. I don't need a full-blown UI, nor do I care much about portability, so I don't think I need to mess with QT. But if anyone has any suggestions I'd be grateful to hear.
https://redd.it/1jo09qq
@r_cpp
Crate-training Tiamat, un-calling Cthulhu:Taming the UB monsters in C++
https://herbsutter.com/2025/03/30/crate-training-tiamat-un-calling-cthulhutaming-the-ub-monsters-in-c/
https://redd.it/1jnyqfq
@r_cpp
Crate-training Tiamat, un-calling Cthulhu:Taming the UB monsters in C++
https://herbsutter.com/2025/03/30/crate-training-tiamat-un-calling-cthulhutaming-the-ub-monsters-in-c/
https://redd.it/1jnxa7z
@r_cpp
- [https://www.youtube.com/watch?v=HNjf6LV5d50](https://www.youtube.com/watch?v=HNjf6LV5d50)
https://redd.it/1jnjrv7
@r_cpp
New C++ Conference Videos Released This Month - March 2025 (Updated to Include Videos Released 2025-03-24 - 2025-03-31)
**CppCon**
2025-03-24 - 2025-03-30
* A New Dragon in the Den: Fast Conversion From Floating-Point Numbers in C++ - Cassio Neri - [https://youtu.be/fPZ1ZdA7Iwc](https://youtu.be/fPZ1ZdA7Iwc)
* Code Generation from Unified Robot Description Format (URDF) for Accelerated Robotics - Paul Gesel - [https://youtu.be/CwN0I8yUqok](https://youtu.be/CwN0I8yUqok)
* How to Hide C++ Implementation Details - Amir Kirsh - [https://youtu.be/G5tXjYzfg9A](https://youtu.be/G5tXjYzfg9A)
* Why Is My C++ Build So Slow? Compilation Profiling and Visualization - Samuel Privett - [https://youtu.be/Oih3K-3eZ4Y](https://youtu.be/Oih3K-3eZ4Y)
* Gazing Beyond Reflection for C++26 - Daveed Vandevoorde - [https://youtu.be/wpjiowJW2ks](https://youtu.be/wpjiowJW2ks)
2025-03-17 - 2025-03-23
* Back to Basics: Rvalues and Move Semantics in C++ - Amir Kirsh - [https://youtu.be/i\_Z\_o9T2fNE](https://youtu.be/i_Z_o9T2fNE)
* Modern C++ Development - Limitations and Problems in std::function and Similar Constructs: Mitigations and Alternatives - Amandeep Chawla - [https://youtu.be/clpQVn\_LAiM](https://youtu.be/clpQVn_LAiM)
* Investigating C++ Legacy Design Trends: Newer Isn’t Always Better! - Katherine Rocha - [https://youtu.be/ffz4oTMGh5E](https://youtu.be/ffz4oTMGh5E)
* Boosting Software Efficiency in C++: A Case Study of 100% Performance Improvement in an Embedded C++ System - Gili Kamma - [https://youtu.be/LE1ocLWiUKQ](https://youtu.be/LE1ocLWiUKQ)
* Back to Basics: Lifetime Management in Cpp - Phil Nash - [https://youtu.be/aMvIv6blzBs](https://youtu.be/aMvIv6blzBs)
2025-03-10 - 2025-03-16
* Using Modern C++ to Build XOffsetDatastructure: A Zero-Encoding and Zero-Decoding High-Performance Serialization Library in the Game Industry - Fanchen Su - [https://youtu.be/agRbVcMkqTY](https://youtu.be/agRbVcMkqTY)
* Monadic Operations in Modern C++: A Practical Approach - Vitaly Fanaskov - [https://youtu.be/Ely9\_5M7sCo](https://youtu.be/Ely9_5M7sCo)
* C++ Sender Patterns to Wrangle C++ Concurrency in Embedded Devices - Michael Caisse - [https://youtu.be/a2gLF9Supic](https://youtu.be/a2gLF9Supic)
* Template-less Metaprogramming in C++ - Kris Jusiak - [https://youtu.be/yriNqhv-oM0](https://youtu.be/yriNqhv-oM0)
* Cost of C++ Abstractions in C++ Embedded Systems - Marcell Juhasz - [https://youtu.be/7gz98K\_hCEM](https://youtu.be/7gz98K_hCEM)
2025-03-03 - 2025-03-09
* Modern C++ Error Handling - Phil Nash - [https://youtu.be/n1sJtsjbkKo](https://youtu.be/n1sJtsjbkKo)
* Adventures with C++ Legacy Codebases: Tales of Incremental Improvement - Roth Michaels - [https://youtu.be/lN-dd-0PjRg](https://youtu.be/lN-dd-0PjRg)
* Deciphering C++ Coroutines Part 2 - Mastering Asynchronous Control Flow - Andreas Weis - [https://youtu.be/qfKFfQSxvA8](https://youtu.be/qfKFfQSxvA8)
* spanny 2: Rise of C++ std::mdspan - Griswald Brooks - [https://youtu.be/2VlK0vFZc7k](https://youtu.be/2VlK0vFZc7k)
* Implementing C++ Reflection Using the New C++20 Tooling Opportunity: Modules - Maiko Steeman - [https://youtu.be/AAKA5ozAIiA](https://youtu.be/AAKA5ozAIiA)
2025-02-24 - 2025-03-02
* C++/Rust Interop: A Practical Guide to Bridging the Gap Between C++ and Rust - Tyler Weaver - [https://youtu.be/RccCeMsXW0Q](https://youtu.be/RccCeMsXW0Q)
* Cross-Platform Floating-Point Determinism Out of the Box - Sherry Ignatchenko - [https://youtu.be/7MatbTHGG6Q](https://youtu.be/7MatbTHGG6Q)
* C++ Data Structures That Make Video Games Go Round - Al-Afiq Yeong - [https://youtu.be/cGB3wT0U5Ao](https://youtu.be/cGB3wT0U5Ao)
* Moved-from Objects in C++ - Jon Kalb - [https://youtu.be/FUsQPIoYoRM](https://youtu.be/FUsQPIoYoRM)
* When Nanoseconds Matter: Ultrafast Trading Systems in C++ - David Gross - [https://youtu.be/sX2nF1fW7kI](https://youtu.be/sX2nF1fW7kI)
**Audio Developer Conference**
2025-03-24 - 2025-03-30
* Writing Correct C++ GUI Code: Bug-Free JUCE UI - Jan Wilczek - [https://youtu.be/Ur\_sTOe-1LI](https://youtu.be/Ur_sTOe-1LI)
* Creature Vocalizations in Video Games -