Educational C++ Videos Educational C++ Videos Videos

• Regular Types and why do I care?  (Victor Ciura, 2018)
• How I learned to Stop Worrying and Love the C++ Type System  (Peter Sommerlad, 2019)
• What Is Variable Shadowing? (C++ Weekly)
• Cost of Using Statics (C++ Weekly)

• What is Negative Zero? (C++ Weekly)
• char8_t  (CopperSpice C++)
• Your small integer operations are broken!

• Back to Basics: Designing Classes [1/2]  (Klaus Iglberger, 2021)
• Back to Basics: Designing Classes [2/2]  (Klaus Iglberger, 2021)
• Back To Basics: The Special Member Functions  (Klaus Iglberger, 2021)
• Back to Basics: Move Semantics  (Nicolai Josuttis, 2021)
• Negative Cost Structs (C++ Weekly)
• Transparent Comparators (C++ Weekly)
• Copy Elision  (CopperSpice C++)
• Copy Elision  (Jon Kalb)
• C++17: Aggregate Initializations (C++ Weekly)
• C++20: Aggregates With User Defined Constructors (C++ Weekly)
• Class Type Design…

• Back to Basics: Const as a Promise  (Saks Dan, 2019)
• Back to Basics: const and constexpr  (Rainer Grimm, 2021)
• What Are 'const' Member Functions? (C++ Weekly)
• Top 4 Places To Never Use 'const' (C++ Weekly)
• constexpr & conteval

• What is Initialization  (CopperSpice C++)
• The Nightmare of Initialization in C++  (Nicolai Josuttis)
• Initializer Lists Are Broken, Let's Fix Them  (Jason Turner, 2018)
• Designated Initializers: Remembering Every Struct Member in Declaration Order Is Hard  (Brian Ruth)
• Initialization in modern C++  (Timur Doumler, 2018)
• The Static Initialization Order Fiasco  (Jonathan Müller, 2020)
• Start Using Default Member Initializers (C++ Weekly)
• C++17: Aggregate Initializations (C++ Weekly)
• C++20: Designated Initializers (C++ Weekly)
• C++20: Designated Initializers And Lambdas (C++ Weekly)
• C++20: Default Bit-field Member Initializers (C++ Weekly)
• C++20: constinit (C++ Weekly)

• Back to Basics: Pointers  (Mike Shah, 2021)
• Rethinking Pointers  (Jonathan Müller, 2018)
• Fancy Pointers for Fun and Profit  (Bob Steagall, 2018)
• References To Pointers (C++ Weekly)
• Lambda To Function Pointer Conversion (C++ Weekly)
• C++20: std::to_pointer (C++ Weekly)
• std::launder  (Réka Kovács, 2017)
• Strict Aliasing In The Real World (C++ Weekly)

Smart Pointers

• Back to Basics: Smart Pointers and RAII  (Inbal Levi, 2021)
• Covarient Return Types And Covariant Smart Pointers (C++ Weekly)
• The Smart Pointers I Wish I Had  (Fleming Matthew, 2019)
• An Alternate Smart Pointer Hierarchy  (Matthew Fleming, 2019)

• Back to Basics: Casting  (Brian Ruth, 2021)
• Declarations and Type Conversions  (CopperSpice C++)
• C++20: std::bit_cast (C++ Weekly)
• Stop Using reinterpret_cast! (C++ Weekly)
• Stop Using const_cast! (C++ Weekly)

• Short Circuiting With Logical Operators (C++ Weekly)
• Safely Using 'goto' In C++
• Branchless Programming in C++  (Fedor Pikus, 2021)

Coroutines

• From Functions to Coroutines  (Rainer Grimm, 2020)
• Converting a State Machine to a C++ 20 Coroutine  (Steve Downey, 2021)
• Coroutine TS a new way of thinking  (Andreas Reischuck, 2018)
• C++ Coroutines - a negative overhead abstraction  (Gor Nishanov, 2015)
• Using C++20 coroutines for asynchronous parsers  (Andreas Reischuck)
• Using Coroutines to Implement C++ Exceptions for Freestanding Environments  (Eyal Zedaka, 2021)
• Automatically Process Your Operations in Bulk With Coroutines  (Francesco Zoffoli, 2021)
• From Problem to Coroutine: Reducing I/O Latency  (Cheinan Marks, 2021)

• What Are Callables? (C++ Weekly)
• Pure Functions in C++ (C++ Weekly)

Overloading

• Overload Resolution  (CopperSpice C++)
• Back To Basics: Overload Resolution  (Ansel Sermersheim & Barbara Geller, 2021)
• Overloading In C and C++ (C++ Weekly)
• Understanding Operator Overloading (C++ Weekly)
• All The Assignment Operators (C++ Weekly)
• The Arrow Operator Is Magic (C++ Weekly)
• Operator Overloading: History, Principles and Practice  (Ben Deane, 2018)
• Techniques for Overloading  (any_invocable)  (Filipp Gelman, 2021)
• Never Overload Operator & or || (C++ Weekly)

Higher Order Functions

• What Are Higher Order Functions? (C++ Weekly)
• Higher-order functions and 'function_ref'  (Vittorio Romeo, 2019)
• Higher Order Functions for ordinary developers  (Björn Fahller, 2018)

ADL (Argument-Dependent Lookup)

• Argument Dependent Lookup (ADL) (C++ Weekly)
• ADL: introduction in name taxonomy, customization points and use cases  (Kyrimis Kostas, 2019)

• Back to Basics: Lambdas  (Nicolai Josuttis, 2021)
• What Exactly IS A Lambda Anyhow? (C++ Weekly)
• Lambdas: The Key To Understanding C++ (C++ Weekly)
• Lambdas in C++  (CopperSpice C++)
• Lambdas in Action  (CopperSpice C++)

• Lambdas For Free (C++ Weekly)
• Stateful Lambdas (C++ Weekly)
• Inheriting From Lambdas (C++ Weekly)
• Why Inherit From Lambdas? (C++ Weekly)
• Inheriting Lambdas vs. Generic Lambdas (C++ Weekly)
• Advanced Stateful Lambdas (C++ Weekly)
• Storage Duration with Lambdas (C++ Weekly)
• Overusing Lambdas (C++ Weekly)
• Lambdas as Comparators (C++ Weekly)
• Transparent Lambda Comparators (C++ Weekly)
• Lambda To Function Pointer Conversion (C++ Weekly)
• Lambdas With Destructors (C++ Weekly)
• Lambdas In Fold Expressions (C++ Weekly)
• Recursive Lambdas (C++ Weekly)
• std::bind_front Implemented With Lambdas (C++ Weekly)
• const mutable Lambdas? (C++ Weekly)
• The Three Little Dots and the Big Bad Lambdas  (Joel Falcou, 2017)
• Lambdas - uses and abuses  (Dawid Zalewski, 2020)
• C++ IIFE in quick-bench.com (C++ Weekly)
• C++ Insights: How Stuff Works, Lambdas and More!  (Andreas Fertig, 2021)

• C++17: constexpr Lambda Support (C++ Weekly)
• C++20: Lambda Usability Changes (C++ Weekly)
• C++20: Lambdas For Resource Management (C++ Weekly)
• C++20: Lambdas As Custom Comparators (C++ Weekly)
• C++20: Template Syntax For Lambdas (C++ Weekly)
• C++20: Designated Initializers And Lambdas (C++ Weekly)

by Jason Turner (C++ Weekly)

• Chapter 1/5 - Understanding Lambdas (C++ Weekly)
• Chapter 2/5 - Building On Lambdas (C++ Weekly)
• Chapter 3/5 - Utilizing Lambdas (C++ Weekly)
• Chapter 4/5 - The Evolution of Lambdas (C++ Weekly)
• Chapter 5/5 - Lambdas To The Limits (C++ Weekly)
• Chapter 5/5 - Answers (C++ Weekly)

• Learning "Modern" C++ [4/5]: const and constexpr (C++ Weekly)
• constexpr: Introduction  (Scott Schurr, 2015)
• constexpr: Applications  (Scott Schurr, 2015)
• Your New Mental Model of constexpr  (Jason Turner, 2021)
• Practical constexpr  (Jason Turner, 2017)
• constexpr vs. static constexpr (C++ Weekly)
• Constexpr Static Const  (CopperSpice C++)
• Bringing Existing Code to CUDA Using constexpr and std::pmr  (Bowie Owens, 2021)
• Constexpr Everything - The Standard Library, Microkernel, Apps, and Unit Tests  (Rian Quinn, 2021)
• Don't constexpr All the Things  (David Sankel, 2021)

• constexpr With optional And variant (C++ Weekly)
• Semi-Automatic constexpr and noexcept (C++ Weekly)
• std::map vs. constexpr map (huge perf difference!) (C++ Weekly)
• constexpr Compile Time Random (C++ Weekly)

• C++17: constexpr if (C++ Weekly)
• C++17: Using constexpr if (C++ Weekly)
• C++17: constexpr Lambda Support (C++ Weekly)

• C++20: constexpr virtual Members (C++ Weekly)
• C++20: constexpr Algorithms (C++ Weekly)
• C++20: constexpr new Support (C++ Weekly)
• C++20: Design By Introspection (concepts + if constexpr) (C++ Weekly)
• C++20's constexpr std::vector and std::string (C++ Weekly)
• C++20: Constraining 'auto' (C++ Weekly)
• C++20: Design By Introspection (concepts + if constexpr) (C++ Weekly)

• C++23: if consteval [1/2] (C++ Weekly)
• C++23: if consteval [2/2] - There's More To This Story (C++ Weekly)
• C++23: Deducing 'this' (C++ Weekly)
• C++23: Multidimensional Subscript Operator Support (C++ Weekly)

• Compile Time Maze Generator (and Solver) (C++ Weekly)
• Compile Time ARM Emulator (C++ Weekly)

• The Preprocessor: Everything You Need to Know and More!  (Brian Ruth, 2021)

• Back to Basics: Compiling and Linking  (Ben Saks, 2021)
• The Structure of a Program  (Bob Steagall, 2020)
• Linkage  (CopperSpice C++)
• C++ Name Demangling (C++ Weekly)
• How inline Might Affect The Optimizer (C++ Weekly)

• How LTO easily makes your program faster
• ThinLTO: Whole Program Optimization  (Teresa Johnson, 2020)
• ThinLTO: Scalable and Incremental Link-Time Optimization  (Theresa Johnson, 2017)

Build Systems

CMake

• Functional C++  (Kevlin Henney)
• Functional Programming: data  (Ivan Cukic, 2017)
• Functional: What's New, And Proper Usage  (Stephan T. Lavavej, 2015)
• Using Functional Programming Patterns…  (Jeremy Demeule & Quentin Duval, 2017)
• Pure Functions in C++ (C++ Weekly)

Higher Order Functions

• What Are Higher Order Functions? (C++ Weekly)
• Higher-order functions and 'function_ref'  (Vittorio Romeo, 2019)
• Higher Order Functions for ordinary developers  (Björn Fahller, 2018)

Standard Library Facilities

• Using std::bind (C++ Weekly)
• Avoiding std::bind (C++ Weekly)
• Fixing Our bind_front with std::invoke (C++ Weekly)
• std::mem_fun vs. std::mem_fn Fight! (C++ Weekly)
• Is std::function really the best we can do?  (Lukas Bergdoll, 2017)

• Inheritance  (CopperSpice C++)
• Intro to the C++ Object Model  (Richard Powell, 2015)
• Back to Basics: Virtual Dispatch and its Alternatives  (Levi Inbal, 2019)
• Virtual Inheritance: Probably Not What You Think It Is (C++ Weekly)
• Covarient Return Types And Covariant Smart Pointers (C++ Weekly)
• Multiple Inheritance problem in C++  (Bo Qian)
• C++ Tapas (typename, virtual, pure virtual)  (CopperSpice C++)
• Back to Basics: Object-Oriented Programming  (Rainer Grimm, 2021)

• OO Considered Harmful  (Phil Nash, 2020)
• Value-oriented Design in an Object-oriented System  (Juan Pedro Bolivar Puente, 2021)

• Polymorphism À La Carte  (E. Madrid & P. Nash, 2021)
• Better Code: Runtime Polymorphism  (Sean Parent)
• Runtime Polymorphism: Back to the Basics  (Louis Dionne, 2018)
• Polymorphic Task  (Sean Parent, 2017)
• Jonathan Boccara  (Meta Polymorphism, 2020)

• Design Patterns and Modern C++  (JetBrains)
• Singleton Design Pattern  (Code Blacksmith)
• Strategy Design Pattern  (Code Blacksmith)
• Builder Design Pattern  (Code Blacksmith)
• Design Patterns - Facts and Misconceptions  (Klaus Iglberger)
• Statistical scientific programming OO patterns: accumulators  (Olivia Quinet, 2017)
• Design Patterns - Facts and Misconceptions  (Klaus Iglberger)
• The Factory Pattern  (Mike Shah, 2021)

• Modern C++ Threads  (CopperSpice C++)
• Multithreading in C++  (CopperSpice C++)
• C++ Memory Model  (CopperSpice C++)
• Memory Model to Mutexes  (CopperSpice C++)
• Atomics  (CopperSpice C++)
• The Foundation of C++ Atomics: The Knowledge You Need to Correctly Use C++ Atomics  (Filipe Mulonde, 2021)
• Futures & Promises  (CopperSpice C++)

• C++ Standard Parallelism  (Bryce Adelstein Lelbach, 2021)
• C++17 Parallel Algorithms  (Dietmar Kühl, 2017)
• N Times Faster Code With Parallel Algorithms (C++ Weekly)

• std::future [1/2] Quick-Start (C++ Weekly)
• std::future [2/2] (C++ Weekly)
• C++20: jthread and stop_token (C++ Weekly)

• Back to Basics: Concurrency  (Arthur O'Dwyer, 2020)
• Back to Basics: Concurrency  (Mike Shah, 2021)
• Multithreading 101: Concurrency Primitives From Scratch  ( Arvid Gerstmann, 2019)

• Thread Safety  (CopperSpice C++)
• What do you mean "thread-safe"?  (Geoffrey Romer, 2018)
• Multithreading is the answer. What is the question? [1/2]  (Ansel Sermersheim, 2017)
• Multithreading is the answer. What is the question? [2/2]  (Ansel Sermersheim, 2017)
• Multithreading using libGuarded  (CopperSpice C++)
• Mutex + Lock = CsLibGuarded  (CopperSpice C++)
• Lock-Free Programming (or, Juggling Razor Blades)  (Herb Sutter, 2014)
• Reader-Writer Lock versus Mutex  (Jeffrey Mendelsohn, 2017)
• The Continuing Saga of the Lock-free Queue [3/N]  (Tony Van Eerd, 2018)
• A Multithreaded,Transaction-Based Locking Strategy for Containers  (Bob Steagall, 2019)
• Designing Concurrent C++ Applications  (Lucian Radu Teodorescu, 2021)
• From Algorithm to Generic, Parallel Code  (Kuhl Dietmar, 2019)
• Best Practices for Concurrency  (Rainer Grimm, 2018)
• Concurrency Patterns  (Rainer Grimm, 2021)

• Plain Threads are the GOTO of todays computing  (Hartmut Kaiser, 2014)
• Threads and Locks must Go  (Rainer Grimm, 2016)
• True parallelism, with no concept of threads  (Alfred Bratterud, 2017)

• Asynchronous C++ Programming  (Pavel Novikov, 2019)
• Continuable asynchronous programming with allocation aware futures  (Denis Blank, 2018)
• Design And Implementation Of DBMS Asynchronous Client Library  (Roman Siromakha, 2018)

• Adventures in SIMD-Thinking  (Bob Steagall, 2021)
• SIMD in C++20: EVE of a new Era  (Joel Falcou & Denis Yaroshevskiy, 2021)
• Fast Conversion From UTF-8 with C++, DFAs, and SSE Intrinsics  (Bob Steagall, 2018)

• The CUDA C++ Standard Library  (Bryce Lelbach)
• Parallel STL for CPU and GPU -- The Future of Heterogeneous/Distributed C++  (Michael Wong and Gordon Brown, 2017)
• cudaFlow: Modern C++ Programming Model for GPU Task Graph Parallelism  (D.-L.Lin, T.-W.Huang 2021)
• A Modern C++ Programming Model for GPUs using Khronos SYCL  (Gordon Brown, 2018)
• GPU Accelerated Computing on Cross-Vendor Graphics Cards with Vulkan Kompute  (Alejandro Saucedo, 2021)
• Debugging Assembly Language and GPU Kernels in Visual Studio Code  (Julia Reid, 2021)
• Using Template Magic to Automatically Generate Hybrid CPU/GPU-Code  (Elmar Westphal, 2018)

• C++20 on Xilinx FPGA with SYCL for Vitis  (Ronan Keryell, 2021)

• Back to Basics: Templates [1/2]  (Bob Steagall, 2021)
• Back to Basics: Templates [2/2]  (Bob Steagall, 2021)

• Variable Templates  (CopperSpice C++)
• C++14: Variable Templates (C++ Weekly)
• C++17: Class Template Argument Type Deduction (CTAD) (C++ Weekly)
• C++17: Surprising Conversions with CTAD (C++ Weekly)
• C++20: Template Syntax For Lambdas (C++ Weekly)
• C++20: Templates - The next level: Concepts and more  (Andreas Fertig, 2021)

• Using Template Magic to Automatically Generate Hybrid CPU/GPU-Code  (Elmar Westphal, 2018)
• C++ Templates Revised  (Nicolai Josuttis, 2017)
• Templates in The Real World  (CopperSpice C++)
• Reducing Template Compilation Overhead, Using C++11, 14, 17, and 20.  (Brown Jorg, 2019)
• Optimizing Generic Algorithms  (Denis Yaroshevskiy, 2019)
• Paradigms, Polymorphism, and Generic Programming  (CopperSpice C++)
• A generic binary tree: why grow your own?  (Jeremy Murphy, 2019)
• Inheriting Lambdas vs. Generic Lambdas (C++ Weekly)

• Intro To Variadic Templates (C++ Weekly)
• Variadic Template Refactor (C++ Weekly)
• Variadic fmin for C++11 (C++ Weekly)
• C++17: Variadic using (C++ Weekly)
• Variadic Expansion Wrap-Up (C++ Weekly)
• Variadic Templates in C++11 / C++14 - An Introduction  (Peter Sommerlad, 2015)

• Understanding 'auto' (C++ Weekly)
• Quick Perf. Tip: Prefer 'auto' (C++ Weekly)
• Constraining 'auto' in C++20 (C++ Weekly)

• Type Deduction and Why You Care  (Scott Meyers, 2014)
• Class Template Argument Deduction for Everyone  (Stephan T. Lavavej, 2018)
• Type Punning in C++17: Avoiding Pun-defined Behavior  (Scott Shurr, 2017)

• Type Traits  (CopperSpice C++)
• Type Traits - what are they and why should I use them?  (Marshall Clow, 2015)
• Type Punning in C++17: Avoiding Pun-defined Behavior  (Scott Shurr, 2017)
• Concepts vs Typeclasses vs Traits vs Protocols  (Conor Hoekstra, 2020)
• The Best Type Traits that C++ Doesn't Have  (Arthur O'Dwyer, 2018)
• Template Metaprogramming: Type Traits [1/2]  (Jody Hagins, 2020)
• Template Metaprogramming: Type Traits [2/2]  (Jody Hagins, 2020)

• Concepts in C++20  (CopperSpice C++)
• C++20: What is requires requires? (C++ Weekly)
• The Concepts of concepts  (Sandor Dargo, 2021)
• Using Concepts: C++ Design in a Concept World [1/2]  (Jeff Garland, 2021)
• Using Concepts: C++ Design in a Concept World [2/2]  (Jeff Garland, 2021)
• Concepts - Evolution or Revolution  (Rainer Grimm, 2019)
• So You Think You Know How to Work With Concepts?  (Andrzej Krzemieński, 2021)
• Concepts driven design  (Kris Jusiak, 2017)
• Concepts vs Typeclasses vs Traits vs Protocols  (Conor Hoekstra, 2020)
• Concepts: The Future of Generic Programming (the future is here)  (Bjarne Stroustrup, 2018)
• Concepts in 60: Everything you need to know and nothing you don't  (Andrew Sutton, 2018)
• Make Classes Great Again! (Using Concepts for Customization Points)  (Vinnie Falco, 2017)

Template Metaprogramming (TMP)

• Learning "Modern" C++ [4/5]: const and constexpr (C++ Weekly)
• constexpr: Introduction  (Scott Schurr, 2015)
• constexpr: Applications  (Scott Schurr, 2015)
• Practical constexpr  (Jason Turner, 2017)
• Constexpr Static Const  (CopperSpice C++)
• Don't constexpr All the Things  (David Sankel, 2021)

• More Resources…

• Introduction to C++ Template Metaprogramming  (Sasha Goldshtein, 2016)
• An inspiring introduction into Template Meta Programming  (Milosz Warzecha, 2017)
• Template Metaprogramming: Practical Application  (Jody Hagins, 2021)
• Modern Template Techniques  (Jon Kalb, 2019)
• Template Metaprogramming: Type Traits [1/2]  (Jody Hagins, 2020)
• Template Metaprogramming: Type Traits [2/2]  (Jody Hagins, 2020)
• Custom Overload Sets and Inline SFINAE for Truly Generic Interfaces  (Vincent Reverdy, 2018)
• Boost.TMP: Your DSL for Metaprogramming  (Odin Holmes, 2018)
• Template Shenanigans  (Jonathan O'Connor , 2020)
• Taking Template Classes Further with Opaque Types & Generic NTTPs  (Joel Falcou & Vincent Reverdy)
• Semantic Sugar: Tips for Effective Template Library APIs  (Roi Barkan, 2021)
• Reducing Template Compilation Overhead, Using C++11, 14, 17, and 20.  (Brown Jorg, 2019)
• Practical TMP: A C++17 Compile Time Register Machine  (Daniel Nikpayuk, 2021)
• A new look at TMP  (Ivan Cukic, 2018)
• Alices adventures in Template Land  (Jonathan O'Connor, 2018)

• Compile Time Maze Generator (and Solver) (C++ Weekly)
• Compile Time ARM Emulator (C++ Weekly)

Generic Programming

• Speed Is Found In The Minds of People  (Alexandrescu Andrei, 2019)
• This Videogame Programmer Used the STL and You Will Never Guess What Happened Next  (Ropert Mathieu, 2019)
• Path Tracing Three Ways: A Study of C++ Style  (Godbolt Matt, 2019)
• Algorithm Intuition  (Conor Hoekstra, 2019)
• Algorithms and Iterators for Multidimensional Arrays  (Cem Bassoy, 2017)
• Efficiency with Algorithms, Performance with Data Structures  (Chandler Carruth, 2014)
• Fantastic Algorithms and Where To Find Them  (Nicholas Ormrod, 2017)
• Algorithms from a Compiler Developer's Toolbox  (Gábor Horváth, 2021)

C++ Standard Algorithms…

• Creating Allocator-Aware Types (C++ Weekly)
• std::allocator Is to Allocation what std::vector Is to Vexation  (Andrei Alexandrescu, 2015)
• Custom Allocator Tutorial  (Code Blacksmith)
• How to Write a Custom Allocator  (Bob Steagall, 2017)
• Frictionless Allocators  (Alisdair Meredith, 2021)
• Efficient Object Pool  (Code Blacksmith)
• Local ('Arena') Memory Allocators [1/2]  (John Lakos, 2017)
• Local ('Arena') Memory Allocators [2/2]  (John Lakos, 2017)
• Value Proposition: Allocator-Aware (AA) Software  (John Lakos, 2019)
• std::allocator  (Andrei Alexandrescu, 2015)
• An Allocator is a Handle to a Heap  (Arthur O'Dwyer, 2018)

Polymorphic Allocatorsstd::pmr

• PMR: 3.5x Faster Standard Containers! (C++ Weekly)
• PMR: Amazing, Fast, But, Not Quite Magic (C++ Weekly)
• std::pmr Comes With a Cost  (David Sankel, 2018)
• test_resource: the pmr detective  (Attila Fehér, 2019)

• Modern C++ in Embedded Systems  (Michael Caisse, 2018)
• Embedded & C++  (Wouter van Ooijen, 2017)
• C++ to the RISCue! A Practical Guide for Embedded C++20  (Kris Jusiak, 2021)
• De-fragmenting C++: Making Exceptions and RTTI More Affordable and Usable  (Herb Sutter, 2019)
• Embedded Domain Specific Languages for Embedded Bare Metal Projects  (Michael Caisse, 2019)
• Support for Embedded Programming in C++11 and C++14  (Scott Meyers, 2014)
• Code Size Compiler Optimizations and Techniques for Embedded Systems  (Aditya Kumar, 2021)
• Using C Libraries in your Modern C++ Embedded Project  (Michael Caisse, 2021)

Series by Jason Turner (C++ Weekly)

• Zero Cost Embedded C++ [1/3]
• Zero Cost Embedded C++ [2/3]
• Zero Cost Embedded C++ [3/3]

• Negative Cost Embedded [1/2]
• Negative Cost Embedded [2/2]

• -O3, -Os, -Og, -Oz, Oh My! (C++ Weekly)
• GCC's Leaky Abstractions (C++ Weekly)
• GNU Function Attributes (C++ Weekly)
• C++ To C Compilation (C++ Weekly)
• Start Using Visual C++ (C++ Weekly)
• Clang's Heap Elision (C++ Weekly)
• LLVM: A Modern, Open C++ Toolchain  (Chandler Carruth, 2017)
• What Else Has My Compiler Done For Me Lately?  (Matt Godbolt, 2018)
• What Has My Compiler Done for Me Lately? Unbolting the Compiler's Lid  (Matt Godbolt, 2017)
• Teaching old compilers new tricks  (Tony Wasserka, 2018)
• A quick view into a compiler  (Arvid Gerstmann, 2017)

Compiler Explorer

• Installing Compiler Explorer (C++ Weekly)
• Execution Support in Compiler Explorer (C++ Weekly)
• clang-tidy Auto Fixes in Compiler Explorer (C++ Weekly)

• Build Systems  (CopperSpice C++)
• Build Systems: A Simple Solution to A Complicated Problem  ()
• Behind the Scenes of a C++ Build System  (Pakkanen Jussi, 2019)

• Docker Based C++ Dependency and Build Management  (Jason Rice, 2018)
• Fastbuild  (Arvid Gerstmann, 2017) - Lightningtalks Meeting C++ 2017
• Git, CMake, Conan: How to Ship and Reuse our C++ Projects  (Mateusz Pusz, 2018)

CMake

Visual Studio Code

• C++ Development with Visual Studio Code  (Tara Raj, 2019)
• C++ Development with Visual Studio Code  (Rong Lu, 2017)
• What's new in Visual Studio Code for C++ development  (Rong Lu, 2018)
• Latest and Greatest in Visual Studio for C++ developers  (Steve Carroll and Daniel Moth, 2017)

Others

• VIM Introduction
• Emacs as a C++ IDE  (Atila Neves, 2015)
• Cevelop IDE With CMake Based Projects (C++ Weekly)

Continuous IntegrationCI

• Intro To Travis CI (C++ Weekly)
• Intro to AppVeyor (C++ Weekly)

Licensing

• Copyright Copyleft  (CopperSpice C++)

Documentation

• How to Write Effective Documentation for C++ Libraries…  (Robert Ramey, 2017)
• Using DoxyPress  (CopperSpice C++)

• What do you do when your Codebase is Old Enough to Vote?  (CopperSpice C++)

Testing

Package Management

Code Formatting

Sanitizers

• Build Systems  (CopperSpice C++)
• Build Systems: A Simple Solution to A Complicated Problem  ()
• Behind the Scenes of a C++ Build System  (Pakkanen Jussi, 2019)

• Docker Based C++ Dependency and Build Management  (Jason Rice, 2018)
• Fastbuild  (Arvid Gerstmann, 2017) - Lightningtalks Meeting C++ 2017
• Git, CMake, Conan: How to Ship and Reuse our C++ Projects  (Mateusz Pusz, 2018)

CMake