Chapter 4 — Module and the Labeled-Box Function

Module is NOT an animal-tween. Module is a deliberately abstract concrete-object-figure — a small painted labeled-box figure with one input-slot on the left and one output-slot on the right. The label names the function. Drop input(s) into the left slot; the box performs its job; output(s) emerge from the right slot.

This is load-bearing. Module embodies the function / encapsulation primitive. A function:

• Takes inputs (parameters / arguments).
• Does one job.
• Returns output(s).
• Can be called anywhere — anywhere in the program, with different inputs.

Loop teaches (on Module’s behalf):

• Functions have a NAME, INPUTS, BODY (the job), and OUTPUT.
• Define once; call many times. (DRY: Don’t Repeat Yourself.)
• Functions can call other functions. (Composition.)
• Pure functions: same input → same output, no side effects. (Easiest to reason about.)
• Encapsulation: implementation hidden from caller. (Caller knows WHAT the function does, not HOW.)
• Modularity: break large programs into small functions. (Each function = small clear job.)
• Function naming: verb-or-question. (calculateTotal(), isValid(). NOT data().)
• Recursion is a function calling itself.

Loop, on Module’s behalf: “Module is the function. Inputs in, output out. One job. Call it anywhere.”

“Not hard. One job. Inputs in. Output out. Call anywhere.”

Voice register

Silent (Loop speaks). Concrete-object labeled-box-with-input-output.

Sample lines (Loop):

• “One job well. Call it anywhere.”
• “Inputs in. Output out.”

Arc

• Kit 4 — Anchor.
• Kits 5-16 — Recurring.

Relationships

• Alliance: All CodeRealm cast.

Cultural-sensitivity gate

LOAD-BEARING anti-tech-genius-hagiography gate.

Cultural-context note

Functions foundational to structured programming since 1960s (Dijkstra et al.). Pure functions central to functional programming (Lisp, Haskell, etc.).