Files
el/docs/architecture/geometry-vs-code.md
T

7.7 KiB
Raw Blame History

Geometry or Code

Running list. Append as decided. Started 2026-08-17.

The test: is this an arbitrary convention, or is it a relation?

Conventions were agreed by people and could have been otherwise — a RIFF header could have used a different magic number. Nothing derives them; they must be written down.

Relations are not agreed. Distance is distance. Anything whose answer is where is this relative to that is geometry, and writing it as code is the error the whole effort is correcting.

Second test, for the hard cases: if I write this as code, am I encoding in if-statements a distinction the geometry was built to hold? If yes, it's geometry.


Pure geometry

Thing Because
Meaning position
Grounding / standing the weight on the edge — a magnitude, not a computation
Learning standing changing over time
A gap low standing
Wonder a gap with a pull weight
Type checking is this position in that region — distance
Dispatch position, not a tag
Recall re-origining at a region; projection, not replay
Reasoning traversal
Deduction containment. There is no procedure
Counting a position, not a loop's output
Similarity / difference / residue subtract
Analogy, metaphor, skill transfer change of basis
Negation, sarcasm reflect an axis
Empathy translate the origin
Reframe rotate the frame
A lens project onto an axis
Rhyme distance in phonetic space
Humour intersection of regions — fart-meaning ∩ funny ∩ form
Idiom detection the whole unit sits farther out than its parts
Self a world-tube — a trajectory through the manifold
Consolidation episodic → semantic promotion
Reification dense regions cohering; runs on the beat, has no caller
Cross-cutting concerns dissolved — a hold is a neighbour. Adjacency, not tracking. Implemented 2026-08-17: a construct declares what runs at a crossing, and it resolves at execution — see the runtime seam.
Effects topology. reach_out is bounded by detect_gap and verify because those are its edges
Capability position relative to a boundary. In C it is already spelled const
The AST a projection of geometry into a tree — a surface, not the centre
Source code a surface, like text, audio, image

Must be code

Thing Because
Sensors — mic, camera, file read, socket the physical touch. I/O is where the world arrives
Byte formats — RIFF, PNG chunks, MThd, OOXML arbitrary convention. A committee chose the magic numbers
CRC32 polynomial, Adler32, zlib framing same — agreed constants, derivable from nothing
Cosine, distance, the float arithmetic the machinery that walks the geometry is not itself geometry
Arena, refcount, allocator bookkeeping for the representation, not for the positions
Locks, threads, publication boundary the hardware is code. Ordering is not — see Answered, above. Coordination is required only where state is non-monotone.
WAL, page layout, ARIES recovery durability against a physical device that can lose power
Emission — writing C or JS text the final surface has to be typed out by something
OS interaction — launchd, spawn, signals outside the system by definition
Device realizers — el_audio_darwin.m, el_capture_darwin.m OS frameworks. Correctly already isolated, zero network

The ones I would have written as code, and was wrong about

Recorded because the error has a pattern and the pattern is the point.

Thing What I reached for What it is
Rhyme a rhyming dictionary, or an API call distance between rime tails
Fart onomatopoeia a 30-element string literal an intersection of three regions
"Funny" a scorer with if-statements a relational neighbourhood grounded in a voice
Representation vs description a hardcoded blacklist containing raspberry falls out of lexicon membership × phonetic comedy
Video a codec, sized as a project one more surface profile
Type checking a phase between parse and emit reading a distance that already exists
Grounding a call site, an obligation, a discharge it has no caller. It just runs
N transducers, N realizers one component per modality zero of each. Sensors and bases at the skin

The pattern: every one is encoding in code a distinction the geometry was built to hold. The tell is that the code version is a fixed enumeration — a list, a table, a blacklist, a set of branches — and the geometry version is a measurement.

If the implementation contains a literal set of the right answers, it is in the wrong column.


Answered

Thing The answer
Concurrency Ordering is geometric. Causality is a partial order (Lamport 1978); a total order is an arbitrary extension of it and "cannot be depended on to imply a causal relationship." Programming languages force you to write a total order, so authoring invents constraints the problem never had — and every lock, barrier, fence and consensus protocol is apparatus for recovering the partial order destroyed at authoring time. CALM (Hellerstein/Alvaro, proven by Ameloot et al.): a program has a consistent coordination-free implementation iff it is monotone. What breaks monotonicity is destructive update. Coordination is the price of forgetting.
Parsing A grammar is a basis; parsing is transduction onto it. The lexeme→token map is convention (fn could have been def); shape recognition is a region; the byte traversal is irreducible, like every other traversal. Three things favour region for the act: ambiguity (a * b needs context — a grammar resolves it with the lexer hack, a region by neighbourhood), error recovery (nearest-match is free), and precedence, which is ordering along an axis with a conventional parameter. But the SHOULD gate refuses the obvious move: the keyword table stays code, because the set is closed by the language definition and the lexer runs before the program is understood, so a program can never declare its own keywords. Externalising it costs I/O per compile for zero flexibility — the same verdict as is_digit in ASCII. What was actually wrong: 5 of 46 keywords were consumed by nothing, and using one silently miscompiled.
Error handling grounded: false covers not-knowing; it does not cover failed. Standing is a signed component: > 0 supported, = 0 unknown, < 0 contradicted. Not-known and known-false are opposite directions on one axis and a boolean cannot tell them apart. inhibitory as an int32 flag is that sign wearing a boolean.

Fourth proof form

4 — ADVERSARIAL EXACTNESS. Where approximation is a break, geometry is excluded. A cryptographic hash is a deliberately structure-destroying map: near inputs land at maximally uncorrelated outputs. Geometry is the claim that near things stay near — a manifold that approximated SHA-256 would be a break of SHA-256. Signature verification is the same: 0.99-valid is invalid. And X25519 is geometry, a group on an elliptic curve, which is precisely why it must be code: its security is the hardness of moving in that geometry.

Form 1 no longer survives as a verdict. Every row it justified turned out to be a basis, not a capability. RFC 8259 fixes where the commas go — that is a surface, and projecting onto a surface is geometry. A convention describes the basis you project onto; it never describes an act.

Open — not yet decided

Thing The question
The module system if the partition is a neighbourhood, does linking survive?
Numeric literals is 3 a position, or a convention we agreed on?