An introduction to algorithm analysis with a practical focus on how CPUs execute code and fetch data. Topics include growth rates, locality, and why memory layout matters

An introduction to data structures and algorithms from a practical, hardware-first perspective. Learn how the physical layout of your data in memory impacts performance.

Data Structures & Algorithms

Understand how our code interacts with physical hardware. Learn about virtual memory, the stack vs. heap, cache lines, and prefetching.

CPUs, Memory, and Locality

Learn how input size affects execution speed and the most common class of algorithms.

Polynomial Algorithms

Working with massive datasets using divide and conquer strategies, and the the required trade-offs.

Logarithmic and Linearithmic Algorithms

Learn why some problems are impossible to solve exactly and how we can use approximations like Monte Carlo simulations to cheat.

NP-Hard and Approximations

Practical Algorithm Analysis

Setting up a lightweight framework for measuring performance. Create benchmarks that produce reliable, meaningful results

Separate our core logic into libraries, configure CMake for multiple targets, and apply hardware-aware optimizations.

Configuring a CMake Project

Integrate the industry-standard Google Benchmark library into a CMake project to capture nanosecond-precision timings.

Integrating Google Benchmark

Fight the compiler's aggressive optimizations to ensure benchmarks measure reality.

Writing Effective Benchmarks

Learn to interpret CPU time, variance, and the trade-offs between insertion speed and read speed.

Analyzing Benchmark Data

Using Google Benchmark's Range and Complexity features to visualize Big O growth and identify the moment our data falls off the CPU cache cliff.

Mapping Complexity and Hardware Cliffs

Using benchmarks to calculate the 'break-even point' where investing in data preparation pays off.

Amortized Costs and Crossover Points

Google Benchmark for C++

Understand how C++20 ranges reshape the standard library. Learn to combine algorithms and views for clean, efficient code

The bridge between data layout and algorithms. Learn how iterators abstract memory traversal and the hierarchy of capabilities.

The Iterator Pattern

An introduction to the C++ Standard Library's algorithms, lambda expressions, and handling memory safely with insertion iterators.

Standard Library Algorithms

Learn how C++20 Ranges and Views allow us to compose safe, lazy-evaluated data pipelines without sacrificing performance.

C++20 Ranges

Learn how to build readable, lazy-evaluated data pipelines that execute in a single pass, and chain C++20 views together using the pipe operator `|`

View Composition and Pipes

Bridge the gap between iterators and views using `std::ranges::subrange` to turn any pair of iterators into a composable, safe C++20 View.

Subranges and Range Interoperability

Iterators, Ranges, and Views

Implement modern C++23 data processing with views and algorithms. Reduce boilerplate while improving correctness and performance

The Producer-Consumer model of C++20 Ranges and the hardware implications of eager vs lazy evaluation.

The Four Algorithm Families

Integrate sorting into C++20 pipelines, the difference between stable and unstable sorts, and how to use partial sorting.

Sorting and Materialization

Learn how C++20 Projections allow us to separate sorting logic from data layout, the mechanics of `std::invoke` and the hardware reality of sorting large objects.

Comparators and Projections

Learn why sorting large objects is slow, and how to optimize it using Proxy Sorting and Data-Oriented Design (SoA).

Proxy Sort and Structure of Arrays

Iterate multiple containers simultaneously with `zip`, handle indices with `enumerate`, and skip elements with `drop` and `stride`.

Composition, Zipping, and Indicies

Using Algorithms and Views

Modern processors are built for parallel execution, not sequential code. Learn how to use multithreading and vectorization in C++ to match that reality

Offload heavy work to other CPU cores. Learn how `std::async` and `std::future` enable concurrent execution.

Asynchronous Tasks with `std::async`

Combine the elegance of C++20 Ranges with the power of parallel execution policies.

Parallel Algorithms and Execution Policies

Learn how mutexes and atomics prevent race conditions, and why hardware contention can make multithreaded code slower than single-threaded code.

Locks and Atomics

Explore the performance cost of synchronization, how to mitigate it, and how to avoid it entirely with better algorithm design.

Cache Coherency and False Sharing

Learn how SIMD registers allow you to process multiple data points in a single instruction, unlocking the full power of each CPU core.

SIMD and Automatic Vectorization

Introduction to Parallelism

Learn how to design and implement a domain-specific container from scratch. The chapter focuses on cache efficiency, data-oriented design, and real-world performance trade-offs

Build a custom container that combines the performance of data-oriented design with the ergonomics of object-oriented programming.

Domain-Specific Containers

Implement proxy sorting, physical memory permutations, and multi-threaded reordering.

Sorting and Permuting Containers

Comparing the performance cost of deletion techniques, and implementing the Swap-and-Pop approach in a Structure of Arrays container.

The Swap-and-Pop Idiom

Solving the index invalidation problem and the trade-offs between memory density and reference stability.

Stable Addressing and Tombstones

Upgrade simple indices into Generational Handles, creating safe, persistent references that detect stale access.

Generational Indices

The hidden cost of `std::vector` growth, why it is dangerous for real-time systems, and how to mitigate it.

The Reallocation Spike

Implementing a Structure of Arrays

Learn advanced bit-centric techniques including fast filtering, bit packing, and compression to maximize efficiency

Learn to use bitwise operators to pack multiple states into a single byte, reducing memory bandwidth use.

Working with Bits

Replace slow logical operators with fast bitwise arithmetic. Learn how to filter data without branching, avoiding pipeline flushes and speeding up queries.

Fast Filtering and Branchless Logic

Trade CPU cycles for memory bandwidth by compressing data using bit packing, quantization, and delta encoding.

Quantization and Delta Encoding

Use bloom filters for fast rejection, hierarchical bitmasks for spatial skipping, and hardware intrinsics using C++20's `<bit>` library.

Advanced Bitwise Techniques

Implement the high-performance Entity-Component-System (ECS) design pattern, alongside an API that makes the architecture easy to use

Transitioning from monolithic data structures to the ECS architecture, splitting our data into dedicated component pools.

Entity-Component-System (ECS)

Connecting components to their entities using the sparse set pattern, achieving fast lookups while maintaining cache-friendly contiguous data.

Relational Data and Sparse Sets

Efficiently pulling data from multiple component pools simultaneously using the smallest set driver pattern, and optimizing it using bitmasks to minimize cache misses.

The Join Algorithm

Improving our API using templates and a centralized registry using `std::tuple`.

Templatizing Components

Updating our ECS to support composable, range-based views that handle the smallest-set algorithm automatically using C++20 ranges.

Creating Views

Entity-Component-System

Learn the physical reality and problems of allocating memory on the heap, and how to bypass these issues using custom allocators

Understanding the mechanisms of memory allocation, and the severe hardware cost of working with the heap.

The Physical Reality of `new` and `delete`

Why do long-running programs inevitably degrade and crash? Discover the hardware reality of memory fragmentation and TLB thrashing.

Memory Fragmentation

Bypass the OS and the global allocator. Build a custom linear arena allocator to implement fast memory allocation with zero fragmentation.

Linear and Arena Allocators

Solve the problem of dynamic entity lifespans. Build a zero-allocation object pool using an implicit free list hidden inside dead memory.

Object Pools and Free Lists

Memory Management and Custom Allocators

An introduction to the mechanics of linked lists, their strengths and weaknesses, and how those weaknesses can be mitigated in high-performance systems

An introduction to node-based data structures. The physical reality of `std::list`, pointer swapping, fast insertions, and why pointer chasing destroys performance.

The Mechanics of Linked Lists

Replace 64-bit pointers with lightweight indices and back our linked list with a contiguous memory pool to maximize performance.

Index-Based and Pool-Allocated Lists

Balance the flexibility of linked lists with cache-line sympathy of arrays. Learn how to group data into contiguous chunks to drastically reduce pointer chasing.

Unrolled Linked Lists

Eliminate node wrappers and heap allocations entirely. Learn how the Linux kernel uses intrusive structures to weave physical memory into multiple logical lists simultaneously.

Intrusive Linked Lists

Trade memory capacity for faster search speeds. Learn how probabilistic express lanes create highly concurrent, self-balancing data structures.

Skip Lists and Probabilistic Linking

Linked Lists

Build high-performance, lock-free algorithms using native hardware instructions. Master optimistic concurrency, tame out-of-order execution with memory fences, and navigate the ABA pointer problem.

Review concurrency and learn how to directly manage OS threads using `std::thread` and `std::jthread`.

Execution Contexts and `std::thread`

Understand the physical reality of moving data between RAM and registers. Learn why explicit loads and stores are required to prevent data tearing in complex structs.

Data Tearing and `std::atomic`

Learn how to perform complex lock-free atomic updates using `compare_exchange_weak()` and the hardware limitations.

Compare-And-Swap (CAS)

Learn how CPU out-of-order execution breaks lock-free code, and how to use `seq_cst`, `acquire`, `release`, `acq_rel`, and `relaxed` to fix it.

Instruction Reordering

Discover why using CAS on pointers is a hardware minefield, exposing the physical realities of memory allocators and the infamous ABA problem.

Lock-Free Pointers

Lock-Free Mechanics

Transition from static data storage to data flow. Implement decoupled architectures and stream data across CPU cores using lock-free concurrency

Learn how to decouple producers and consumers using FIFO and LIFO buffering structures.

Queues and Stacks

Learn how to bend a contiguous array into an infinite circle to build fast FIFO data pipelines.

Ring Buffers

Build a Single-Producer Single-Consumer lock-free queue using atomics, memory barriers, and cache-line alignment.

SPSC Ring Buffers

Build a Multi-Producer Multi-Consumer lock-free queue using CAS loops, Sequence Tickets, and memory ordering.

MPMC Ring Buffers

Build a highly concurrent, lock-free object pool and defeat the ABA problem using generation tags.

Lock-Free Object Pools

Build a highly concurrent Treiber stack using atomic Compare-And-Swap (CAS) instructions.

Lock-Free Stacks

Stacks and Queues

Building optimized containers that use open addressing, Robin Hood heuristics, cuckoo hashing, and consistent hashing techniques

Explore hashing, bitwise masking, and why the standard library's implementations hurt CPU cache performance.

Hash-Based Containers

Learn how to build a contiguous, cache-friendly hash set using open addressing and linear probing.

Flat Sets and Linear Probing

Fix the worst-case scenarios of linear probing by implementing Robin Hood Hashing to minimize variance and keep CPU cache lines packed.

Robin Hood Hashing

Learn why string keys destroy cache locality, and how to fix it using Hash Caching and Heterogeneous Lookups.

Hash Caching and Heterogeneous Lookups

Learn how to globally deduplicate string data and transform complex data into fast integer handles.

String Interning

When our work outgrows a single machine's capability, learn how to partition it across a cluster using Consistent Hashing.

Hash Rings and Consistent Hashing

Implement strict guarantees by bounding a lookup to exactly two memory locations, and build a fast rejection path for massive databases.

Cuckoo Hashing and Filters

High-Speed Hashing

Additional lessons and chapters covering vectorization and trees are coming soon

Coming Soon

This course is intended for those who already have a basic familiarity with C++

Learn data structures and algorithms by building real systems, measuring performance, and understanding how your code interacts with the physical hardware.

A hands-on course where you'll implement, benchmark, and optimize code, turning abstract concepts into practical skills you can immediately apply.

Implement real systems like ECS and custom containers from scratch, reinforcing concepts through hands-on work and gaining confidence by building complete, working solutions.

Learn by Building

Turn abstract concepts into efficient implementations, learning how theoretical ideas translate into real-world code you can understand, modify, and confidently apply.

From Theory to Code

Identify performance bottlenecks, measure improvements correctly, and apply practical optimization techniques without guesswork or misleading assumptions about what actually matters.

Debug and Optimize

Use C++20 and C++23 features to write cleaner, more expressive code while reducing boilerplate and improving both safety and performance in everyday development.

Modern C++ Techniques

Build a toolkit of reusable patterns and approaches that transfer across projects, helping you solve new problems faster without relying on memorized solutions.

Reusable Patterns

Learn how to balance performance, readability, and maintainability, making better engineering decisions based on real constraints rather than idealized or purely theoretical scenarios.

Real-World Tradeoffs

What You'll Learn

Become a software engineer with C++.  Starting from the basics, we guide you step by step along the way

Intro to C++ Programming

If you're completely new to programming, we recommend starting with our introductory course:

New to Programming?

Practical DSA

Minimizing Variance with Robin Hood Hashing

Cuckoo Filter: Practically Better Than Bloom

Cuckoo hashing

Learn how to implement Cuckoo Hashing and Cuckoo Filters in C++. Replace Bloom Filters with a cache-friendly, bounded-lookup architecture to create lightning-fast rejection paths for massive databases.

Cuckoo Hashing and Cuckoo Filters in C++: Fast Rejection Paths

Partial-Key Cuckoo Hashing (The XOR Hack)

Cuckoo Hashing and Filters

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation

Practical DSA