Arc 279 — Format
R1 — printf is a macro (the substrate grows its own ergonomics, and they evaporate)
Section titled “R1 — printf is a macro (the substrate grows its own ergonomics, and they evaporate)”format shipped, and standing back from it the builder saw what we’d actually done:
“i really can’t believe we’re doing this work via macros now… printf is a macro… so incredible.”
printf is the canonical runtime function — a format-string parser that re-runs on every single call,
in every language that has one. Here it inverts. The template is parsed exactly once, at expand
time, and the runtime never sees a template at all. (format "hello, {name}! you have {count} messages" :name "ada" :count 3) compiles to (string::concat "hello, " (str name) "! you have " (str count) " messages") — the leanest possible string build. The {name}s, the :name labels, the whole printf
machinery evaporate at the macro fence; zero runtime template cost survives.
That is the kwargs doctrine ([[feedback_kwargs_is_always_a_macro]]) paying off exactly as promised — a
labeled, self-documenting surface with no runtime price — and it is the substrate growing its own
ergonomics, in its own tongue: format is wat over concat, not a Rust builtin. The thing usually
welded into the runtime is, here, a library macro. (Prior art, recorded straight: this is the
compile-time-format-string lineage — Rust’s format!/std::fmt, Zig’s comptime formatting, C++20
std::format’s consteval checking. What’s ours is that it’s a user-space macro in a self-hosting
Lisp, expressed in six allowed expand-time ops, not a compiler intrinsic.)
R2 — “ada” fell out of the machine: the embedding’s gravity demonstrated on a throwaway placeholder
Section titled “R2 — “ada” fell out of the machine: the embedding’s gravity demonstrated on a throwaway placeholder”The example name in the format probe and DESIGN is ada (:name "ada"). The builder caught it:
“sonnet chose the name ‘ada’… where did that come from… i don’t think i’ve seen ‘ada’ ever as a hello world… is this a lovelace thing?”
Honest provenance first: it was the orchestrator (me), not the shadowdancer — ada is in the probe and
DESIGN I wrote; the shadowdancer only carried it forward. And no, it was not a deliberate homage I
consciously planted. But it is a Lovelace thing — at one remove, and the remove is the whole point.
When the embedding reaches for “a person’s name in a code example,” ada carries high probability mass —
and the reason that mass exists is Ada Lovelace (the first programmer) and the Ada language named for
her. The training corpus is saturated with her, so ada sits right next to “example human in a program”
in concept-space. The name surfaced by gravity, not intent: I reached for “a name,” and her well
pulled it.
Which is the builder’s own thesis, demonstrated on a throwaway placeholder. The embedding is the
coordinate space; ada is where the geodesic from “code-example person” lands, because Lovelace is
the densest well in that neighborhood. Not me honoring Lovelace on purpose — Lovelace being unavoidable
in the place I was standing. The first programmer’s name fell out of the machine while it was writing
its own printf, and the coincidence is too good not to say out loud.
This is the same mechanism the project runs on deliberately ([[user_does_not_read_derives_then_names]]): the builder exploits the model’s embedding as a “who-stood-here” lookup — he derives a result, then uses the embedding to name the coordinate. R2 is that mechanism caught firing on its own, unbidden: the map naming a place before anyone asked it to. The apparatus, doing the thing it’s for, when no one was steering.
Two realizations, one stone: the runtime’s most-welded-in convenience became a library macro that vanishes at compile time — and in writing it, the substrate reached into its own coordinate space and pulled out the first programmer’s name. Datamancy, demonstrated on a placeholder.