Paradigm Families

Satisfaction stops at the first roster that satisfies every rule. Optimisation must also prove nothing cheaper exists, which means refuting the whole remaining space under a bound. The proof, not the discovery, is what takes hours.

The nested pass sees a graph that is half-updated, so the handler reads values no settled state ever had. It can also re-trigger itself without bound, and its edit is a dependency the engine never recorded.

Independence licenses concurrency; it does not create it. Speedup is bounded by the longest dependency chain through the graph, by per-cell work too small to repay scheduling, and by hidden edges that serialise cells the engine believed were independent.

Prefer stating a fact the engine was missing, such as a dependency or a narrower property, over dictating strategy. A hint is the next resort and pins you to today's engine; a literal step is last, forfeiting derived order and idempotence.

Both bills, neither guarantee. Seams appear wherever the front line runs instead of at one edge, invariants hold in only part of the graph so nobody can rely on them, and every reviewer carries two models.

Cost settles it, not taste. Once a language supports several styles, idiomatic means what this codebase decided plus what the surrounding module already does, so the fix is a written rule naming which regions use which style.

Module-level state acts as an argument no signature declares. A third writer couples silently to the other two, turns call order into an unwritten contract, and forces every test, retry and concurrent run to reset the ledger first.

Name a defect class you can count, check it concentrates in that core, price the boundary plus the review tax, scope to a region closeable in one planning cycle, weigh cheaper partial moves, and set a stop rule.

When - or whether - the work happens. Under deferred evaluation, writing an expression only records how to produce a value; the work runs at the point some other code demands it, which may be far away or never.

A single shared operand stack. Each word takes its inputs off the top and leaves its outputs there, so the next word written finds exactly what the previous one left: juxtaposition is composition.

It pays when partitions are independent, each large enough to dwarf the cost of splitting and merging, reasonably even in size, and combined by an associative merge. Skew and the sequential fraction, not worker count, set the floor on wall-clock time.

Solve time is a property of the encoding, not only of the problem. A rule stated as one group constraint prunes far more than the equivalent pairwise pile, interchangeable people multiply identical rosters, and a poor variable order makes the search rediscover one conflict everywhere.

The critique says a narrow word-at-a-time channel between store and processing unit shaped the languages built on it, so programs became statement-at-a-time recipes with no useful algebra for combining them and a meaning that depends on a large implicit state.

Order changes nothing about what the rules mean and everything about how the engine looks for it. Under a fixed depth-first, top-to-bottom strategy, a recursive goal placed before the goal that would narrow it descends forever.