Missing Link

See what Missing Link gives you

Real output from an actual run on the concept below. Most of the result is shown; nothing is reworded.

The concept you're stuck on

Recursion

Real run, 2026-10-07 — subject: Computer Science; level: undergraduate. The tool's own built-in example.

What it depends on, in order

• 1. Functions and return values — chance this is the gap: low
• 2. The call stack — chance this is the gap: high
• 3. Base case vs. recursive case — chance this is the gap: high
• 4. Trusting the recursive leap — chance this is the gap: medium
• 5. Recursion itself — chance this is the gap: low

The likely gap: the call stack

A very common pattern when students say recursion feels impossible to follow is that they are trying to track the logic of the function without a model of what the machine is doing underneath. Without understanding that each call is a separate, paused frame with its own variables — waiting for the call below it to finish before it can continue — recursion looks like the function is somehow running in parallel with itself, which is disorienting. This trips up a lot of people before they ever get to worrying about base cases.

How sure it is: medium

• The call stack is a very common gap at the undergraduate level for students new to recursion, and it directly explains the most frequently reported symptom of not being able to follow what the function does.
• The student gave only the concept name and no description of exactly where they get lost, so it is not possible to confirm whether the confusion is about execution order, base cases, or something else.
• If the student already has a solid call-stack model, the gap is more likely to be the recursive leap — the diagnosis could shift with one more piece of information about what specifically feels wrong.

The quick refresher

When your program calls a function, it creates a little box — called a stack frame — that holds that function's inputs and local variables. The program then pauses whatever it was doing and works inside that new box. When the function returns a value, that box is destroyed and the program resumes exactly where it paused, now holding the returned value. Recursion stacks these boxes on top of each other: each recursive call creates a new frame, pauses the one above it, and the whole tower unwinds from the bottom up once the base case is reached — each returning frame hands its value up to the frame that called it.

The common confusion

Students often imagine the function re-running from the top each time and overwriting its own variables. In reality, each call gets its own completely separate copy of the local variables. The version of the function at level 3 of the stack has no idea what level 2 stored in its variables — they are separate boxes.

If that's not it

• Trusting the recursive leap: You understand the call stack and can draw it, you can identify the base case and recursive case correctly, but you still feel you have to trace every nested call to convince yourself the function works — writing recursive functions from scratch feels impossible even on simple problems.
• Base case vs. recursive case: You can follow a recursive function someone else wrote when it is short, but when you try to write your own you either end up with infinite recursion or you are not sure what condition to check to stop the calls.

Study plan (2-4 hours across 2 study sessions)

• Build the call stack mental model: take factorial(4) or sum([1,2,3]) and draw every frame by hand — the input value going in, the recursive call pausing that frame, and the return value coming back up. Do this without running the code first.
• Add print statements before and after the recursive call in a function, run it, and check that the output matches your hand-drawn stack exactly. If it does, your model is accurate.
• Return to whatever recursive problem or explanation first confused you. This time, instead of reading the whole function at once, identify just the base case and just the recursive case, then ask: what does one frame do with the value returned from the frame below it?