foundational forms in code
I.
Each pattern is a fragment recovered from the substrate of computation — a shape that recurs across languages, decades, and minds. We have arranged them here as one might arrange ruins in an impossible museum.
A presence that watches; a witness in the loop.
Subject and observer entangle without owning each other. State propagates outward in concentric ripples. The pattern is the silhouette of attention itself, rendered as architecture.
One vessel, summoned only when summoned.
A single instance held against multiplicity. The archetype of monastic stillness — a vow of solitude inside the runtime. All callers converge on the same point of origin.
A mouth that exhales instances on demand.
A vessel that produces vessels. The caller asks; the factory answers in objects. Concrete types remain hidden behind a veil of abstraction — concealment rendered as method.
A pilgrim that walks the length of a structure.
Movement abstracted from the path it traverses. The iterator is a quiet protagonist — it steps forward without knowing the shape of the road, yet always reports its position.
Skins layered upon skins; substance unchanged.
Behavior accreted around a core, ring upon ring, like sediment settling on a hidden stone. The original interface remains intact while the surface acquires new powers.
A translator stationed at the seam of worlds.
Two incompatible grammars meet at a doorway; the adapter is the doorway itself. It speaks both languages and reveals neither — only the meaning passes through.
"In the depth of code there are figures that no programmer invented —
they were waiting, the way ruins wait beneath a city,
the way certain dreams wait beneath the day."
II.
Six fragments preserved as code. Each cell is a slab of midnight holding a small recurrence — read them as inscriptions.
const route = strategies[mode];
const result = route(input);
return narrate(result);
// algorithm chosen at the seamtree.traverse(node =>
visitor.visit(node)
);
// behavior detached from shapehub.broadcast(event);
// many parts speak through one
// none knows the othersconst past = state.snapshot();
state.mutate(now);
state.restore(past);
// memory as a portable artefactconst op = new Command(target);
queue.push(op);
op.undo();
// intent reified as objectconst veil = new Proxy(real, {
get: (t, k) => observe(t, k)
});
// a stand-in that gates accessPatterns are not invented; they are remembered.