How One Jump Can Tangle a Program
A program is easier to understand when its instructions form a visible route: do this, then that, repeat these steps, or choose between two branches. A `GOTO` replaces that route with a direct jump to a labeled instruction elsewhere. The jump may skip over code, land inside a sequence, or send execution backward to an earlier point.
The difficulty grows when many jumps cross one another. To understand what a line does, a programmer must trace not only the instructions above it but every possible jump that might arrive there—and where execution can jump next. The result is often called spaghetti code: control flow that twists through the program like strands crossing in a bowl.
Why the Problem Compounds
Structured constructs such as loops and `if` statements make the boundaries of a decision or repetition explicit. With scattered jumps, those boundaries may be hidden. A change that seems local—moving a line or adding a condition—can alter a distant route through the code, creating bugs that are hard to reproduce and making later edits riskier.
This is why programming practice shifted toward structured control flow: it gives readers a smaller set of predictable paths to follow. `GOTO` is not inherently disastrous; a tightly limited jump can be useful in some low-level code or to exit a deeply nested sequence. The trouble is using it freely, without clear boundaries. When jumps multiply, the program stops reading like a sequence of decisions and starts requiring a map of every possible landing point.
