● Chapter 16 — 16-boundaries is built and CI-green (84 exercises). This is the final chapter of the #17

Merged

navicore merged 1 commit from chapter16 into main

2026-06-30 03:32:24 +00:00

navicore commented

2026-06-30 03:31:08 +00:00

Owner

curriculum-expansion plan.

The chapter's subject is failure, so every behavior was probed against real plgc first and the exact transcript
quoted in the prose. The arc — catchable error → uncatchable error → structural exclusions → synthesis:

01-overflow — integers are 64-bit; past the ceiling you get a catchable evaluation_error(int_overflow) — not
C's silent wraparound, not bignum. Factorial story: 20! fits, 21! overflows; the student catches it.
02-uncatchable — the keystone. resource_error(steps) (the 10000-step guard) is the one error catch/3 can't
stop — wrap a runaway in catch and it still dies at exit 3. Lesson: termination is a correctness obligation; the
student supplies the base case that is that safety.
03-no-database — no assertz; calling it is existence_error(procedure, assertz/1). State that changes lives in
arguments (accumulator), not a mutable database.
04-fixed-syntax — the only parse-time boundary (op/3, postfix, DCG → exit 2, before anything runs). But
operators are just sugar for compounds, so =.. builds any expression — the fixed table costs no expressiveness.
05-robust-eval (capstone) — one evaluator catching the whole recoverable engine-error family (zero_divisor,
int_overflow, type_error(evaluable,_)) and naming each, closing the whole exceptions+boundaries arc on the
asymmetry: you recover from a bad computation, never from one that won't stop.

All catchers match on the Formal's shape with _ in the culprit slot, so issue #36 (the bare-atom evaluable
culprit) can't affect them. Registry, ROADMAP (84), and README updated; a memory saved on the
constructive-teaching constraint that shaped the design.

curriculum-expansion plan. The chapter's subject is failure, so every behavior was probed against real plgc first and the exact transcript quoted in the prose. The arc — catchable error → uncatchable error → structural exclusions → synthesis: 1. 01-overflow — integers are 64-bit; past the ceiling you get a catchable evaluation_error(int_overflow) — not C's silent wraparound, not bignum. Factorial story: 20! fits, 21! overflows; the student catches it. 2. 02-uncatchable — the keystone. resource_error(steps) (the 10000-step guard) is the one error catch/3 can't stop — wrap a runaway in catch and it still dies at exit 3. Lesson: termination is a correctness obligation; the student supplies the base case that is that safety. 3. 03-no-database — no assertz; calling it is existence_error(procedure, assertz/1). State that changes lives in arguments (accumulator), not a mutable database. 4. 04-fixed-syntax — the only parse-time boundary (op/3, postfix, DCG → exit 2, before anything runs). But operators are just sugar for compounds, so =.. builds any expression — the fixed table costs no expressiveness. 5. 05-robust-eval (capstone) — one evaluator catching the whole recoverable engine-error family (zero_divisor, int_overflow, type_error(evaluable,_)) and naming each, closing the whole exceptions+boundaries arc on the asymmetry: you recover from a bad computation, never from one that won't stop. All catchers match on the Formal's shape with _ in the culprit slot, so issue #36 (the bare-atom evaluable culprit) can't affect them. Registry, ROADMAP (84), and README updated; a memory saved on the constructive-teaching constraint that shaped the design.

navicore added 1 commit

2026-06-30 03:31:08 +00:00

● Chapter 16 — 16-boundaries is built and CI-green (84 exercises). This is the final chapter of the

CI - Linux / CI - Linux x86_64 (pull_request) Successful in 52s

Details

820b662139

curriculum-expansion plan.

  The chapter's subject is failure, so every behavior was probed against real plgc first and the exact transcript
  quoted in the prose. The arc — catchable error → uncatchable error → structural exclusions → synthesis:

  1. 01-overflow — integers are 64-bit; past the ceiling you get a catchable evaluation_error(int_overflow) — not
  C's silent wraparound, not bignum. Factorial story: 20! fits, 21! overflows; the student catches it.
  2. 02-uncatchable — the keystone. resource_error(steps) (the 10000-step guard) is the one error catch/3 can't
  stop — wrap a runaway in catch and it still dies at exit 3. Lesson: termination is a correctness obligation; the
  student supplies the base case that is that safety.
  3. 03-no-database — no assertz; calling it is existence_error(procedure, assertz/1). State that changes lives in
  arguments (accumulator), not a mutable database.
  4. 04-fixed-syntax — the only parse-time boundary (op/3, postfix, DCG → exit 2, before anything runs). But
  operators are just sugar for compounds, so =.. builds any expression — the fixed table costs no expressiveness.
  5. 05-robust-eval (capstone) — one evaluator catching the whole recoverable engine-error family (zero_divisor,
  int_overflow, type_error(evaluable,_)) and naming each, closing the whole exceptions+boundaries arc on the
  asymmetry: you recover from a bad computation, never from one that won't stop.

  All catchers match on the Formal's shape with _ in the culprit slot, so issue #36 (the bare-atom evaluable
  culprit) can't affect them. Registry, ROADMAP (84), and README updated; a memory saved on the
  constructive-teaching constraint that shaped the design.

navicore merged commit ad5b7519b4 into main

2026-06-30 03:32:24 +00:00

navicore deleted branch chapter16

2026-06-30 03:32:24 +00:00

navicore referenced this pull request from a commit

2026-06-30 03:32:25 +00:00

Merge pull request '● Chapter 16 — 16-boundaries is built and CI-green (84 exercises). This is the final chapter of the' (#17) from chapter16 into main