Overview

Modern C++ development requires navigating decades of opinions and misconceptions. This course helps you build a clear understanding of what modern C++ truly offers and why these skills matter in professional software engineering. You will learn how to separate outdated assumptions from real language behavior, improve code quality, and apply modern standards effectively. Through practical insights, you’ll enhance your problem-solving and write safer, more efficient C++ programs. The course stands out by combining deep theoretical clarity with hands-on examples, showing how features like smart pointers, lambdas, and concurrency apply to real projects. It is ideal for developers with basic C++ experience who want to strengthen their modern C++ skills and advance into more confident, high-level engineering work.

Syllabus

C++ Is Very Difficult to Learn

In this section, we analyze C++'s historical complexity, explore modern C++ features that enhance safety and clarity, and apply test-driven development (TDD) to build reliable systems code with structured learning techniques.

Every C++ Program Is Standard-Compliant

In this section, we examine C++ standard compliance across compilers and frameworks, identifying non-standard extensions and practical deviations that impact code portability and maintainability in real-world development environments.

There's a Single C++ and It Is Object-Oriented

In this section, we explore C++ as a multi-paradigm language, applying functional programming with std::function, analyzing metaprogramming via templates and constexpr, and designing strong types using constraints and type aliases for safer, more maintainable code.

Main() Function Is the Entry Point to Your Application

In this section, we explore the startup process of applications, analyzing ELF on Linux and PE on Windows, tracing execution from _start() to main(), and using Ghidra to inspect runtime initialization for deeper debugging and secure development insights.

The Importance of Order in C++ Classes

In this section, we explore the critical importance of ordering class members and initialization sequences in C++ to ensure predictable behavior, prevent undefined results, and maintain reliable, maintainable code in real-world applications.

C++ Is Not Memory-Safe

In this section, we examine spatial and temporal memory safety issues in C++, learn to use std::span to prevent buffer overruns, and analyze the ongoing limitations of modern C++ mechanisms in eliminating undefined behavior.

Parallelism and Concurrency in C++: Challenges and Solutions

In this section, we define parallelism and concurrency in C++ using functional programming and the Actor Model, addressing common challenges and demonstrating safer, more predictable approaches for scalable, high-performance systems.

The Fastest C++ Code Is Inline Assembly

In this section, we explore using inline assembly for peak performance in C++ on x86 architectures, while learning to evaluate compiler output and make informed decisions about when to optimize manually versus trust modern compiler optimizations.

C++ Is Beautiful

In this section, we explore the aesthetic qualities of C++ code, emphasizing symmetry, structural clarity, and elegance in macro and syntax design. It highlights how beauty enhances maintainability and intellectual satisfaction in programming.

There Are No Libraries for Modern Programming in C++

In this section, we examine the modern C++ library ecosystem, focusing on developer experience, compatibility across libraries, and supply chain security to build reliable, maintainable software in real-world applications.

C++ Is Backward Compatible ...Even with C

In this section, we explore C++'s backward compatibility with C, enabling seamless integration of legacy code. We examine practical applications of auto type deduction and interoperability with C libraries in modern system-level development.

Rust Will Replace C++

In this section, we explore Rust's ownership model, safety features, and trait system, demonstrating how they enable reliable, high-performance systems programming as a modern alternative to C++.