Two Hands Cannot Halve Every Stacking Time

My imaginary sport-stacking coach has one correction: stop watching the quick hand. Watch the hand waiting for somewhere to put its cup.

Two-handed coordination looks like an invitation to double throughput. But a cup cannot land on a supporting row that does not exist yet. Memorizing the sequence removes hesitation; controlled placement still takes time. Some work overlaps, and some stubbornly waits its turn.

That is the territory of Amdahl’s law: the part of a job that must run sequentially limits the benefit of parallel execution. It became particularly hard to ignore during the 2000s push towards multicore processors. More computing resources did not automatically make an entire program proportionally faster.

Let’s invent a tiny practice model. A routine contains 300 ms of unavoidable sequential work and 700 ms of work that could be divided perfectly between hands. These are illustrative numbers, not measurements of competitive stacking.

serial_ms = 300
parallel_ms = 700
baseline_ms = serial_ms + parallel_ms
for hands <- 1..2 do
  elapsed_ms = serial_ms + parallel_ms / hands
  speedup = baseline_ms / elapsed_ms
  :io.format("~B hand(s): ~B ms, ~.2fx~n", [hands, round(elapsed_ms), speedup])
end

Both versions print:

1 hand(s): 1000 ms, 1.00x
2 hand(s): 650 ms, 1.54x

Bash can do the same calculation using integer arithmetic. Here, speedup is stored in hundredths; the displayed result is truncated to two decimal places.

#!/usr/bin/env bash
serial_ms=300
parallel_ms=700
baseline_ms=$((serial_ms + parallel_ms))
for hands in 1 2; do
  elapsed_ms=$((serial_ms + parallel_ms / hands))
  speedup=$((100 * baseline_ms / elapsed_ms))
  printf '%d hand(s): %d ms, %d.%02dx\n' \
    "$hands" "$elapsed_ms" "$((speedup / 100))" "$((speedup % 100))"
done

Elixir expresses the ratios directly with floating-point division, rounding elapsed time to a whole millisecond for display. Bash keeps everything integral, which works cleanly for these particular durations and hand counts.

The model is optimistic: real hands share space, coordination has a cost, and placement errors demand recovery. Even its perfect two-hand routine only reaches about 1.54 times the speed. During timed practice, the useful question becomes wonderfully specific: which waiting movement can better sequence memorization or cleaner placement actually shorten?