Exercise 1: Why Reading PROCESS-PARA Once Gives a Misleading Picture — Possible Solution
====================================================================

WHAT A ONE-TIME READING OF PROCESS-PARA'S OWN SOURCE SHOWS
This chapter's own real example shows PROCESS-PARA containing exactly
one real statement: GO TO STEP-A. Reading only that line, in
isolation, gives the genuine impression that every single time
PROCESS-PARA runs, control transfers to STEP-A - a simple, fixed,
one-way jump with no apparent variation.

WHAT STEP-A GENUINELY DOES THAT ISN'T VISIBLE FROM PROCESS-PARA ALONE
This chapter's own warn-box explains that STEP-A contains a real ALTER
PROCESS-PARA TO PROCEED TO STEP-B statement - which genuinely rewrites
PROCESS-PARA's own GO TO statement so that its real target changes
from STEP-A to STEP-B. Critically, this modification is written inside
STEP-A's own paragraph, physically separate from PROCESS-PARA's own
source lines - nothing in PROCESS-PARA itself hints that its own
behavior can be altered from elsewhere in the program.

WHY THIS MEANS THE SAME LINE GENUINELY BEHAVES DIFFERENTLY OVER TIME
This chapter's own material states the real consequence directly: "the
exact same line of source code does something different the second
time." The first execution of GO TO STEP-A in PROCESS-PARA sends
control to STEP-A, exactly as the source literally reads. But by the
time PROCESS-PARA is genuinely reached a second time, its own GO TO
statement has already been rewritten by STEP-A's earlier ALTER, and
now sends control to STEP-B instead - with PROCESS-PARA's own visible
source text never having changed at all.

WHY THIS IS GENUINELY MISLEADING TO SOMEONE WHO'S ONLY READ IT ONCE
Someone who read PROCESS-PARA's own source once, without also knowing
STEP-A contains a real ALTER statement targeting it, would reasonably
but incorrectly conclude that PROCESS-PARA always transfers control to
STEP-A. That conclusion would be genuinely wrong for every execution
after the first, since the real target has been silently changed by
code sitting in a completely different, physically separate paragraph
- a change no amount of rereading PROCESS-PARA's own unchanged source
text would ever reveal.

ANSWER: Reading PROCESS-PARA's own source once shows only a fixed GO
TO STEP-A, giving the reasonable but genuinely incorrect impression
that it always transfers control to STEP-A. In reality, STEP-A
contains a real ALTER statement that rewrites PROCESS-PARA's own GO TO
target to STEP-B - a change made from an entirely separate paragraph,
with no trace of it visible in PROCESS-PARA's own unchanged source
text. This means the same line of code genuinely behaves differently
after its first execution, and no amount of rereading PROCESS-PARA in
isolation would reveal that change, since the real modification lives
somewhere else in the program entirely.

WHY THIS WORKS AS AN ANSWER
------------------------------
This correctly traces the real disconnect between what PROCESS-PARA's
own source visibly says and what it actually does after STEP-A's own
ALTER has run, explaining specifically why this chapter's own warn-box
calls this behavior genuinely disorienting rather than merely unusual.