Skip to content
Essays · Long-Form Notes

Slow thinking about algorithms.

A small set of long-form essays. Fewer than one per week, because each is written slowly. Topics range from interview patterns to the craft of explanation to the books that shaped this curriculum.

The essays here are intentionally different from the module pages. Modules are structured curriculum. They cover an entire data structure or pattern from first principles. Essays are arguments. They make a claim, defend it with examples, and sometimes annoy people who hold the opposite position. That's the point.

We publish on no schedule. A new essay appears when one is finished, not when a calendar says it should. Each piece goes through at least three drafts before publication; the goal is the writing density of a careful textbook chapter, not the cadence of a blog. If you want every essay delivered, the RSS feed picks up new pieces within an hour of publication.

Essays draw on the same engineering experience that informs the modules: production performance debugging, technical interviews from both sides of the table, and the specific cases where the textbook answer is wrong. They link freely back into the modules where the underlying technique gets a proper treatment. Read them in either order; the cross-references work both ways.

Three essays are currently live. Two more are in draft. If a topic interests you that isn't covered yet, the contact page is the right channel for requests. Topic suggestions land in the queue; not every one ships, but most do.

Featured essays

Featured · The Canon

DSA study plans that actually work

How long does it take to learn data structures and algorithms? Six to twelve weeks, if the plan matches your deadline. Here are the three study plans behind AlgoMastery's pathways,

9 minPedagogy
Read essay
Essay · Patterns

Why your recursive solution works but you cannot explain it

Most developers can write a recursive function that passes tests. Far fewer can trace the call stack, name the invariant each frame maintains, or explain why the base case is suffi

Read →
Essay · Performance

Why arrays beat linked lists in practice

Arrays beat linked lists in most real code, and the reason is the memory hierarchy, not Big-O. Here is the cache-locality argument, an honest benchmark sketch, and the short list o

Essay · Engineering Taste

The Hidden Cost of Premature Abstraction

In algorithm design and in engineering generally, the most expensive bugs are not the ones we make, they are the abstractions we built before we understood the problem. This essay

Essay · Pedagogy

The texts that taught me algorithms

A slow reading list: four books that did the heavy lifting when I was learning. What each does best, what each is bad at, and why their strengths don't overlap as much as a glance

Essay · Pattern Recognition

Recognise the shape, not the problem

Interview problems reuse a small catalogue of shapes. The candidate who memorises two hundred problems is running a losing race against the candidate who can classify a new problem

Essay · Reasoning

Complexity is a contract, not a fact

"O(n)" is not a measurement. It's a contract: a promise about how running time scales <em>given certain assumptions</em>. When those assumptions fail, the contract is void, and fas

More essays arrive when they're ready. There is no schedule.