San Diego C++ Meetup #85 – April 2026 Edition: Vector Pitfalls and Memory Management

Posted on by Kobi

Another fantastic month, another great San Diego C++ Meetup! On April 14th, 2026, we hosted our 85th session. We had an incredibly insightful meetup packed with brain-teasing code snippets, a serious deep dive into memory management, and lively discussions about the evolving tech landscape.

If you missed the live session or want to revisit the technical deep dives, all the resources and recordings are available below!

The Agenda

As outlined in our presentation, this month’s meeting was broken down into three main segments:

  1. C++ Quiz: Testing our knowledge with challenging snippets and edge cases from cppquiz.org.
  2. Vector Pitfalls: A deep dive into memory management and the non-trivial mechanics of std::vector.
  3. Catching Up: Reviewing the latest industry news, community updates, and C++ ecosystem trends.

Session Highlights

1. C++ Quiz

We kicked things off with a few head-scratchers from cppquiz.org, focusing on C++23 standards. We explored a particularly common pitfall regarding std::vector initialization – specifically, the subtle traps of passing string literals into initializer lists and how the compiler chooses constructor candidates. We also did a quick refresher on the zero-initialization rules for static local variables.

2. Deep Dive: Vector Pitfalls & Memory Management

The core of this month’s meetup was an intensive look at what it takes to implement a custom, std::vector-like container correctly.

We explored:

  • Raw Memory Allocation: Why and how to use malloc or uninitialized memory instead of default new to avoid paying the overhead of unwanted object construction.
  • The Rule of Five and Custom Deleters: How hiding tear-down logic inside a std::unique_ptr with a custom stateful deleter can subtly break your compiler-generated copy/move assignments and swap operations (especially if you accidentally use reference members!).
  • Exception Safety Guarantees: A close look at std::uninitialized_copy and how to prevent catastrophic “double destruction” and memory leaks when dealing with raw memory blocks during operations like reserve().

During this segment, we also gave a huge shoutout to some must-read C++ books, specifically highlighting works by Patrice Roy (on memory management) and Klaus Iglberger (C++ Software Design). If you are looking to level up your C++ architecture, these are absolute top-tier recommendations.

3. Catching Up & Community Trends

We wrapped up the technical presentation by highlighting some excellent community resources, including Sandor’s deep-dive blog series on std::chrono (covering time zones and clocks up through C++20) and Jason Turner’s site tracking C++ standard changes.

The session ended with a fantastic open discussion about the intersection of C++ and AI. We talked about using Google’s NotebookLM as a study aid for massive C++ textbooks, shared thoughts on Anthropic’s Claude, and swapped stories from the recent NVIDIA GTC conference.

Event Resources

Catch up on everything we discussed using the links below:

A huge thank you to everyone who joined us, asked questions, and contributed to the discussion. If you are looking for a C++ mentor or are willing to be one, please reach out via our Discord channel!

See you at the next one!

Kobi

San Diego C++ Meetup #84: March 2026 Edition – UNDO – Agentic Debugging Using Time Travel

Posted on by Kobi

Hello everyone!

Last Tuesday, March 10th, we held our 84th San Diego C++ Meetup. This was a special “super-fast” edition where we broke our usual virtual routine to meet in person at Qualcomm. It was a packed house with great pizza and even better technical discourse.

Our New Home on Luma

As mentioned in our previous sessions, we have officially moved away from the Meetup.com platform. To stay updated with our future events and sync them to your calendar, please follow our new dedicated page.

Join our community calendar here: https://luma.com/sdcppmu

At this time, we are no longer seeking additional sponsorships, but we are excited to focus on growing our community through this new platform.

The Main Event: Agentic Debugging Using Time Travel

We were honored to host Dr. Greg Law, co-founder and CEO of Undo, who flew in from England to share his insights on “Agentic Debugging.” Greg is a programmer at heart with over 25 years of experience in the software industry, and his talk focused on how time travel debugging is evolving alongside AI.

The event page on Luma: https://luma.com/8lwifeef

Why Time Travel Debugging?

Greg opened with a classic Brian Kernighan quote: “Debugging is twice as hard as writing the program in the first place.” If you are as clever as you can be when you write it, how will you ever debug it?

Traditional debuggers tell you what is happening now, but they don’t tell you what happened in the past. Time travel debugging treats a program’s execution like a “core file for every instruction,” allowing you to reason backward from a failure to the root cause.

Key Highlights from the Talk:

  • Doom as a Debugging Sandbox: Greg demonstrated the power of time travel by using a recording of Chocolate Doom. He showed how to find the exact line of code where a zombie was killed simply by tracking the “last” time a specific pixel value changed on the screen and following the data back to the health decrement.
  • The implementation of “Magic”: We went under the hood to see how Undo works. Unlike naive state-saving, it uses a JIT (Binary Translation) to record only non-deterministic events (system calls, thread switches, signals, and shared memory accesses). This allows for high-performance recording that can be replayed deterministically.
  • The AI Revolution (Agentic Debugging): The most exciting part of the talk was seeing how Large Language Models (LLMs) like Claude can be given “tools” to drive the debugger. Greg showed an agent diagnosing a subtle reference-counting bug in CPython that had previously taken human maintainers weeks to solve.
  • Backwards Reasoning: AI agents are remarkably good at tool-use when constrained. By allowing an agent to “reverse-step” and “trace” values through a time-travel recording, we can move from manually hunting bugs to simply asking the agent to “find where this door opened” or “explain why this pointer is null.”

Recording

If you couldn’t make it to Qualcomm or want to re-watch Greg’s live demos of the AI agent in action, the full recording is available below:

Special Thanks

This meetup was a collaborative effort, and I want to extend several thank yous:

First, a huge thanks to the UNDO team for coming to San Diego. Specifically, thank you to Greg Law for the fantastic presentation and Tony for his collaboration and help in making this session a reality.

I also want to thank Qualcomm and Brian for orchestrating the venue and hosting us.

Finally, thank you to our long-term supporters. We thank Packt Publishing for their ongoing support and technical resources, and JetBrains for their generous sponsorship over the past year which helped us keep the community thriving.

Closing Thoughts

It was a treat to see so many of you in person. The intersection of AI and low-level C++ debugging is a fascinating frontier, and Greg’s talk gave us a lot to think about regarding the future of our workflow.

Don’t forget to register on Luma to stay in the loop for our April meeting.

See you at #85!

Kobi

San Diego C++ Meetup #83: February 2026 Edition

Posted on by Kobi

Last night we held our 83rd San Diego C++ Meetup. It was a fantastic evening filled with deep technical discussions and a significant announcement regarding the future of our community infrastructure.

The Big Announcement: Moving to Luma

The biggest news from this meeting is that we are officially moving away from Meetup.com. To streamline our event management and provide a better experience for our members, we have transitioned to Luma.

We now have a dedicated San Diego C++ Meetup calendar on Luma where you can see all upcoming sessions, register for events, and sync them directly to your personal calendar.

Please register on our new platform here: https://luma.com/sdcppmu

The Main Presentation: Hidden Dangers in Static Polymorphism

I delivered a deep dive into the “Hidden Dangers in Static Polymorphism.“

The event page on Luma.com: https://luma.com/24rt9aa0 (also on meetup: https://www.meetup.com/san-diego-cpp/events/313044656)

A major highlight of the talk was debunking the myth that static polymorphism is a “cure-all” for the issues found in dynamic polymorphism. Specifically, I demonstrated that slicing remains a significant threat in both worlds.

Slicing, CRTP, and std::tuple

We explored how slicing occurs when a derived object is copied into a base class storage, resulting in the loss of derived data and behavior. Even when using the Curiously Recurring Template Pattern (CRTP), developers can inadvertently trigger slicing if they aren’t careful with how objects are stored or passed.

I showed specific examples of how std::tuple can lead to slicing issues when attempting to store heterogeneous types that share a CRTP base. The talk covered:

  • Detection: How to use static_assert and deleted constructors to catch slicing at compile time.
  • Avoidance: Strategies for maintaining type identity without falling into the “value-based” slicing trap.

Modern C++ Solutions

The presentation moved beyond the “dangers” to show how modern C++ features provide safer alternatives for polymorphism:

std::apply and Variadic Templates: Powerful techniques for processing heterogeneous collections (like tuples) in a generic and type-safe manner.

C++20 Concepts: Using concepts to constrain template parameters, providing better error messages and ensuring that types satisfy the required interface without requiring a common base class.

std::variant and std::visit: An exploration of “closed” polymorphism where type safety is guaranteed and slicing is avoided by providing a type-safe union.

Recording

If you missed the live session or want to revisit the technical details, you can watch the full recording here:

Special Thanks to Our Sponsors

This community continues to thrive thanks to the generous support of our partners.

I would like to extend a huge thank you to JetBrains for their ongoing support in covering our meetup fees and dues. Their contribution ensures that our platform remains accessible to everyone.

I also want to thank Packt Publishing for partnering with us and providing excellent technical resources and books to our community members.

Closing Thoughts

It was great to see everyone and engage in such high-quality C++ discourse. Don’t forget to join our new Luma calendar to stay updated on our March meeting and beyond.

See you at #84!

Kobi

San Diego C++ Meetup #82 – January 2026 Edition

Posted on by Kobi

Hello everyone and Happy New Year!

I hope you all had a wonderful holiday season and are ready for another year of deep diving into our favorite language.

We kicked off 2026 this past Tuesday, January 13th, with our 82nd session. It was great to see everyone again; our community continues to grow, now reaching 1,874 members!

Our Supporters

Before we jump into the technical highlights, I want to take a moment to thank our sponsors who keep this community thriving.

A huge thank you to JetBrains for sponsoring our meetup fees. These costs aren’t small (reaching into the hundreds), and having their support allows us to focus entirely on the C++ content and our members.

We also want to acknowledge Packt Publishing. I’ve been spending my free time recently with a copy of Software Architecture with C++. It is a massive book – around 700 pages – and while the first few chapters cover the theoretical ground, it gets incredibly advanced from chapter five onwards. If you’re looking to push your boundaries in C++20 and beyond, I highly recommend it. Packt has been kind enough to provide a CPP20 discount code for the ebook if you want to check it out yourself!

The Main Event: C#-Style Properties in C++

Our special guest for the evening was our very own Martin Vorbrodt. Martin has been a staple of the C++ community for years, with a career spanning computer forensics, automated trading, and storage drivers.

Aside from his technical prowess, we also had something to celebrate: Martin is starting a new position next week! Congrats, Martin!

The Motivation

Martin’s talk was based on his recent work implementing C#-style properties in C++. The goal was simple but ambitious: provide the encapsulation of a getter/setter mechanism while maintaining the clean, intuitive syntax of a public data member.

We’ve all been told that public data members are a “big no-no” because you lose control over how data is accessed or modified. Martin’s implementation solves this by using a policy-based design that intercepts read and write operations without requiring the user to call get_x() or set_x() explicitly.

Implementation Highlights

Martin walked us through the <em>property.hpp</em> and <em>property.cpp</em> files from his blog repository. The implementation is a masterclass in modern C++20:

  • Policy-Based Design: The property<T> class template uses policies to control storage and access. The default policy stores the value in memory, but Martin demonstrated an FS Property (File System) policy where the value is actually stored and retrieved from disk.
  • C++20 Concepts: The code uses concepts heavily to enable or disable member methods and operators based on whether the underlying type is a primitive, a container, or a smart pointer.
  • Zero Overhead (Mostly): By default, sizeof(property<T>) is equal to sizeof(T). This is achieved by avoiding storing extra state inside the property itself when possible.
  • Event Dispatching: One of the “killer features” is the ability to register an update procedure. You can subscribe to a property, and whenever its value is modified, your lambda or function is triggered – much like property changed events in C#.
  • Explicit vs. Implicit Access: While it behaves like a variable, Martin specifically made the cast to a non-const reference explicit. This ensures that you don’t accidentally bypass the setter mechanism without meaning to.

Code: https://github.com/mvorbrodt/blog/blob/master/src/property.cpp

Q&A and Caveats

The session included some great discussion. One of the questions raised was about thread safety. Martin noted that the current event dispatching uses a static map, which isn’t thread-safe out of the box, though it could be adapted for thread-local storage or protected with a mutex if needed.

We also talked about “caching” for the File System policy. Currently, it reads/writes to disk on every access, but the beauty of the policy-based design is that a user could easily inherit from the policy to add a caching layer.

Resources and Wrap-up

f you missed the live session or want to revisit the details, you can find the event page, recording, and source code below:

Thank you again to Martin for sharing his work and to everyone who attended and asked questions. It’s a fantastic way to start the year.

See you all in February!

Kobi