Reading for engineers,
chosen the way a mentor would.

A plainspoken treatise on complexity - why most senior engineers sound simple and why that is the point.

The foundational case against the "learn X in 24 hours" genre. Deliberate practice, deep immersion, time.

Still the single best career-defining book for working engineers. Reads like a senior sitting next to you.

The three-pass method. Applies to RFCs, design docs, postmortems - not just academic papers.

Why thinking - not typing - is the bottleneck. From the creator of Clojure, in his characteristic slow tempo.

A methodology for building software-as-a-service. Old, short, still correct about almost everything.

The canonical text on distributed systems. Dense, but the one book that will carry a decade of your career.

Why the ugly thing wins. A parable about Unix, Lisp, and the market that keeps repeating itself.

The assumptions you don't know you're making. Spawned a genre - and stopped a thousand bad forms.

The authors of real systems explain how they built them. The closest thing to reading code tours at scale.

A talk that teaches you what language design means - while only ever using one-syllable words, then two.

The distinction between "simple" and "easy" - and why mixing them up is how codebases rot.

Long. Unglamorous. The thing that will finally make cache lines click for you. Worth the afternoon.

Adding people to a late project makes it later. Fifty years old; every generation rediscovers this.

Rules of thumb from one of C's best stylists. Half of what became the Go style guide lives here first.

An actual bridge engineer turned programmer interviews others like him. What do we borrow, and what don't we?

Deep modules, shallow interfaces. A short book that quietly contradicts half of what you were taught.

A very funny, very true essay about what systems programmers actually do at 3am. Required reading.

The demo that launched live-coding, observable notebooks, and an entire aesthetic. Watch it twice.

The original supply-chain attack, explained in six pages by the person who could've actually done it.

How Linux got built. Dated in places; still the origin text for how open-source communities work.

Build two full interpreters, one in Java, one in C. The best hands-on CS education you can get for free.

You get a small number of "innovation tokens" per company. Spend them where it matters, boring everywhere else.

Every performance tool on Linux, explained by the person who built most of them. A reference for life.

Append-only logs as the foundation under queues, databases, and event systems. Origin story for Kafka.

A provocative, polarizing talk on software decay. Even if you disagree with half, you'll remember all of it.

Information hiding. The paper every "clean code" book is downstream of - and usually gets half-right.

Unix as a worldview, not an OS. Composition, transparency, and the rule of silence - principles that travel.

The code is not the program. The program is a shared theory in the team's heads. Explains so much.

Short essays on the most consequential lines of code in history. A lovely way to learn by story.