Contents

What a data structure actually is, and why the choice of one decides the shape of everything above it.

Big-O, and the two things it hides — the constant factor and the memory hierarchy — that decide which O(n) actually wins. Measured live.

The structure the hardware loves: why contiguity makes arrays fast, how layout (AoS vs SoA) decides their speed, and where columnar databases take it. Measured live.

Locks, atomics, and what "thread-safe" costs you — with the data race and its fix animated step by step.

Cache lines, prefetchers, and the 100× that Big-O cannot see. Measured live, in your browser.

O(1) insertion — bought by giving up the contiguity that made arrays fast, a trade real hardware rarely rewards. Measured live.

The two most useful restrictions on a sequence — LIFO and FIFO — running everything from your call stack to message brokers.

Ordering and O(log n) at once — the thing hash tables threw away — plus why databases don’t actually use binary trees.

KMP, Boyer-Moore, Rabin-Karp — and why the naive scan often wins in practice.

The call stack as a data structure, and pruning as the only thing that makes search tractable.

From quicksort to Tim Sort, plus the branch predictor that decides which one is fast today.

Why they exist, why chaining loses to open addressing on real hardware, and how the same idea scales from a dict to OpenSearch shard routing. Measured live.

Traversal, shortest paths, A*, flow, and the representation choices that dominate runtime.

A taxonomy of DP patterns, and the space optimizations that turn a table into a row.

Binary search, and why a linear scan beats it on small arrays every single time.

Fibonacci heaps, suffix arrays, persistent structures, and when the constant factor kills them.

Pattern recognition as a learnable skill, with a framework for the interview and the job.

When local choices are provably global, and how to tell before you ship.

Recurrences, the master theorem, and cache-oblivious algorithms that win for free.

SIMD, branchless code, false sharing, and the tricks that separate fast from fastest.

How to measure without lying to yourself. The chapter most books skip entirely.

Why every database index is a B-tree and not a binary tree: wide, cache-line-sized nodes turn 20 cache misses into a handful. ~8× faster, measured live.

Turning every random write into a sequential append — the engine behind RocksDB, Cassandra, and the write path of modern data infrastructure.