Author: Kobi

Hello everyone!

Here is the summary of the last session, took place on Tuesday, April 15 2025.

The session had few topics discussed.

First, I’d like to announce that we have a new Sponsor to our meetup!

Jetbrains has generously agreed to sponsor the yearly Meetup fees!

It is super fun to have your favorite editor being the one sponsor it. Such a win win for me 🙂

Thank you Maria and the team from Jetbrains helping me on that!

Meetup page can be found here

The recording can be found here:

Discussion points in the meetup:

1. What am I snacking – I talked a bit on Patrice Roy‘s new book “C++ Memory Management” which is an excellent book! Grab it!
2. AI Assistant and vibe coding. Gave some insights from my experience working on multiple tools, evaluating multiple plugins to IDEs. And it’s fantastic. I’m so scared! The future is here and things IMO will only get better. Senior engineers will have super powers, Junior engineers would need to make sense of what is given to them and I’m afraid that w/o enough experience, this is a challenging part.
3. Quiz How much impact RTTI (class types w/ or w/o virtual functions) has on typeid?
4. RAII. Here is what we covered:
   • Simple RAII class
     • I realized after the meeting that I missed having =delete for the copy ctor so we do not mess up copying the handle and risking in double cleanup of the same handle.
     • Better to = delete your copy/op= so you are on the safe side.
   • Using simple SFINAE
   • Using simple concepts
   • Using static_assert
   • Why different instantiation of the RAII class fails.
     • Function pointers
     • References to functions
     • add_pointer_t
     • decltype(auto), return (x), decltype((x))
     • What did Scott Meyers had to say in his last book (Effective Modern C++: C++11/14)
     • Using https://cppinsights.io/ to decipher templates.
   • Using unique_ptr<> with custom deleter.
   • Using gsl::finally
   • Capture-less lambdas in un-evaluated context.

Patrice Roy’s book:

Thank you for reading!
Kobi

Hello everyone!

Tuesday March 18 2025 evening was all about Refactoring with C++ by Dmitry Danilov.

But before we dive to the summary – we’ll mention that there was a Job posting presented by Parker Lanning – Looking for Mid Sr. C++ Developer Role – contract role. Please feel free to contact Parker.

We also mentioned the following:

• A new C++ exercises website – give it a shot!
• Iterators! 7 Interesting (and Powerful) Uses for C++ Iterators – John Farrier – interesting read!

You can find the recording here:

Link to the meetup page.

I’ll start by saying that I really like Refactoring business, and especially in C++. A clear evidence that there is indeed something wrong with me. (Un?)Fortunately, Refactoring is part of our life. Code evolves, rotten and not maintained correctly. There is some joy in taking such code and making it better, more readable, modern, more maintainable and sometimes even faster!

The book is good. It has a lot of good information in Design choices, reasons for tech debt, how to avoid it, SOLID and more! Grab the book!

So what did we discuss?

• First, checkout the variety of books available on this subject.

• Checkout Refactoring.Guru – great site! also has the Design Patterns aspect.
• We discussed clean code, technical debts, why this is happening, what happens with personal taste? How about the gaps in ones knowledge of the language, the libraries, good practices?
• People who don’t know about the tool, have questions and concerns. How would I know that std::accumulate is actually doing the right thing and not shooting a rocket to the moon (well, as part of the accumulate operation?)
• What is a boring but effective API? How about consistent API, const-correct API?
• What is SOLID? Why it’s so important and not just a buzzword or a Software marketing term. (It’s not just marketing term, it’s super important foundation!). Also think about KISS!
• How about C++ Core Guidelines ? Yes, these are good and important to know!
• We discussesed Strategy Pattern, Dependency Injection, Interface Segregation and of course, I mentioned the C++ Design pattern bible of the modern days: C++ Software Design: Design Principles and Patterns for High-Quality Software, by Klaus Iglberger

• We closed with some low hanging fruits for refactoring Legacy code.

There is no universe where we can cover everything in < 1hr. So please take a look at the book and other useful resources. Do it for yourself, future self and your team.

Oh yes – AI might save us and write better, more idiomatic code for us. I want to believe this would happen soon (well you could argue that it is already happening).

Thanks for reading,

Kobi

San Diego C++ Meetup, February 14th 2025. yes, Valentine day, because we love C++ 🙂

Link to the meetup page here.

Recording uploaded to San Diego C++ Meetup (sdcppmu) YouTube channel:

Hello everyone!

February 2025 was dedicated to a new book from Packpub publication: “Debunking C++ Myths: Dispelling Misconceptions and Embracing Modern C++” by Alex Bolbaoca and Ferenc Deak.

Amazon link here.

During the meeting Alex and Ferenc shared their career stories, how they were introduced to C++, what other languages have influenced their work and answered various questions on the book., and their favorite chapters in the book.

Tune into the the recording to learn more about Alex, Ferenc and bunch of details from the book itself.

Enjoy the recording!

Kobi

Hello all,

I’m late on this report. I’ve been traveling a lot in the past week and did not have a chance to sit down and write this report.

The meeting info on meetup can be found here. Took place on Tuesday, January 14, 2025.

Recording is uploaded as usual to our sdcppmu Youtube channel:

Topics discussed during the meetup:

In this meeting, we’ve discussed the Decorator pattern.

This is heavily inspired by Klaus’ excellent book (which I consider is the bible of Modern C++ Design Patterns). The book can be found on Amazon/O’reilly as printed or soft copy. If you do not own a copy, run, don’t walk to grab one and read!

More things discussed… :

Packtpub publication announced 2 new C++ books which we mentioned (and had coupons to share):

• Debunking C++ Myths | Programming | eBook
• Minimal CMake | Programming | eBook

Next, Rich Yonts, the author of a manning’s title 100 C++ Mistakes and How to Avoid Them, called for volunteers to participate in a study. Please contact Rich for more information (hopefully this is still applicable when you read this).

Quiz time – We looked at cppquiz-352 which demonstrates how typedef is not a … new type!

I went through the previous meetup content to clarify few things related to mapping runtime values to compile time, in order to be used as NTTP like in func<val>(). BTW – it’s really cool and you should probably check it out. Lots of fun!

The main talk was about “C++ Decorator Design Pattern”. This is an important and very useful Pattern. Few highlights:

1. We looked at C++ decorator vs Python function decorator. Not related to each other, comparison was just for fun 🙂
2. Gang Of Four Decorator Pattern – Structural design pattern used to dynamically add behavior to objects.
3. Supports OCP and SRP! this is a huge bonus!
4. We looked at specific use case of adding Decorator.
5. Decorators can be thought of compositions of features/behavior. Think f(g(h(x))).
6. C++17 STL allocators also implement such mechanism!

And of course, we always need to highlight shortcoming of this pattern:

1. Every level in the hierarchy is another level of indirection. Perfs might be impacted but MEASURE!
2. You could make silly mistakes like applying decorator twice.

That’s it for reading!

Kobi

Hello all,

Summary of San Diego C++ Meetup – Meeting session number 69. Took place on December 10 2024.

This is the last session for 2024!

Event link can be found here.

Topics we covered:

• Modern C++ Programming: A tutorial/training session by Federico Busato.
• ADL and the  std::swap idiom: Including a mention of  std::ranges::swap(). The discussion covered ADL, anonymous namespaces, and the global namespace, highlighting the subtleties when mixing them.
• Mapping a runtime value to compile time: More details on this topic are provided below.
• Variadic templates and fold expressions: Exploring techniques to eliminate duplicate code.
• Lightning talk by GC: GC’s slide deck on “Stateless Allocators and Memory Resources” can be found here.

How can I map a runtime value to a compile-time value?

This was the main topic. The idea was as follows: given something like:

How can I take a runtime value n and pass it to the function? func<n> would not work since n is not a compile-time value!

The original problem to solve was the following (values are just for the example, it could be anything): for a range [0…5] map to 128, [6…10] map to 256, [11…max] map to 512.

People attending the session immediately suggested using an array/map/hash-map (aka unordered_map). I did not have any material to demonstrate anything with these elements, but before I show the solution presented in the session, let’s try to solve it first with the unordered_map type (since people claim it has O(1) efficiency).

This obviously cannot work. The compiler will complain: “call to non-‘constexpr’ function ’ … “. CE link.

So, what about trying to embed some constants in the “value” part of the unordered_map?

So the problem is, what do we place instead of the ????

What is the actual type? Even if I use integral_constant, which can be used in constant expression contexts, I don’t have a way to provide the type. std::integral_constant<std::size_t, 128> is different from std::integral_constant<std::size_t, 256>.

The next attempt was using Jason Turner’s idea of a “constexpr map.” For reference, here is Jason’s C++ Weekly:

Here is a link to CE trying to get it working. But again, this only works with compile-time inputs. The requirement was runtime inputs!

Let’s take a look at the actual implementation presented in the session. For this, you need to be familiar with:

• std::lower_bound: Given the values [5, 10, max] and a needle, we need lower_bound to find the correct item among the values. Note that lower_bound is not a must here; we could also use a linear search like find/ find_if.
• std::integral_constant<>: An important ingredient in the overall solution. This is where we can actually pass a constant to the template NTTP!
• std::variant<> + std::visit() + overloaded{} idiom: For more information, check out cppreference and cppstories.com, which has tons of great articles on these.

Here is a CE link to the overall solution. Thanks to GC for suggesting constexpr on the return of lower_bound when working with C++20! My solution needed to compile with C++17.

Here is a simple explanation of what’s going on:

We have an array of variants. The std::variant is of type:

Think of it as mapping some number to std::integral_constant<size_t, some_value>.

Given a needle, find the index in the array of variants. We use:

• lower_bound
• overloaded{} idiom
• std::visit to extract the first value in the pair<>

Once we have the result of lower_bound, given the iterator return value, we can compute the index using std::distance(base, iter).

Invoke a call that takes the index. We use the index with the array: arr[n].

Since arr[n] yield a variant type, we can run std::visit, getting the value and extracting the integral_constant, which is the second type in the pair.

Now, we can pass it to an NTTP by calling func<p.second()>(). The magic happens with integral_constant<>! It can be used as an NTTP!

That’s it for this session. I bet there are some other cool ways to achieve something similar!

Thank you for reading!

Kobi

Hello all!

Here is the summary of the last San Diego C++ Meetup, virtual meeting, took place on Wednesday, Nov 13 2024.

Link to the meetup event page here.

Recording uploaded to the San Diego C++ Meetup channel (sdcppmu)

The agenda:

1. cppquiz fun – C++ Quiz – 297 – std::async, future .wait() vs .get()
2. Recommending YT channel – “C++Next by Alex Dathskovsky”
3. The Art of Writing Efficient Programs – chapter 12 – Design choices for Performance.
4. Tip: transparent comparator/operators.

More details:

First, Alex’s YT channel mentioned above is something you should checkout. It’s fun, short episodes and packed with good information.

We mentioned few Design choices as mentioned in Fedor G. Pikus book: “The Art of Writing Efficient Programs: An advanced programmer’s guide to efficient hardware utilization and compiler optimizations using C++ examples”:

Chapter 12 discuss “Design for Performance”. We mentioned:

1. Choosing APIs for performance. operator[] vs iterator interface, std::deque as an example to have better performance using iterator vs operator[].
2. Using std::set<> in conjunction with std::vector<>, using member vs non-member functions.
3. Lock vs non-lock interfaces, runtime vs Template, policy based classes. Also, using decorators (inheritance in this case).
4. Redundant get-ters/set-ters and when these are actually could be useful.
5. 13:34 – we mentioned std::span<>! 🙂

• Transparent operator – using std::less<> which is like std::less<void>, the benefit of using it, how can it save you from debugging subtle bugs.

This is for this session, thank you for reading!

Kobi

Hello all,

We had a fun evening on Tuesday October 15th, discussing C++ STL, Data structure and various modern techniques. The inspiration coming from a recently published book by John Farrier:

recording:

Event page here.

Hey everyone,

Here’s a quick recap of our discussion:

We kicked things off with cppquiz 167. It’s a tough one but packed with important modern C++ concepts like RValue, LValue, and what happens when you pass an RValue to a function. We also touched on std::move and std::forward. Give it a shot and make sure to read the explanation!

C++ Data Structures and STL:

• We talked about getters and exposing internal data structures from your class. We also introduced alternatives like iterators and discussed how to write them in different ways.

SFINAE and std::void_t:

• We covered how SFINAE tweaks the compiler’s function candidate list, mentioned C++20 concepts, and how std::void_t can help. We also discussed type_traits, if constexpr, static_assert(), declval, and how cppinsights.io can be useful.

Allocator Interface:

• How to use it with STL containers.

std::span<> Example:

• We went through an example of std::span<>.

Gotchas:

• Comparing two strings or comparing pointers? Check out the last 2-3 minutes of the recording for the full details!

Book Recommendation:

• I liked the book, though it was a bit basic for me. However, I think it’s great for newcomers to the language/STL to get familiar with various containers, algorithms, and other parts of the Standard Template Library.

Thanks for reading!

Kobi

Hello everyone,

Last Tuesday (September 17, 2024), we gathered for the 66th meeting of The San Diego C++ Meetup.

The topic was CMake. Yes, CMake can be fun sometimes! 😊

The inspiration for this session came from the relatively new 2nd edition of “Modern CMake for C++” by Rafal Swidzinski.

First off, the book is fantastic! It’s packed with valuable material that can make your life easier if your build system is CMake. Despite considering myself quite knowledgeable about CMake, I learned a lot from it.

This wasn’t my first time giving a talk on CMake. I’ve had several opportunities in the past, ranging from one-hour to multi-hour sessions. It always feels like there’s so much to cover that even 1, 2, or 4 hours isn’t enough to touch on every aspect of CMake. CMake is extensive, and it’s crucial to understand and use it well. Otherwise, your build system can become difficult to improve, extend, and maintain, leading to a lot of frustration.

When discussing CMake (or any topic in a C++ session), my goal is for everyone to learn something new—at least one thing!

The meetup page link: here

And the recording:

BTW – We had an excellent session on July 11, 2023, with Alex Reinking, titled “Modern CMake Best Practices for Library Authors” at the San Diego C++ Meetup. It’s definitely worth watching!

Summary of our discussion:

• Introduction to the book.
• CMake’s popularity (based on 2023 surveys).
• Overview of CMake: its purpose and stages (configuration, generation, and build).
• Simple CMake files and FetchContent.
• Generators: what they are and how to write agnostic command lines that work with any generator.
• CMake Cache file (CMakeCache.txt): using the --force option, cache variables, and debugging/tracing CMake build generation with options like --trace, --log-context, --trace-expand, and --debug-output.
• Cleaning with the --clean-first option.
• Targets: what they are and how to build them.
• Installation: a high-level overview (there’s much more to explore here).
• Running CMake as a script with the -P option.
• Brief mentions of CTest/CPack and other tools in the CMake suite.
• CMakeConfigureLog.yaml (introduced in version 3.26) for advanced debugging of the configure stage.
• Utility modules included with the CMake package, and projects like cmake-awesome and cmake-modules.
• Find modules.
• A slide on important elements of the CMake language (the book has an excellent chapter on this).
• CLion and CMake: debugging CMake with CLion.

Additional topics covered in the book:

• Generator expressions
• Dependency graph and how to print it
• CMake presets
• Program analysis tools
• C++20 modules
• Testing frameworks
• Generating documentation

Many thanks to Packtpub for their support providing me the material to review!

That’s it for this session!

Happy CMake-ing!

Kobi

Hello everyone,

Super late in writing this summary, can’t believe we are 1 week past the session. I’ve been super busy at work and with Family.

What did we have on the Agenda:

1. Guo Ci, our guest speaker, presented 2 techniques that are being used to optimize C++ code. The first is doing binary searches with equal_range (in std::ranges and std) and the second is customizing the three-way comparison operator (<=>). Slides: guoci SDCPPMU presentation

• bio: Guo Ci. Guo is a bioinformatician at the University of Michigan, working in labs doing proteomics and genomics research.

2. Adding Default Constructor using =default; to your class type.

sdcppmu Youtube recording:

Event page from meetup.com

Summary of the discussions:

1. From Guo Ci talk – demonstrated techniques related to spaceship/comparison operator
   • Changing order of the non-static data members, changes the default operator<=>
   • usage of std::tie and restoring the required order
   • Transformation of the data members before comparison, using make_tuple and std::cref
   • While float provides partial_ordering, what if we want strong_order?
   • Caveats related to std::tuple’s <=>
   • Synth-three-way
2. Second item from Guo Ci talk – A more generic equal_range
   • An optimized way to reduce algorithm complexity, running on a sorted array
   • Showed benchmarking comparisons
   • Overview from the slides:

Next part of the meeting talked about “Adding Default Constructor using =default; to your class type”. We compared aggregate changes between 17 and 20. For 20, an aggregate cannot have “user-declared or inherited constructors”. 17 could. So 20 is stricter. Examples in the slides from godbolt.

The last part of the session talked about top level const in function deceleration, why clang-tidy complains and the rational behind it.

Thanks for reading!

Kobi

Hello all!

Summary of the recent San Diego C++ meetup session, took place Tue, July 16 2024 5PM Pacific Time.

Agenda in this meeting:

1. New C++ Book – C++ Brain Teasers! – by Anders Schau Knatten – image above.
2. Discussion on Throwing destructors
3. Yet another hard to find(?) bug

Meetup event page here.

Recording can be found here:

Details:

1. I introduce “C++ Brain Teasers” book by Anders Schau Knatten. The PragProg page has 3 items that can be accessed. Puzzles 2,3,14. We went over each and discussed it. Super fun book, very recommended! Amazon link if you’d like also the colored printed book.
2. Throwing destructors Discussion – noexcept and C++11, is it a good idea to throw from destructors? what happens when you aggregate a type with “noexcept(false)” ? How to workaround such issue? What do Core Guidelines say? It triggered lots of good discussions.
3. And finally, a very hard to find(?) bug related to temporaries and lifetime. I saw it in production code few times in the past few months and wanted to share it with the group. Lots of good discussions here as well!

That’s it for July 2024. Working on the agenda for the next meeting!

Thank you for reading!

Kobi

This month we hosted Rich Yonts, the author of a Manning publication title (MEAP/Beta) – 100 C++ Mistakes and How to Avoid Them

The recording can be found in our San Diego C++ Meetup channel:

The meetup even link can be found here.

About Rich Yonts:

Rich Yonts is a Senior Software Engineer at Teradata and a long-time software engineer using C++, Java, and Python. Rich held a number of technical and leadership roles during his many years at IBM and Sony. As an assistant professor, he has dealt with questions and issues of undergraduate and graduate students learning programming. He has deep experience on large code bases and considers himself both a student and a teacher of C++.

Rich cherry-picked few examples from the book and presented to the group.

Here is the summary of the topics:

1. The challenges when dealing with old codebase in various companies. i.e. dealing with 98/03 and not beyond that.
2. Narrowing values, uniform initialization to detect narrowing.
3. Referring to an uninitialized data member and UB.
4. Post vs pre increment of type instances.
5. The fit fall of using setter when class invariant is not checked/violated and how to solve it.
6. Shallow vs deep copy and how to ensure a deep copy with copy constructor and op=.
7. The benefit of using the “override” keyword.
8. Using “=delete” keyword to disable a specific function, vs the old 98/03 “method”.
9. Variadic Templates.
10. Using sprintf vs iostream vs std::format.

That’s it for June 2024 session.

Thank you for reading!

Kobi

Introducing: “Modern C++ Programming Cookbook” – Master modern C++ including the latest features of C++23 with 140+ practical recipes, Third Edition – By Marius Bancila

Meetup session page: san-diego-cpp

Recording (sdcppmu Youtube Channel):

I continued using “google meet” where I can share the slides directly from my google drive, record a session, chat with attendances and it works beautifully!

Recent session introduced Marius’ newly published book which is really a good one (as usual :)!

The session started with a warm up, c++quiz Question #287. A bit of a tricky one. If you cannot remember the exact constructor diffs of std::string, you are out of luck 🙁

The main session/talk was on “Implementing the higher-order functions map and fold“. Taken from chapter 3 from the book (just part of the chapter). Oh – and we had a raffle of 3 ebooks!

Minutes:

1. Map, fold implementation.
2. Various overloads to support different containers that might behave a bit differently in the way we iterate over the items (std::queue<> is one example).
3. The difference between the presented fold() and “C++17 fold expressions”.
4. Composing(composing(composing(functions))) – with many examples.
5. Fold left/right functions.
6. Functions as first class citizens. Returning functions and composing a chain of functions.
7. Overload operator* as a syntactic sugar when composing.

That’s it for this session. Next session should be a really nice one. Working on bringing a new speaker with an interesting topic!

Take care,

Kobi

Hello all,

Short summary on the previous San Diego C++ meetup, the last one for 2023.

It took place on December 12th 2023.

The topic for the meetup was Class Template Policy based design. All based on the first chapter of Andrei’s Modern C++ Design book from 2001.

Here is a link to the meetup event.

Recording on our sdcppmu channel here:

The talk goes over the first chapter of Andrei’s book highlighting the huge advantage of using this technique in your code. And in particular, it described the following items:

1. Templates, specialization of Class Templates, functions, what is template-template parameters.
2. Examples of how Policy design can improve readability, flexibility of your design.
3. Static vs Dynamic dispatch/polymorphism.
4. How to mix different, orthogonal policies
5. How to mix policies with some dependencies (though this is not a recommended approach).
6. Enrichment APIs and how Templates do not instantiate functions unless being used.
7. Customizing structure with Policy Classes.
8. Examples of Policy classes in the wild. ACE library, Standard library.

Next month will discuss chapter 2 that describes more of the important Template techniques.

That’s if for now.

Have a great holidays, hoping for a better 2024!

Kobi

Hello all,

This post is about the latest San Diego C++ Meetup session, held on Tuesday, November 14 2023. It was a virtual meeting, recorded and uploaded to the sdcppmu Youtube channel. Here is the recording:

Here is a link to the event on meetup.com

This time, we hosted Šimon Tóth who gave a wonderful talk named “Patterns of interview solutions”.

A bit on Šimon:

He can be found on the following Social media: linkedin, hachyderm.io, substack, medium and github.com .

Books on leanpub.com:

• A Complete Guide to Standard C++ Algorithms (content complete C++20) cpp-algorithms-guide
• Surviving the C++ Coding Interview (in progress) cpp-coding-interview
  

Summary of the content presented

The talk is divided to 2 parts. First part presented the available algorithms in C++. Including some from the ranges library. Total of 126 algorithms were bunched into categories and Šimon quickly went over the benefits of each category with some examples.

The second part presented couple interview-like questions and their respective Modern C++ solutions:

1. Sum of distances to all nodes – Šimon demonstrated solving a problem while looking at it from different persoective.
2. Longest palindromic substring – showing few ways to improve your algorithms using different methods.

In all of the above, Šimon is using ranges, algorithms and Modern C++ syntax and mechanism.

Hope you enjoy the recording!

Take care,

Kobi

Hello everyone!

As usual, I’m providing a short summary to the previously held San Diego C++ Meetup session.

But before this, I’d like to promote the next, upcoming one – we are hosting Šimon Tóth that will present his talk – “Patterns of interview solutions“. This will happen on Tuesday, November 14th, 930am Pacific time. Looking forward!

The recording of the October meetup, named “Let’s embed it with C++” can be found here:

Here, you can find the past event Link on the meetup.com page.

The original meetup session was scheduled to October 10th but I had an emergency travel to Israel supporting my family as I lost my nephew during the first few hours of October 7th war.

So what did we discussed about during this 1:30 hrs of this session?

The idea was to provide an overview, mostly for beginners to intermediate levels on how can we use Modern C++ features in Embedded environment. The talk was heavily inspired by this excellent book By Christopher Kormanyos:

I also started by mentioning 2 great talks. One from Dan Saks, cppcon2016 – extern c: Talking to C programmers about C++, and the second one from cppcon2022 – Erik Rainey, “Using C++14 in an Embedded ‘SuperLoop’ Firmware”.

High level topics discussed:

• Using class types for encapsulations, organization of code, as well as namespaces
• (No)Overhead demonstrated using various features like class types, constexpr, using templates to improve code generation.
• Showing various code/options side by side using Compiler Explorer and the new CLion feature to “Show assembly” (what a great feature JetBrains!).
• Discussing the subset of C++ that is useful for embedded. The various trade-offs using STL(Standard Template Library).
• Using integral macros from “cstdint”. Thinking about portability of your code working with various OS and compiler vendors.
• static_asserts, limits for more compile time evaluation.
• Using std::array as a replacement to the C array.
• Why STL algorithms are a good fit for your programs? How do they compare to raw loops, runtime speed and generated code.
• The advantage of using User Defined string literals (one of my favorite features of the language!). How does it contribute to strongly typed elements with zero cost abstraction!
• C++ Core guidelines, using std::span<> (and gsl:: library if you are working on <20 standard).
• Demonstrating template integer sequences with Modern C++.

Conclusion is that C++ is more than suitable for embedded. You need to know how to use the language correctly, take advantage of templates when applicable, know STL well to avoid pitfalls!

That’s it for now. Hope this session is useful for various people at least as a good introductory session to various Modern C++ features.

Until next time, stay safe,

Kobi