Practical articles about modern C++, architecture, build systems, testing and real-world engineering.
Architecture & Real Projects
Learn how C++ features, ownership, dependencies, build structure, and testing come together when you move beyond isolated examples and start building real applications.
No More Helloworlds — Build a Real C++ App
Knowing C++ syntax is only part of the job. The harder problem is deciding how to split an application into components, manage dependencies and ownership, structure the build, and keep the code testable as the project grows.
The book walks through building a complete C++ application using practical architecture, modern CMake, GoogleTest, resource management, Git, and CI.
-
C++20 Modules Don’t Remove the Need for Good Interface Design
A practical look at how to prepare for C++ coding interviews without treating LeetCode as a replacement for real engineering work: train fast thinking, use modern STL, practice std::ranges, and turn interview preparation into useful daily C++ training.
View all Architecture & Real Projects articles
C++ Fundamentals & Lifetime
Understand objects, ownership, RAII and lifetime.
If Special Member Functions Are Unclear, Your C++ Code Will Stay Fragile
Get free 10–15 page PDF guide explaining one of the most misunderstood C++ fundamentals:
- onstructors and invariants
- copy vs move semantics
- destructors, RAII, and the Rule of Five
Clear explanations, real examples, and diagrams
-
Learn Objects Before Pointers: A Better Way to Understand C++ Memory Management
Should C++ beginners start with raw pointers and manual allocation? Drawing on a conversation with Patrice Roy, this article explains why objects, lifetime, RAII, and ownership should come first.
-
C++ Object Creation: Stack, Heap, and Lifetime
Stack and heap are useful terms, but they do not fully explain how C++ objects are created and destroyed. This article explores storage duration, object lifetime, ownership, RAII, and the practical reasons for choosing dynamic allocation.
-
RAII in C++
Learn why RAII makes resource management automatic and exception-safe, and how unique_ptr, containers, and other RAII types lead to the Rule of Zero.
View all Fundamentals articles
CMake & Build Systems
Build C++ projects around clear targets, explicit dependencies, and maintainable build configurations
Learn how modern CMake fits together with project structure, compilation, testing, and real-world build workflows.
Modern CMake Becomes Simple Once You Understand How Targets Work
Understand targets, dependencies, include paths, and what PUBLIC, PRIVATE, and INTERFACE actually mean.
-
Top 5 CMake Mistakes That Make Your Configuration Fragile
A practical look at common CMake mistakes that make build configuration fragile: overloaded CMakeLists.txt files, manual compiler flags, ignored CTest infrastructure, unnecessary custom logic, and global commands that break target boundaries.
-
Cross-compilation for Windows. Why not?
Build Windows binaries from Linux without maintaining a full Windows build environment. MXE + Docker setup, toolchain builds, and shipping DLL dependencies.
-
Precompiled headers in CMake? Easy peasy, lemon squeezy
Precompiled headers are a powerful way to reduce compilation time in C++ projects. The best part is that modern CMake supports them out of the box. In this article, I’ll show you how to set up your CMake project to take advantage of precompiled headers.
View all CMake & Build Systems articles
Career & Interviews
Practical advice for getting noticed, preparing for C++ interviews, and showing your engineering skills when it matters.
C++ Interview Preparation: A Practical Guide
Turn job requirements into a study plan, prepare for coding rounds, structure your answers, and learn from every interview.
-
How to Get an Interview Invitation in 2026
Getting an interview invitation in 2026 is not only about sending more applications. This article explains why direct applications often work poorly, how recruiters search for candidates, and how proper LinkedIn positioning can make your profile easier to find and understand.
-
If I Had to Learn C++ Today, Here’s What I’d Do
A practical C++ learning path: what to learn first, what to postpone, and how to build real skills through one project.
-
From Stress to Structure: A Practical C++ Interview Framework
A technical interview can feel chaotic: time pressure, unfamiliar people, and the need to explain your thinking clearly. This article turns that complexity into a simple C++ interview framework: what interviewers evaluate, how to communicate, how to manage time, and what “clean modern code” should look like under pressure.
View all Career & Interviews articles
Concurrency
Learn how to reason about shared state, choose the right synchronization strategy, and build concurrent C++ code that stays understandable as it grows.
C++ Synchronization Primitives Don’t Have to Be Confusing
Understand when to use mutexes, atomics, condition variables, semaphores, latches, and barriers — and the trade-offs behind each choice.
-
std::mutex Isn’t Enough: 3 Rules for Using It Safely
Adding std::mutex does not automatically make C++ code thread-safe. This article breaks down three practical rules for using std::mutex safely: rely on RAII, keep synchronization boundaries explicit, and treat std::recursive_mutex as a design smell before treating it as a solution.
-
C++ Transactional Memory
Transactional memory looks like an elegant solution to concurrency problems — but in C++, it comes with serious trade-offs. This article walks through GCC’s transactional memory implementation, explains how atomicity and rollback work in practice, and compares performance against mutex-based solutions. You’ll learn when transactional memory simplifies concurrent code — and when it makes things…
-
From Mutexes to Snapshots: Copy-on-Write for Read-Mostly Data in C++
When reads dominate writes, a mutex can turn into a scalability bottleneck. This article explains a simple copy-on-write “snapshot” pattern for C++20 using std::atomic: lock-free reads in user code, safe atomic updates for writers, and the trade-offs that decide when this approach is worth it.
Modern C++
Explore modern C++ features and abstractions that make code more expressive, safer, and easier to reason about.
From Complexity to Essence in C++
Modern C++ becomes much easier when features are understood as connected ideas rather than isolated syntax.
Get focused deep dives into practical C++ topics, with examples, trade-offs, and the reasoning behind the design.
-
Constructing views in Modern C++. A Practical Guide.
C++20 views are not limited to the adaptors provided by the standard library. When an operation cannot be expressed through their composition, you can implement a custom view. This article demonstrates the process by building a lazy, SAX-like XML parser. Along the way, it explains how views, iterators, and sentinels work together, which standard concepts…
-
C++20 Modules Don’t Remove the Need for Good Interface Design
A practical look at how to prepare for C++ coding interviews without treating LeetCode as a replacement for real engineering work: train fast thinking, use modern STL, practice std::ranges, and turn interview preparation into useful daily C++ training.
-
How to Make Coroutines Practical for C++ Projects
C++20 coroutines provide the low-level machinery for suspendable functions, but not a complete async runtime. This article explains what coroutines are, how std::generator makes lazy value generation practical, and how libraries such as libcoro provide tasks, schedulers, and thread pools for real projects.
Testing & Code Quality
Build confidence in your C++ code with practical testing, static analysis, runtime checks, and automated quality gates.
C++ Quality Gates: What to Check Before Merging Code
Learn how tests, coverage, sanitizers, static analysis, formatting, and code review work together to catch different classes of problems before they reach the main branch.
-
How C++ Sanitizers Work and Where They Miss Bugs
C++ sanitizers can detect memory errors, undefined behavior, uninitialized reads, and data races during execution. This article explains how the main sanitizers work, how ThreadSanitizer tracks happens-before relationships, and why good tests and realistic workloads are still essential.
-
Why clang-tidy matters in real C++ projects — and how to set it up
C++ compiles many mistakes that are still expensive. This article shows how `clang-tidy` helps catch subtle language misuse early — and how to introduce it into a real project without chaos.
-
How to Introduce Unit-Tests in Your Project
Unit tests don’t have to be a “big rewrite.” This article shows a practical way to introduce unit tests into an existing C++ project: integrate GoogleTest with CMake/CTest, start with isolated code, scale with fixtures, and mock external dependencies without turning your codebase upside down.
View all Testing & Code Quality articles