You Don't Hate Recursion. You Were Taught It Wrong.

Installing mental model for recursion.

Three lines of code drew this. A function that draws a triangle, then calls itself three times — each time smaller, each time nested inside the last. That's not a loop. That's recursion.

But here's what every tutorial gets wrong. They tell you recursion is a function calling itself. That's like saying a movie is pictures moving fast. Technically true. Completely useless.

Watch what actually happens. Here's factorial of three. When it runs, the machine doesn't just call the function again. It builds an entirely new world. A private copy with its own variables, its own state, completely sealed off from the original.

And that copy? It builds another copy. And another. Until we hit the floor.

The code looks like one function. But at runtime, four separate worlds exist simultaneously — stacked in memory, each frozen at a different moment, each holding a different value of n.

One blueprint. A tower of frozen worlds.

So what happens to all those frozen worlds?

This is the call stack. Think of it like dream levels in Inception.

Every function call pushes a new frame — a new level, with its own private memory, its own copy of every variable. And when a function calls itself, it's dreaming inside a dream.

Watch factorial of four. It calls factorial of three — that's level two. Three calls two — level three. Two calls one. One calls zero. Five levels deep.

And here's the thing — every single level is frozen. Waiting. The only one actually running is the one at the very top. Factorial of zero. And it knows the answer: one.

This is the base case. The kick that starts the chain reaction back up.

Now watch. Zero returns one. That value drops down to level four. Factorial of one takes it, multiplies by one, returns. Pops off. Factorial of two catches it, multiplies by two. Returns. Factorial of three — times three. Six. Returns. And finally, factorial of four — times four. Twenty-four.

The answer didn't come from one computation. It cascaded back through five frozen worlds, each one waking up just long enough to do its piece and pass the result down.

That's the unwinding. The part most people never see, and the part that makes recursion actually work.

But what if there's no base case? No kick? The stack grows and grows. Python cuts you off at a thousand frames. C gives you eight megabytes. After that — stack overflow. The program crashes. The website Stack Overflow? Named after exactly this.

Factorial is clean though. One call per level. Straight down, straight back up. But what happens when a function calls itself... twice?

Fibonacci calls itself twice. And that changes everything.

fib of five calls fib of four AND fib of three. fib of four calls fib of three and fib of two. Each of those branches again. The stack isn't a stack anymore. It's a tree.

Now look at this tree carefully. See fib of three? It appears twice. Fib of two appears three times. Fib of one — five times. The same computation, over and over, producing the same answer each time. The function has no memory. It doesn't know it's repeating itself.

For fib of five, that's fifteen calls. Sounds fine. But watch the tree grow.

fib of ten — a hundred and seventy-seven calls. fib of twenty — twenty-one thousand. fib of thirty — two point seven million. Each level nearly doubles the work. The complexity is O of phi to the n — exponential.

But what if the function could remember?

Add a dictionary. Before computing anything, check — have I seen this before? If yes, return the answer instantly. If no, compute it, store it, return.

Now watch the tree collapse. Every duplicate vanishes. The branches that once exploded into millions of redundant calls just... disappear. Two point seven million calls become fifty-nine.

Push just past a hundred, and the naive version would take longer than the age of the universe. The memoized version? Microseconds.

One dictionary. That's it. That's the difference between impossible and instant.

You might be thinking — just use a loop. And for factorial? Sure. A loop works fine.

But try writing a loop that walks this. A folder contains files and other folders. Those folders contain more folders. The depth is unknown. The branching is unknown. The structure itself is recursive — it contains smaller copies of itself. The only natural way to walk it is recursion.

And this pattern is everywhere. JSON documents nest objects inside objects. Git stores your repository as a tree of trees. React renders components that render components. Every compiler turns your code into an abstract syntax tree, then walks it recursively.

Recursion isn't an interview trick. It's the natural language for self-similar structure.

Remember those three lines that built a fractal? That's the purest form — where the output IS the recursion. A simple rule, calling itself, producing infinite complexity from almost nothing.

Once you see it, you see it everywhere.

Cognitive architecture... updated.