Name: The Self-Taught Developer's Guide to Big O Notation
Author: Robert M. Cavezza

O(1) // the vending machine O(log n) // the halving O(n) // the roll call O(n log n) // the sorting tax O(n²) // the handshake problem O(2ⁿ) // the doubling monster O(n!) // the seating chart nightmare O(1) // the vending machine O(log n) // the halving O(n) // the roll call O(n log n) // the sorting tax O(n²) // the handshake problem O(2ⁿ) // the doubling monster O(n!) // the seating chart nightmare

// what's inside

Four things. That's the whole book. On purpose.

01 / containers

The Containers

Arrays, objects, maps, sets — what they're actually doing under the hood, and when each one saves you.

02 / speeds

The Speeds

O(1) to O(n!), each with a nickname you'll actually remember when it matters.

03 / recipes

The Recipes

Searching, sorting, hashing, memoization, and more — the patterns behind every fast program.

04 / fixes

The Fixes

Five changes that solve 90% of slow code. Find your bottleneck, apply, ship.

// a taste — the speeds

Nicknames you'll actually remember

notation	nickname	the vibe
O(1)	The Vending Machine	Same speed at 10 items or 10 million.
O(log n)	The Halving	Cuts the problem in half every step.
O(n)	The Roll Call	Twice the data, twice the wait. Fair enough.
O(n log n)	The Sorting Tax	As good as sorting honestly gets.
O(n²)	The Handshake Problem	Everyone greets everyone. Fine at a dinner party, fatal at a stadium.
O(2ⁿ)	The Doubling Monster	One more item, double the work.
O(n!)	The Seating Chart Nightmare	The universe ends before your function returns.

// the author

Why this book exists

I'm Robert M. Cavezza. Most people call me Bobby. I learned to code the way a lot of us do: by shipping things, Googling the rest, and quietly wondering whether I was a real developer or just someone who hadn't been found out yet.

That feeling stuck around long enough that I eventually went back to grad school at Harvard to learn the things I'd been faking. CS fundamentals. Algorithms. The stuff I'd nodded along to in conversations for years.

Page 31 of this book is about O(log n). For a long time, logarithms felt like the part of math that existed to make things harder than they needed to be. Then one day it clicked: it's just halving. Every step cuts the problem in two. That's it. That's the whole thing.

That moment of realizing a scary-looking concept had a dead-simple mental model hiding inside it is why this book exists. If O(log n) can be "the Halving," then all of it can be understood. Not just by CS grads. By everyone.

Your app worked at 50 users.
It died at 5,000.
This is why.