You Will Fall: Restart From the Ground

You will fall. Not might — will. The forearm flexors contract hard enough to clamp shut their own blood supply, lactate stops clearing, and the hand opens whether or not you’ve decided to let go. On my first session I couldn’t top a single V0 cleanly; the wall didn’t beat me, my own circulation did. So the real design question in bouldering isn’t how to avoid falling. It’s what happens the instant after. You hit the pad, stand up, chalk, and start again from the ground — a clean, known-good state.

Joe Armstrong turned that exact motion into a fault-tolerance model at Ericsson in the late ’80s. Don’t wrap every risky move in defensive checks trying to survive a failure you can’t predict. Let the process die, and put something above it whose only job is to notice the death and start a fresh one. “Let it crash.”

In Elixir, the supervisor and its worker are two separate processes. The climber attempts the problem; if pumped, it just exits. The belayer is monitoring, sees the :DOWN, and spawns a new attempt from scratch — no partial state carried over from the fall.

defmodule Boulder do
  def climb(problem) do
    if :rand.uniform() < 0.25, do: IO.puts("sent #{problem}"), else: exit(:pumped)
  end

  def belay(problem, n \\ 1) do
    {pid, ref} = spawn_monitor(fn -> climb(problem) end)
    receive do
      {:DOWN, ^ref, :process, ^pid, :pumped} ->
        IO.puts("try #{n}: fell — reset to the ground")
        belay(problem, n + 1)
      {:DOWN, ^ref, :process, ^pid, :normal} -> :ok
    end
  end
end

Boulder.belay("V2 arete")

The shell version is cruder but the same shape — each attempt runs in its own subshell, so nothing leaks between tries:

#!/usr/bin/env bash
problem="V2 arete"; n=0
while :; do
  n=$((n+1))
  if ( (( RANDOM % 4 == 0 )) ); then
    echo "try $n: sent $problem"; break
  fi
  echo "try $n: pumped — drop, chalk, reset"
done

Running it:

try 1: pumped — drop, chalk, reset
try 2: pumped — drop, chalk, reset
try 3: sent V2 arete

What both versions get right is that the fall isn’t the exception path. It’s the normal path. I read the route from the ground the way I’d read a chess position — the whole sequence visible before I touch it — and then I fall anyway, three or four times, and each fall drops me back to the one state I can reliably rebuild from. The crash is how progress gets made, not what interrupts it.