Structured Programming

The inner declaration shadows the outer one: inside that block the name resolves to the new declaration, while the outer binding keeps its own value, untouched, and becomes visible again once the block ends.

Short-circuit evaluation stops as soon as the result is decided: a short-circuiting AND skips its second operand when the first is false, an OR when the first is true. The skipped operand never runs, so its log write never happens.

Call by value copies the argument's value into a fresh parameter slot, so assigning to the parameter cannot reach the caller. Call by reference copies the location of the caller's variable, so assigning to the parameter replaces the caller's variable.

The objection was about reasoning, not taste. With unrestricted jumps you can no longer describe where a running program has got to using a few coordinates, so a position in the text stops telling you what already happened.

The jump said once where control went; the flag says it everywhere. It adds a mutable value that every later step reads, so the reader must now track extra state through the whole routine to know which statements actually run.

A variant: a measure that strictly decreases on every pass and cannot fall forever. The work list's length is not one here, since a pass may push. Pair the count of never-yet-visited dependencies with the list's length and compare the pairs in order.

Under lexical scope the read binds to the declaration in the surrounding program text, decided before the program runs. Under dynamic scope it binds to the most recent still-active declaration on the chain of calls, so the caller decides.

A catch-all default makes any outcome added later fall silently into an existing arm, so nothing reports the missing case. Listing every outcome explicitly, with no default, turns that later addition into a loud failure at the point of change instead.

A block starts at a leader: the routine's first statement, any statement a branch can jump to, and any statement immediately after a branch. A block then runs from its leader to just before the next one, entered only at its top.

It adds bookkeeping: a control variable holding which chunk of the original flowchart runs next, wrapped in one loop over a selection that dispatches on it. The rewrite preserves the computed result, not the structure a reader sees.

An activation record is the block of storage created for one call. It holds the return address, saved caller state such as the previous frame's base, the incoming parameters, the routine's locals, temporaries for part-finished expressions, and room for the result.

Only the name's scope ends. Scope is the region of program text where a name can be used; lifetime is the stretch of run time during which the value exists, and the document's reference keeps that value alive.

The jump into the middle of a block resists rewrite, because it gives that block a second entry, and every structured construct has exactly one. Backward jumps become iteration and forward jumps become a guarded region; the inward jump forces the code itself to change.

At that exit, the property the loop preserves on every pass together with the condition that fired the break must imply whatever the code after the loop assumes. The normal exit condition — the work list emptied — is false there, so the tail cannot rely on it.

Resolve each mention outward to its nearest declaration and compare them. The write inside the loop reached a new per-iteration binding the edit introduced, while the read after the loop still reaches the outer binding, which nothing ever wrote.

An arm is unreachable when every input satisfying its condition already satisfied an earlier condition in the chain, or when its own condition is self-contradictory and no input satisfies it at all. First-match selection then guarantees it never runs.

Only when neither depends on the other's effect: neither reads what the other writes, neither writes what the other reads, and they do not both write the same place. Observable effects count as a shared place too.

The frame is released at the return, so the storage the reference names is no longer reserved for that record and the next call may claim it. The reference is invalid from the return onwards, even though reading through it often still succeeds.

Because the jump is forward only, targets one label, and never enters a block partway, so it keeps the single-entry discipline while the structured alternatives either duplicate the release sequence or deepen the routine one level per resource.

Whatever was still to be done after each pending call came back: which item is being visited, how far through its dependencies you had got, and any partial result waiting to be combined. A call in tail position leaves nothing pending, so that rewrite needs no stack at all.

No. Nothing in the loop's own state decreases, so there is no measure to exhibit; whether it stops depends on the world outside the code. You can still show partial correctness — if it exits, the fetch succeeded — and you get termination only by introducing a bound.

Nothing, unless the release was bound to the block's exit rather than written as a trailing statement. A release bound to block exit runs on every path out, the raising one included; a trailing call is simply never reached.

The counter lived inside the operand that was moved to the right, where a short-circuiting operator evaluates it only when the left operand has not already decided the result. Swapping operands preserves the boolean value but not which effects happen.

Every live call holds a whole frame, and frames are pushed into one bounded region reserved for the running thread. Depth multiplied by frame size outgrows that region, and the overrun is detected as a fault rather than handled gracefully.

Rarely as a destination, often as a scaffold. The flattening is behaviour-preserving and mechanical, which is its whole value on code nobody dares touch, but it moves the structure into a variable, so it must be followed by extracting and naming real regions.

By the conventional resolution of the dangling-else ambiguity, a trailing else binds to the nearest preceding conditional that does not already have one — the inner one. The grammar decides this, not the indentation.

They diverge whenever a second route reaches the same storage during the call. Copy-restore works on a private copy and writes back once at the return, so aliased writes are lost or overwritten and timing differs; call by reference makes every write land immediately.

A region is single-entry/single-exit when every edge into it from outside lands on one node and every edge out of it leaves from one node. It can then be collapsed to a single node and reasoned about as one statement.

Write the rule about the defect, not the keyword: permit forward-only jumps to a single top-level label inside one routine, refuse backward and inward ones, and rewrite on touch behind characterisation tests rather than in one sweep.