Signal. Oregon State University’s ENGR 112 notes on Algorithmic Thinking, written by Kevin Webb for an intro engineering-computing course, make a claim most bootcamps quietly skip: learning to program is about developing algorithmic thinking, not about learning a language. The whole of Section 4 proves it by teaching you to toast bread — Start, get bread, depress lever, loop until it pops, enjoy — and then admits the flowchart for that same procedure is not unique. You can add a branch for burnt toast, a loop for scraping, a bypass for butter. The toaster is a truss in disguise.

System. The reason this holds in 2026, and held in 1972, is that every algorithm decomposes into three primitives: a process (do a thing), a conditional (branch on a Boolean), and a loop (repeat while true, or a fixed count). Webb’s notes lay them out flat — if, if…elseif…else, while, for, nested loops for stepping a matrix — with the operator table an engineer actually needs (&&, ||, ~=, >=). None of it is Python. None of it is MATLAB. That is the point: draw the flow first, pick the language last. It is the same discipline underneath the parametric stack PAZ readers already live in — a Galapagos run by David Rutten is an evolutionary loop wrapped around a fitness conditional, and even a transformer’s attention block, for all its O(n²) bookkeeping, is a weighted sum inside a loop. The primitives don’t change. Only the notation does.

The Tool: This primer is built to run on Mermaid (the mermaid-js project, started by Knut Sveidqvist and now maintained by a large open-source community). Mermaid turns a flowchart into text — you write the boxes and arrows as a few lines of markup, and it renders a diagram you can commit to git, diff in a pull request, and paste into a README. For an architect or computational designer, that is the missing half of ENGR 112: Webb teaches you to draw the algorithm; Mermaid lets you version it next to the code it becomes. It is worth an afternoon because a flowchart your whole studio can review is cheaper than a bug found on site.

Setup:

npm install -g @mermaid-js/mermaid-cli

cat > toast.mmd <<'EOF'
flowchart TD
  A([Start]) --> B[Get bread]
  B --> C[Depress lever]
  C --> D{Popped up?}
  D --No--> C
  D --Yes--> E{Dark enough?}
  E --No--> C
  E --Yes--> F([Enjoy toast])
EOF

mmdc -i toast.mmd -o toast.svg   # renders the flowchart to SVG

First steps:

1. Run the block above. Open toast.svg — that is Webb’s toaster loop, rendered from six lines of text.
2. Add the burnt-toast branch: after Enjoy toast, insert {Inedible?} --Yes--> [Scrape with knife] --> back into the eat step. Re-run mmdc. Notice you changed the algorithm, not a single line of any programming language.
3. Now swap the domain. Rename the boxes: Get bread → Export IFC, Popped up? → Clashes resolved?, Enjoy toast → Issue for construction. The graph is identical. You have just flowcharted your IFC round-trip.

←TODAY: A 2026 flowchart of your export-clash-reissue loop opens in any browser, no licence, no plugin. →3012: When this quarter’s authoring tool goes dark — and one always does — the flowchart still reads; the .rvt might not. Fulcrum: The diagram outlives the language because it never depended on one.

Street. On a working desk the payoff is boring and enormous. The bug that costs you a Thursday is almost never a syntax error; it is a missing branch — the case where the toast was already burnt, the wall type that had no clash rule, the while that never made its own condition false. Webb’s own trace makes the trap visible: run x = x/2 then x = x + 5 while x < 12 and it oscillates forever (9.5→4.75, 9.75→4.875, 9.875→4.9375…), checked only at the top of the loop. His two while-loop drills carry the receipts: successive halving takes x = 5 down to 0.625 in four passes, and the factorial loop resolves 5! to 120 in five. Most offices ship one infinite loop a week; it just wears a meeting invite.

Atelier: For a Swiss studio living the Archicad→Speckle→Bonsai round-trip, the move is to flowchart the pipeline before anyone opens a code editor — one Mermaid .mmd file per recurring workflow, committed to the project repo, reviewed like a Detailplan. This is exactly the shift a team adopting AI needs: when a model proposes a script, you already own the diagram it has to satisfy, so you review the flow, not the vibes. Monday move: pick your one flakiest workflow, draw it as a Mermaid flowchart this week, and mark every conditional that currently has no else branch — those are your next three bugs, listed in advance.

Hack: Count how many times a 12 metre bay survives halving before its members drop below a 0.3 m minimum depth — Webb’s successive-halving example, aimed at a truss instead of a number.

span, minimum, splits = 12.0, 0.3, 0   # metres: clear bay, smallest member depth
while span / 2 > minimum:               # check the condition BEFORE you act
    span /= 2
    splits += 1
print(splits)                           # 5 == floor(log2(span / minimum))

That loop is floor(log2(span/minimum)). Once you see the while-loop and the closed-form log as the same statement written twice, you stop fearing either — and you know why the condition sits at the top: move it below the halving and you subdivide one bay too far.

Move. The Daily Star ran a confession this year — “I spent two years learning AI, then another year unlearning it” — about outsourcing the thinking step until the muscle atrophied. The antidote is old and free: draw the flow yourself first. Even ZDNET’s write-up of Stanford’s Norvig-and-Thrun AI course makes the same point — the durable skill is the foundational structure, not this season’s tool. Clone Mermaid tonight, render one workflow you actually run, and keep the .mmd in the repo.

Learn-it:

• Project repo — github.com/mermaid-js/mermaid
• Docs / getting started — mermaid.js.org
• Primary source (this primer’s spine) — ENGR 112 §4, Algorithmic Thinking (K. Webb, Oregon State)
• Root concept — Flowchart (Wikipedia)
• PAZ note on the unlearning risk — “I spent two years learning AI, then another year unlearning it”