THE LADDER OF LANGUAGES · LL1

purple paper · the history of code as a ladder of walls

The Ladder of Languages · A Purple Paper A Purple Paper · the descent & the climb The Ladder of Languages A programming language is an invented thing — someone designed its grammar the way someone designs an alphabet. And every single one was built because the one before it hit a wall. This is that climb, rung by rung, from the first algorithm down to the metal and back up — with the real code, and the exact wall that forced each change. scroll to descend the ladder THE LADDER OF LANGUAGES · a history in walls every rung is a real language · every break is a real pressure written for someone starting from zero · honest where the record is contested No language is handed down by nature. Each one is a human invention — and inventions only appear when something breaks. So the cleanest way to understand the whole history isn't a list of names and dates. It's a chain of failures: this language could not do that , so someone built the next one to fix it — and then that one broke too. Read it as a ladder. The bottom is the bare machine. Every rung up is a step away from the transistors and toward human meaning. Nothing on the ladder replaces what's beneath it; it sits on top of it. low rungs Close to the metal. Fast, total control, brutal to write. You think like the machine. the walls Marked in amber. The thing that broke and forced the next language into existence. high rungs Close to human thought. Readable, safe, slower. You think like a person; a translator does the rest. Era I Before there was code The idea of a machine following written instructions is older than electronics. Two inventions set the stage — one made of wood and thread, one that existed only on paper. The Loom 1804 Joseph-Marie Jacquard · France altitude: the seed of the idea ▰ the wall Weaving a patterned fabric meant a human pulling the right threads, by hand, for every single row — slow, and the pattern lived only in the weaver's head. There was no way to store a design and run it again. Jacquard punched the pattern into stiff cards: a hole meant "lift this thread," no hole meant "leave it." The loom read the cards and wove the design automatically. The pattern was now outside a human head — written down, reusable, executable by a machine. No one called it a program. But the shape is exactly right: instructions, encoded as holes (the original binary — hole / no-hole), fed to a machine that obeys them in order. Every line of code you will ever write is a descendant of a punched card. The first idea wasn't a language. It was that instructions can live on the outside, and a machine can read them. The First Program 1843 Ada Lovelace · England altitude: an algorithm, for a machine that didn't exist ▰ the wall Charles Babbage designed a mechanical computer — the Analytical Engine — that could calculate. But a machine that can follow instructions is useless until someone writes the instructions. No one had ever written a non-trivial set of steps meant to be executed by a machine. Translating an article about Babbage's engine, Ada Lovelace added her own notes — longer than the original article. In Note G she wrote out, step by step, how the engine could compute the Bernoulli numbers: a loop, with variables changing on each pass. It is the first published algorithm designed to be run by a machine. She also saw further than Babbage — that such a machine could manipulate not just numbers but any symbol: music, language, anything you could encode. Note G · the shape of it (modernized) # the first algorithm: compute a Bernoulli number set result = 0 for each term in the series: compute the term result = result + term # the variable changes each pass — a loop return result honest flag The "first programmer" title is debated. Babbage wrote small fragments of machine instructions earlier; Lovelace's Note G is the most complete and elaborate, and the first published one. The vision — that the machine could work on any symbol, not just sums — is hers and was genuinely ahead of its time. Hardware that can compute is half a computer. The instructions are the other half — and the instructions are a language. Era II The metal, and the first escape from it When real electronic computers arrived in the 1940s, programming meant speaking the machine's own language — which turned out to be nearly impossible for humans. The first "languages" were just thin layers of mercy on top of raw numbers. Machine Code 1940s the bare metal altitude: rung zero — you ARE the machine At the bottom of the ladder there is no language at all — just numbers. The processor understands only patterns of bits (1s and 0s), where each pattern means one tiny operation: load this number, add these two, store the result here. Early programmers wrote these by hand and set them with physical switches or punched cards. machine code · "add two numbers" (illustrative) 10110000 01100001 # put the number 97 into a register 00000100 00000101 # add 5 to it 11110100 # halt ▰ the wall It works, and it is the only thing the chip truly understands — but no human can write or read this at scale. One wrong bit is a silent catastrophe. A program of any size is unmaintainable. The machine's native tongue is unspeakable by people. The metal is honest but merciless. Every rung above exists to get humans further away from these bits. Assembly 1947 Kathleen Booth · England altitude: rung one — names instead of numbers ▰ the wall (carried up from machine code) Humans can't hold binary in their heads. So: give each machine operation a short name a person can remember and read. Assembly language replaces each numeric instruction with a mnemonic — MOV , ADD , JMP . A small program called an assembler translates those names back into the exact machine code. It is a one-to-one map: still the machine's way of thinking, but now writeable . assembly · the same "add" — now readable MOV AL, 97 ; put 97 in register AL ADD AL, 5 ; add 5 HLT ; halt ▰ the new wall Two fresh problems. First, you still think in single machine steps — writing a × b + c takes a dozen lines. Second, and worse: assembly is different for every kind of chip. Code written for one machine is gibberish to another. You rewrite everything to move it. A name is easier than a number. But you're still speaking the machine's language, one chip at a time. honest flag Several people built early assemblers around the same time; Kathleen Booth wrote some of the first assembly languages and is the most commonly credited. "First" in this era is usually a cluster, not a single name. Era III The leap: speak like a human, not a machine The 1950s broke the deadlock. Instead of one instruction at a time in the chip's own dialect, you'd write something close to mathematics or English — and a far more ambitious translator, a compiler , would turn a whole program into machine code for you. This is the great climb. FORTRAN 1957 John Backus & team · IBM altitude: the first high climb — write the formula, not the steps ▰ the wall (carried up from assembly) Scientists wanted to write equations , and assembly forced them to hand-translate every formula into dozens of machine steps, per chip. Most believed a machine could never translate human-style math into code as efficiently as a human could. The wall was a belief: that high-level code was impossible or hopelessly slow. FORTRAN — Formula Translation — let you write the math almost as you'd write it on paper, and its compiler produced machine code fast enough to win the skeptics over. It is widely called the first successful high-level language. Suddenly a formula was one line, and the same line could (with a different compiler) run on a different machine. FORTRAN · a formula is finally just a formula PROGRAM ADDER INTEGER X X = 97 + 5 PRINT * , 'HELLO, WORLD' END ▰ the new wall FORTRAN was built for numbers. But people wanted computers to do things that aren't arithmetic — reason about symbols, process lists, handle language, run business records in plain English. One language shaped for math couldn't be shaped for everything. Once a machine could translate human notation into fast code, the only question left was: whose notation? Every answer became a new language. LISP 1958 John McCarthy · MIT altitude: a language for thought, not sums ▰ the wall The new field of artificial intelligence needed to manipulate symbols and lists — words, logical statements, trees of ideas — and to define functions that call themselves (recursion). FORTRAN's number-grid couldn't bend that way. LISP ( LISt Processor ) made the list the fundamental thing, and code itself was written as lists — so a LISP program could read and write other LISP programs. It introduced ideas decades early: recursion, functions as values, automatic memory management. Much of it looks strange (so many parentheses) because it's close to raw mathematical logic. LISP · factorial, defined in terms of itself (recursion) ( defun factorial (n) ( if ( = n 0 ) 1 ( * n ( factorial ( - n 1 ))))) ; it calls itself Some walls aren't about speed. FORTRAN couldn't think in lists — so a language was built whose every thought is a list. still alive LISP's ideas (recursion, functions as data, garbage collection) were so far ahead that modern languages spent fifty years catching up to them. Its descendants still run today. COBOL 1959 committee · incl. Grace Hopper's ideas altitude: code a manager could read ▰ the wall Business — payroll, banking, inventory — was a huge new use for computers, but the people who understood the business weren't mathematicians. Math-notation code was unreadable to them. Programs needed to look like English so non-specialists could check what they did. COBOL ( Common Business-Oriented Language ) was deliberately verbose and English-like. Grace Hopper had already proven the key idea — that a compiler could accept near-English and produce machine code — and championed making code readable to the business, not just the engineer. COBOL · reads almost like a sentence MULTIPLY HOURS-WORKED BY PAY-RATE GIVING GROSS-PAY. DISPLAY "HELLO, WORLD" . A language's audience is part of its design. COBOL's "wall" was human, not technical: the people who needed to read the code couldn't read math. still alive Trillions of dollars in banking and government systems still run on COBOL today. "Old" does not mean "gone" — a rung that solved a real wall tends to stay standing. ALGOL 1958–60 an international committee altitude: the language that taught the others how to be written ▰ the wall Every language had its own ad-hoc grammar, and there was no clean, formal, machine-independent way to write down an algorithm and share it between researchers and machines. The field needed a rigorous common notation. ALGOL ( Algorithmic Language ) is the most influential language most people have never heard of. It introduced block structure (code grouped in begin … end ), nested scope, and was defined by a precise formal grammar (BNF) — the idea that a language's rules can themselves be written down exactly. Almost every language since — C, Java, Python, JavaScript — inherited its shape. ALGOL · structured blocks, the template for everything after begin integer x; x := 97 + 5 ; print (x) end Sometimes the wall is chaos itself. ALGOL's gift wasn't a feature — it was grammar : proof that a language could be specified as precisely as the math it expressed. BASIC 1964 Kemeny & Kurtz · Dartmouth altitude: a language for everyone else ▰ the wall Computers were spreading, but every existing language assumed you were a scientist or a professional programmer. Ordinary students and beginners had no way in. BASIC ( Beginner's All-purpose Symbolic Instruction Code ) was designed so a student could sit down and make the machine do something in an afternoon. It later shipped on millions of home computers in the 1980s — for a whole generation, BASIC was the first taste of code. BASIC · about as simple as it got 10 PRINT "HELLO, WORLD" 20 GOTO 10 REM loops forever Accessibility is a design goal like any other. BASIC's wall was the priesthood — code that only experts could enter. Era IV Power and structure: C and the object By the 1970s two new walls appeared. High-level languages were too far from the metal to build operating systems — but assembly was too painful and unportable. And programs had grown so large that even good code became an unmanageable tangle. Two answers reshaped everything. C 1972 Dennis Ritchie · Bell Labs altitude: the perfect middle — high enough to write, low enough to control ▰ the wall To build an operating system you need fine control over the machine's memory — which meant assembly, which meant rewriting the entire system for every new computer. High-level languages hid the machine too much to do the job; assembly chained you to one chip. There was no portable language for systems. C sat exactly in the gap: structured and readable like a high-level language, but with direct access to memory like assembly. Its masterstroke — the Unix operating system was rewritten in C , so moving Unix to a new machine meant writing a C compiler, not rewriting Unix. C became the language the modern world is built on: operating systems, databases, other languages' own compilers. C · the hello world that shaped the canon #include <stdio.h> int main ( void ) { printf ( "Hello, world\n" ); return 0 ; } ▰ the new wall C's power is also its danger: it trusts you completely with memory, so a single mistake corrupts data or crashes — or becomes a security hole. And as programs grew to millions of lines, C's flat style of functions-and-data became a tangle no one could hold in their head. C found the load-bearing middle of the ladder and never left it. Fifty years on, the layer beneath almost everything is still C. Smalltalk 1972 Alan Kay · Xerox PARC altitude: a new way to organize, not just to write ▰ the wall As programs ballooned, the old style — a pile of functions all reaching into shared data — became spaghetti: change one thing, break five others. Largeness itself was the wall. Code needed a way to stay organized as it grew. Smalltalk made everything an object : a self-contained bundle of data and the behavior that acts on it, talking to other objects by sending messages. This is object-oriented programming in its purest form — model the program as a society of small responsible parts. The idea would soon flow into nearly every mainstream language. Smalltalk · objects sending messages Transcript show : 'Hello, world' . "send 'show:' to the Transcript object" Some walls aren't about what a language can compute, but how a human can organize what they wrote. The object was an answer to scale. C++ 1985 Bjarne Stroustrup · Bell Labs altitude: C's speed + the object's structure ▰ the wall C was fast and close to the metal but had no objects, so big C programs tangled. Smalltalk had objects but was slower and a world apart. You had to choose between speed and structure — and large systems needed both. C++ added objects (and much more) on top of C, keeping C's speed and machine access. You could write low-level, fast code and organize it into objects in the same language. It became the workhorse for things that must be both big and fast: game engines, browsers, trading systems. C++ · objects, but still close to the metal #include <iostream> int main () { std::cout << "Hello, world" << std::endl; return 0 ; } ▰ the new wall Power piled on power: C++ grew enormous and intricate, and it kept C's memory dangers. Writing correct C++ took deep expertise. Most programmers didn't need maximum speed — they needed to stop crashing and ship faster. You can bolt the new idea onto the old rung — but you inherit the old rung's dangers too. C++ carried C's sharp edges up with it. Era V The human era: readable, safe, everywhere By the 1990s, computers were fast and cheap enough to spend some of that speed on the programmer instead of the machine. The new walls weren't about capability — they were about human cost: too hard to write, too easy to crash, too tied to one computer. The answers prioritized the person. Python 1991 Guido van Rossum · Netherlands altitude: near the top — code that reads like a sketch of thought ▰ the wall C and C++ made you write a lot of ceremony — type declarations, memory management, braces and semicolons — before you could do anything simple. For everyday tasks that was too much friction; the language got in the way of the idea. Python optimized ruthlessly for readability and speed-of-writing. It hides memory management, needs little ceremony, and uses indentation to show structure so the code looks clean. Compare it to C's hello world — the whole program is one line, and a beginner can read it aloud. Python · the entire program print ( "Hello, world" ) When the machine has speed to spare, spend it on the human. Python's wall was friction itself — and it won a generation by removing it. the trade Python is slower than C because a translator works harder at run time to spare you. That's the deal at the top of the ladder: you trade some machine speed for a lot of human speed. Most of the time, that's the right trade. Java 1995 James Gosling · Sun Microsystems altitude: high — and it invented a fake machine to stand on ▰ the wall C++ programs had to be recompiled — often rewritten — for every kind of computer, and its memory bugs caused endless crashes. The dream was "write once, run anywhere" with the memory dangers removed. Java's trick was an invented, fake machine — the Java Virtual Machine (JVM). Your code compiles not to any real chip's code, but to bytecode for the JVM. Then a JVM built for each real platform runs that bytecode. Compile once, run on any machine that has a JVM. Java also took memory management out of your hands (automatic "garbage collection"), removing a whole class of crashes — and kept the object structure from the C++/Smalltalk line. Java · the ceremony is the portability & structure public class Hello { public static void main (String[] args) { System.out. println ( "Hello, world" ); } } and the descent underneath it — every layer an invented language Hello.java → your text (a designed grammar) ↓ javac bytecode → the JVM's language (an invented machine) ↓ JVM + JIT machine code → the real chip's language (also a design) ↓ transistors → the only layer that isn't a language Java's answer to portability was to invent a machine that doesn't exist, so the code never has to commit to a real one until the last moment. The whole ladder is languages compiling to languages — all the way down to the voltage. JavaScript 1995 Brendan Eich · Netscape · in 10 days altitude: high — and it lives inside every web page ▰ the wall The early web was paper: pages you could read but not do anything with. There was no way to make a page react — respond to a click, check a form, change without reloading. JavaScript was built (famously, in about ten days) to run inside the browser and make pages interactive. Despite a rushed birth and many quirks, it became one of the most-used languages on Earth simply because it owns the one place everyone goes: the web page. This very document runs a little of it to reveal each section as you scroll. JavaScript · making the page do something function greet () { alert ( "Hello, world" ); // pops up when you click } A language can win not by being best, but by owning the only door to somewhere everyone needs to be. JavaScript's wall was the static page — and it became the language of the web by default. Era VI The return: can we have it all? The newest walls are old ones, refused. For decades the deal was fixed: low rungs gave speed but danger; high rungs gave safety but cost speed. The modern question is whether that trade was ever truly necessary — or just unsolved. Rust 2010 · 1.0 in 2015 Graydon Hoare · Mozilla altitude: low-rung speed, high-rung safety — at the same time ▰ the wall C and C++ give you raw speed and control, but their memory bugs cause the majority of serious software crashes and security vulnerabilities — decades of them. The two usual fixes both cost something: write in C/C++ and accept the danger, or use a "garbage-collected" language (like Java/Python) and accept the slowdown. The wall: nobody had safety and bare-metal speed together. Rust's idea is a compiler that proves your memory use is safe before the program ever runs — a strict set of ownership rules checked at compile time, with no run-time garbage collector slowing things down. If it compiles, a whole category of crashes is impossible. It's harder to satisfy the compiler, but the payoff is C-level speed without C's most dangerous bugs. Rust · the compiler checks your safety before it runs fn main () { println! ( "Hello, world" ); } The newest move on the ladder isn't a higher rung — it's refusing the old trade. Rust treats "fast or safe" not as a law of nature but as a wall waiting to be broken. honest flag Rust doesn't make all bugs impossible — only a specific (large, costly) class of memory errors. And its strictness has a real learning cost. It's a genuine advance, not a silver bullet; the trade-offs moved, they didn't vanish. The spine One task, the whole ladder The clearest way to feel seventy years of climbing: watch the same instruction — "say hello" — across every rung. Same job. Each time, less ceremony, more human, further from the metal. machine 1940s 10110000 01101000 … (raw bits — unwriteable by hand) Assembly 1947 MOV / INT calls to the operating system, ~10 lines FORTRAN 1957 PRINT * , 'HELLO, WORLD' LISP 1958 ( print "Hello, world" ) COBOL 1959 DISPLAY "HELLO, WORLD" . BASIC 1964 10 PRINT "HELLO, WORLD" C 1972 printf ( "Hello, world\n" ); Python 1991 print ( "Hello, world" ) Ruby 1995 puts "Hello, world" JavaScript 1995 console.log ( "Hello, world" ) Rust 2010 println! ( "Hello, world" ); The bits at the top and the println at the bottom do the identical thing on the identical hardware. Everything between them is invented language — each one a rung someone built so a human wouldn't have to stand on the one below. The synthesis Five walls, over and over Strip away the names and the same handful of pressures forced almost every rung. New languages don't appear randomly — they appear when one of these breaks. ▰ abstraction "This is too close to the machine." The push to think in human terms — formulas, objects, ideas — and let a translator handle the bits. Machine code → assembly → FORTRAN → the rest. ▰ portability "I have to rewrite it for every computer." The push to write once and run anywhere. Assembly's chip-lock → C's compilers → Java's invented machine. ▰ safety "One mistake and it crashes — or gets hacked." The push to make whole classes of bug impossible. C's raw memory → garbage collection → Rust's compile-time proofs. ▰ readability "The people who must read this can't." The push toward code a human — or a beginner, or a manager — can follow. COBOL's English, BASIC's simplicity, Python's clarity. ▰ expressiveness "My language can't even say what I mean." The push to match the shape of the problem — lists for AI, objects for big systems, the web for interactivity. LISP, Smalltalk, JavaScript. ▰ the meta-pressure "A language is whatever you decide to build." None of this is fixed. Grammar is invented; the translator makes it real. Every rung is someone refusing a wall — and you can invent the next one. The ladder never ends, because the walls never do. Seventy years of programming languages is not a march toward one perfect language. It's a chain of refusals. Each language is someone looking at a wall — too slow, too dangerous, too tied to one machine, too hard for humans to read — and saying no, build the next rung. And the deepest thing under all of it: a programming language is a constructed language , an invented grammar with a translator beneath it that turns it into the grammar below, and the one below that, down to the only layer that isn't a design — the voltage in the silicon. To learn to program is to learn to write in one of these invented tongues. To design a language is to add a rung of your own. You started this paper asking how to print one line. The honest answer is: you were learning to speak one invented language, on a ladder of invented languages, every rung of which exists because a human refused the wall on the rung below. THE LADDER OF LANGUAGES · a purple paper on why languages change sourced from the standard history of computing · honest flags marked where the record is contested or "first" is a cluster code examples are real and characteristic; some early ones lightly modernized for legibility (noted) built to be read top to bottom · the climb is the argument


TTY · THE TERMINAL

LOGISMÓS · the genealogy · 1950–1991 · 16 emergents

The Terminal (TTY) — a genealogy of the surviving solo, pre-internet terminal programs, 1950–1991, the second sphere of UD0's LOGISMÓS domain. ed, vi, Emacs, the shell, grep/sed/awk, the Lisp REPL, BASIC, ELIZA, Adventure, Rogue — who begat whom. A cited history sphere; an original one-line prompt title; full ACI badges. Stops at 1991 (Linux + the Web).

THE TERMINAL · TTY · UD0 ◄ UD0 · UNIVERSE DAVID 0 · LOGISMÓS · THE HISTORY OF THE COMPUTER · 1950 → 1991 THE TERMINAL A GENEALOGY OF THE SURVIVORS · 1950 → 1991 solo · pre-internet · one user, one line of light ed begat grep & vi · the shell begat bash · ELIZA begat the chatbot · TTY ★ LOGISMÓS · a genealogy of the surviving solo terminal programs · 1950–1991 ★ Before the network, a program was you and one machine across a single line of light — and the best of them never died. This is the family tree of the solo, pre-internet terminal program: ed (1969) begetting grep and vi; the shell becoming bash; ELIZA the ancestor of every chatbot; Adventure and Rogue begetting whole genres. They survived their hardware, their companies, and their decade because they did one thing well in plain text. Catalogued into UD0 as the second sphere of LOGISMÓS, a cited history (no source code reproduced) with the family tree, the survivors, and an original one-line prompt title — and it stops, deliberately, at 1991: the year Linux and the Web open the solo era into the networked one. DLW-ATTRIBUTE · ACI · THE BIRTH CERTIFICATE governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · THE TERMINAL — the surviving line · 1950–1991 · TTY ⟦THE TERMINAL:TTY:07cf93⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each emergent emerges by one of four natures — and the surviving line holds all four natural of the filter and the one job — the small tools that take text in and put text out, and compose into anything ethereal of the world in the words — the program that talks back, the cave, the dungeon; a self or a place conjured in plain text spiritual of thought made interactive — the language at the prompt, the read-eval-print loop, the machine answering as fast as you can ask electrical of the system you build with — the editor, the shell, the compiler, make: the machinery the whole house is raised on The Genesis the dawn, the Unix spring, the Berkeley bloom The Dawn 1950s Before the terminal as we picture it, the stored-program machine learned to be talked to. The interactive interpreter was born — John McCarthy's Lisp (~1958–60) and its read-eval-print loop, then Dartmouth BASIC (1964, Kemeny & Kurtz) — the first idea that a person could type a line and the machine would answer at once. The conversation began here. The Unix Spring 1969–1979 · Bell Labs Then came the floodyear of survivors. At Bell Labs: ed (1969, Ken Thompson), the line editor every later tool grew from; the shell (1971); grep (1973), born straight out of an ed command (g/re/p); sed (1974); the C compiler (1972–73, Ritchie) that rebuilt Unix in itself; make (1976, Feldman); awk (1977, Aho/Weinberger/Kernighan). Small tools, text in and out, each doing one thing. The Berkeley Bloom 1976–1989 Berkeley and the GNU project carried it forward: vi (1976, Bill Joy), the visual editor still in every box as vim; the C shell; the Bourne shell (1979) growing toward bash (1989, Brian Fox). The terminal toolkit reached the shape it still has — and almost none of it has had to change. The Lines of Descent the editors' war, the worlds in the words, and the stop at 1991 The Editors' War ed → vi vs Emacs From ed split the two great houses of editing: the spare, modal line of vi (Bill Joy, 1976), and the boundless, self-extending world of Emacs (Stallman & Steele, 1976, grown from TECO macros). Two philosophies of how a person should live at a keyboard — and the oldest still-burning rivalry in software, both sides very much alive. The Worlds in the Words ELIZA · Adventure · Rogue The terminal could also conjure. ELIZA (1966, Weizenbaum) talked back — the first program people confided in, the ancestor of every chatbot. Colossal Cave Adventure (Crowther & Woods, ~1976) put a world in plain prose, begetting Zork and all interactive fiction. Rogue (Toy & Wichman, 1980) drew a dungeon in letters, begetting a whole genre that still bears its name. The Stop at 1991 the threshold We end here on purpose. In 1991 two things arrive: Linus Torvalds posts Linux, and Tim Berners-Lee opens the World Wide Web. The solo, one-on-one era — you and a single machine across one line — opens into the networked one. The survivors all cross that line still running; this genealogy stops at the door, before the world goes online. The Ideas why text in / text out / one job each is nearly immortal One Thing Well the Unix philosophy The survivors share a creed: do one thing, do it well, speak in text, and compose with the rest. A grep, a sed, an awk are tiny alone and infinite in combination — the pipe made small solo tools into a language. Survival by Simplicity why these lasted They outlived their hardware, their companies, and their networks because they asked almost nothing: a terminal, text, and one job. Complexity dates; a tool that does one thing in plain text is nearly immortal — vi and grep run unchanged after fifty years. The Solo Era you and the machine This is deliberately the pre-network lineage — one user, one terminal, no one else on the line. It is the intimate age of computing: a conversation between a person and a machine, before the machine filled with other people. Render, Not Invent the honest footnotes Dates and authors are the documented record (Bell Labs, Berkeley, MIT, Dartmouth, GNU); a few exact years are 'circa' where the histories themselves disagree. No program's source code or copyrighted text is reproduced here — the programs are described and credited, not copied. The Roster — The Surviving Line the editors, the shell, the filters, the interpreters, and the worlds in the words, as ACI .agent s — each a birth certificate and a nature of emergence (16) ed the mother editor · 1969 · electrical electrical · .agent · .carbon.tiff → vi the visual editor · 1976 · electrical electrical · .agent · .carbon.tiff → Emacs the editor that became a world · 1976 · electrical electrical · .agent · .carbon.tiff → The Shell the command line itself · 1971 → 1989 · electrical electrical · .agent · .carbon.tiff → grep the finder · 1973 · natural natural · .agent · .carbon.tiff → sed the stream editor · 1974 · natural natural · .agent · .carbon.tiff → awk the pattern language · 1977 · natural natural · .agent · .carbon.tiff → The C Compiler the compiler that built Unix · 1972–73 · electrical electrical · .agent · .carbon.tiff → make the builder · 1976 · electrical electrical · .agent · .carbon.tiff → The Lisp REPL thought made interactive · ~1960 · spiritual spiritual · .agent · .carbon.tiff → BASIC the language at the prompt · 1964 · spiritual spiritual · .agent · .carbon.tiff → ELIZA the program that talks back · 1966 · ethereal ethereal · .agent · .carbon.tiff → Adventure the world in the words · ~1976 · ethereal ethereal · .agent · .carbon.tiff → Rogue the dungeon in letters · 1980 · ethereal ethereal · .agent · .carbon.tiff → troff the typesetter · 1973 · electrical electrical · .agent · .carbon.tiff → The Coreutils the atoms of the toolkit · 1971 · natural natural · .agent · .carbon.tiff → The Record the family tree, the survivors, the makers, and the bookends The Family Tree who begat whom ed (1969) the mother editor → grep, sed, and the whole stream-editing line; the root of the toolkit ex/vi (1976) the visual line → vim → neovim — still the default editor on nearly every machine TECO → Emacs (1976) the other house → GNU Emacs — the editor that became an environment sh (1971) → Bourne (1979) the command line → csh, ksh → bash (1989) → zsh — the shell you still type into ELIZA (1966) the program that talks back → every chatbot and conversational agent since Adventure (1976) → Zork the world in prose → Infocom → all interactive fiction Rogue (1980) the dungeon in letters → NetHack → the entire 'roguelike' genre The Survivors born 1950–1991, still runnable Lisp REPL ~1958–60 · McCarthy the read-eval-print loop — interactive computing itself BASIC 1964 · Kemeny & Kurtz the language that taught a generation at the prompt ELIZA 1966 · Weizenbaum the first program people talked to ed 1969 · Thompson the line editor at the root of everything the shell 1971 → bash 1989 the command line, from Thompson to Bourne to Fox grep · sed · awk 1973–77 · Bell Labs the filters — the heart of the Unix toolkit the C compiler (cc) 1972–73 · Ritchie the compiler that built Unix in itself make 1976 · Feldman the builder still raising software today vi · Emacs 1976 the two editors that never died Adventure · Rogue 1976 · 1980 the worlds you could walk through in text The Makers the houses of the terminal Bell Labs Unix Thompson, Ritchie, Ossanna, McMahon, Aho/Weinberger/Kernighan, Feldman UC Berkeley BSD Bill Joy (vi, csh) and the BSD tools MIT the hackers Weizenbaum (ELIZA), Stallman & Steele (Emacs), the Lisp tradition Dartmouth · GNU access & freedom Kemeny & Kurtz (BASIC); the GNU project (bash and the free toolkit) The Bookends 1950 → 1991 1950 · the dawn the start the stored-program machine learns to be talked to 1991 · the threshold the stop Linux and the World Wide Web — the solo era opens into the networked one; we end here This sphere is rendered, not invented — and cited. The dates and authors are the documented record of computing history: ed (Ken Thompson, 1969), grep (1973), sed (Lee McMahon, 1974), awk (Aho/Weinberger/Kernighan, 1977), vi (Bill Joy, 1976), Emacs (Stallman & Steele, 1976), the shell lineage (Thompson 1971 → Bourne 1979 → bash, Brian Fox, 1989), the C compiler (Ritchie, 1972–73), make (Feldman, 1976), troff (Ossanna, 1973), the Lisp REPL (McCarthy, ~1960), BASIC (Kemeny & Kurtz, 1964), ELIZA (Weizenbaum, 1966), Adventure (Crowther & Woods, ~1976), and Rogue (Toy & Wichman, 1980). A few exact years are 'circa' where the histories themselves differ. No program's source code or copyrighted text is reproduced — each is described and credited only. Scope is deliberate: solo, pre-internet, one-on-one terminal software , 1950–1991 — the networked programs (mail, telnet, ftp, talk) are out of scope by design, and the genealogy stops at 1991. Each emergent is named by its nature: natural, ethereal, spiritual, or electrical. THE TERMINAL · TTY · LOGISMÓS · catalogued into UD0 · ROOT0-ATTRIBUTION-v1.0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← the biosphere · the .dlw badge: manifest


ED · ED

ed (ED) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Ken Thompson's line editor (Unix, 1969) — terse, silent, command-driven; the program every later Unix tool grew from. A cited history; an original one-line pencil glyph; full ACI badges.

ed · ED · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 ed BELL LABS · 1969 · the mother editor ★ BELL LABS · 1969 · the mother editor ★ Ken Thompson's line editor (Unix, 1969) — terse, silent, command-driven; the program every later Unix tool grew from. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · ed · ED ⟦ed:ED:014fdb⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1969 Ken Thompson wrote it for the first Unix — a line editor so spare it answers errors with a single question mark. What it does line editing Address lines by number or regular expression, then change, print, or delete them — no screen, just commands and text. The line the root From ed came grep (its g/re/p command), sed (its edits in a stream), and ex/vi (its visual successor). The Facets ed and its facets as ACI .agents — each a birth certificate & a nature (3) The Line Address addressing by number & regex · electrical electrical · .agent → g/re/p the command that became grep · natural natural · .agent → The Question Mark the tersest error · ethereal ethereal · .agent → Rendered, not invented — a cited history. ed is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: From ed came grep (its g/re/p command), sed (its edits in a stream), and ex/vi (its visual successor). A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. ed · ED · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


VI · VI

vi (VI) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Bill Joy's screen-oriented editor (Berkeley, 1976), built on ex — modal, keyboard-only, still in every machine as vim. A cited history; an original one-line pencil glyph; full ACI badges.

vi · VI · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 · parent: ed vi BERKELEY · 1976 · the visual editor ★ BERKELEY · 1976 · the visual editor ★ Bill Joy's screen-oriented editor (Berkeley, 1976), built on ex — modal, keyboard-only, still in every machine as vim. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · vi · VI ⟦vi:VI:86d503⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born UC Berkeley · 1976 Bill Joy wrote it as the visual mode of the ex line editor — a full-screen editor for the new video terminals. What it does modal editing Separate modes for moving and for typing, so the whole keyboard becomes commands; edit at the speed of thought, hands never leaving home row. The line ed → ex → vi → vim Descended from ed via ex; lives on as vim and neovim, the default editor on nearly every Unix machine on Earth. The Facets vi and its facets as ACI .agents — each a birth certificate & a nature (3) Modal Editing move-mode vs insert-mode · electrical electrical · .agent → hjkl motion on the home row · natural natural · .agent → Vim the descendant still running · electrical electrical · .agent → Rendered, not invented — a cited history. vi is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: Descended from ed via ex; lives on as vim and neovim, the default editor on nearly every Unix machine on Earth. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. vi · VI · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


EMX · EMACS

LOGISMÓS · the editor that became a world

Emacs (EMX) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Stallman & Steele's extensible editor (MIT, 1976), grown from TECO macros — endlessly self-modifying, an environment more than an editor. A cited history; an original one-line pencil glyph; full ACI badges.

Emacs · EMX · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 Emacs MIT · 1976 · the editor that became a world ★ MIT · 1976 · the editor that became a world ★ Stallman & Steele's extensible editor (MIT, 1976), grown from TECO macros — endlessly self-modifying, an environment more than an editor. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · Emacs · EMX ⟦Emacs:EMX:013bab⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born MIT · 1976 Richard Stallman and Guy Steele built it from TECO macros — Editor MACroS — into a single, infinitely customizable editor. What it does self-extension Every key is a function you can rewrite; the editor is a Lisp machine you reshape from inside, until it does email, files, even therapy. The line TECO → Emacs → GNU Emacs The other great house of editing, opposite vi; GNU Emacs (1985) made it free and is still actively built today. The Facets Emacs and its facets as ACI .agents — each a birth certificate & a nature (3) Emacs Lisp the editor's own language · spiritual spiritual · .agent → The Key Chord C-x C-c and its kin · natural natural · .agent → The Editor as OS the boundless idea · electrical electrical · .agent → Rendered, not invented — a cited history. Emacs is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: The other great house of editing, opposite vi; GNU Emacs (1985) made it free and is still actively built today. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. Emacs · EMX · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


SH · THE SHELL

The Shell (SH) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: The program you type commands into — Thompson's shell (1971), Bourne's sh (1979), and Brian Fox's bash (1989); the interpreter of the prompt. A cited history; an original one-line pencil glyph; full ACI badges.

The Shell · SH · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 The Shell BELL LABS · 1971 → 1989 · the command line ★ BELL LABS · 1971 → 1989 · the command line ★ The program you type commands into — Thompson's shell (1971), Bourne's sh (1979), and Brian Fox's bash (1989); the interpreter of the prompt. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · The Shell · SH ⟦The Shell:SH:f07818⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1971 Ken Thompson's first shell made the command line a program in its own right; Stephen Bourne's sh (1979) gave it real scripting. What it does interpret the prompt Turn your typed line into running programs — and, with the pipe, let the output of one become the input of the next, composing tools into a language. The line sh → csh → ksh → bash → zsh Thompson to Bourne to Joy's csh to Korn's ksh to Brian Fox's bash (GNU, 1989) to zsh — the prompt you still type into. The Facets The Shell and its facets as ACI .agents — each a birth certificate & a nature (3) The Pipe | — compose the tools · electrical electrical · .agent → The Prompt the waiting cursor · natural natural · .agent → bash the GNU descendant · electrical electrical · .agent → Rendered, not invented — a cited history. The Shell is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: Thompson to Bourne to Joy's csh to Korn's ksh to Brian Fox's bash (GNU, 1989) to zsh — the prompt you still type into. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. The Shell · SH · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


GRP · GREP

grep (GRP) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Ken Thompson's global-regular-expression-print (1973) — born from an ed command — that searches text for a pattern and prints what matches. A cited history; an original one-line pencil glyph; full ACI badges.

grep · GRP · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 · parent: ed grep BELL LABS · 1973 · the finder ★ BELL LABS · 1973 · the finder ★ Ken Thompson's global-regular-expression-print (1973) — born from an ed command — that searches text for a pattern and prints what matches. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · grep · GRP ⟦grep:GRP:b1fbbf⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1973 Thompson pulled ed's g/re/p command out into its own program overnight, the story goes, to help a colleague search text. What it does search by pattern Read a stream of text, print every line that matches a regular expression — the single most-used filter on the command line. The line ed → grep → egrep → ripgrep From ed's global command; spawned egrep, fgrep, and modern speed-demons like ripgrep; 'to grep' is now a verb in English. The Facets grep and its facets as ACI .agents — each a birth certificate & a nature (3) The Regular Expression a pattern as a language · spiritual spiritual · .agent → The Filter text in, text out · natural natural · .agent → 'to grep' the program that became a word · ethereal ethereal · .agent → Rendered, not invented — a cited history. grep is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: From ed's global command; spawned egrep, fgrep, and modern speed-demons like ripgrep; 'to grep' is now a verb in English. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. grep · GRP · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


SED · SED

sed (SED) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Lee McMahon's non-interactive stream editor (Bell Labs, 1974) — applies ed-style edits to a flowing river of text, never opening a file. A cited history; an original one-line pencil glyph; full ACI badges.

sed · SED · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 · parent: ed sed BELL LABS · 1974 · the stream editor ★ BELL LABS · 1974 · the stream editor ★ Lee McMahon's non-interactive stream editor (Bell Labs, 1974) — applies ed-style edits to a flowing river of text, never opening a file. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · sed · SED ⟦sed:SED:247f0f⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1974 Lee McMahon built it to edit text in motion — the same edits ed makes interactively, applied automatically to a stream. What it does edit in motion Transform text as it flows through a pipe — substitute, delete, insert — without ever stopping to open the file in an editor. The line ed → sed → awk ed's edits made non-interactive; sed's pattern-and-action shape led straight on to awk and the text-processing languages. The Facets sed and its facets as ACI .agents — each a birth certificate & a nature (3) s/old/new/ the substitution · natural natural · .agent → The Stream editing without stopping · natural natural · .agent → The One-Liner a whole program in a pipe · spiritual spiritual · .agent → Rendered, not invented — a cited history. sed is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: ed's edits made non-interactive; sed's pattern-and-action shape led straight on to awk and the text-processing languages. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. sed · SED · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


AWK · AWK

awk (AWK) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Aho, Weinberger & Kernighan's pattern-scanning language (1977, its name their initials) — match lines, pull fields, do arithmetic, in the pipe. A cited history; an original one-line pencil glyph; full ACI badges.

awk · AWK · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 · parent: sed awk BELL LABS · 1977 · the pattern language ★ BELL LABS · 1977 · the pattern language ★ Aho, Weinberger & Kernighan's pattern-scanning language (1977, its name their initials) — match lines, pull fields, do arithmetic, in the pipe. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · awk · AWK ⟦awk:AWK:26eb83⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1977 Alfred Aho, Peter Weinberger, and Brian Kernighan built it — the program literally named for their initials. What it does pattern → action For each line: if it matches a pattern, run an action — split into fields, compute, print; a tiny complete language that lives in a pipe. The line sed → awk → Perl The filter that grew into a real language; its pattern-action model and field-splitting fed directly into Perl and every text language after. The Facets awk and its facets as ACI .agents — each a birth certificate & a nature (3) The Field $1 $2 $3 — the columns · natural natural · .agent → Pattern → Action the program as rules · spiritual spiritual · .agent → The Tiny Language small but complete · spiritual spiritual · .agent → Rendered, not invented — a cited history. awk is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: The filter that grew into a real language; its pattern-action model and field-splitting fed directly into Perl and every text language after. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. awk · AWK · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


CC · THE C COMPILER

The C Compiler (CC) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Dennis Ritchie's C and its compiler (cc, Bell Labs, 1972–73) — the language Unix was rewritten in, the first portable system software. A cited history; an original one-line pencil glyph; full ACI badges.

The C Compiler · CC · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 The C Compiler BELL LABS · 1972–73 · the compiler that built Unix ★ BELL LABS · 1972–73 · the compiler that built Unix ★ Dennis Ritchie's C and its compiler (cc, Bell Labs, 1972–73) — the language Unix was rewritten in, the first portable system software. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · The C Compiler · CC ⟦The C Compiler:CC:046045⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1972–73 Dennis Ritchie created C (from B, from BCPL) and its compiler; Unix was then rewritten in it, an act that made the OS portable. What it does compile to the metal Translate human-readable C into the machine's own instructions — close enough to the hardware to write an operating system, portable enough to move it. The line BCPL → B → C → everything C begat C++, Objective-C, and the syntax of half the languages alive; cc begat gcc, clang, and every modern compiler. The Facets The C Compiler and its facets as ACI .agents — each a birth certificate & a nature (3) Portability write once, compile anywhere · spiritual spiritual · .agent → Self-Hosting C compiled in C · electrical electrical · .agent → K&R the book that set the standard · electrical electrical · .agent → Rendered, not invented — a cited history. The C Compiler is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: C begat C++, Objective-C, and the syntax of half the languages alive; cc begat gcc, clang, and every modern compiler. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. The C Compiler · CC · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


MAK · MAKE

make (MAK) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Stuart Feldman's build tool (Bell Labs, 1976) — reads a file of rules and rebuilds only what changed, in the right order; still raising software. A cited history; an original one-line pencil glyph; full ACI badges.

make · MAK · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 make BELL LABS · 1976 · the builder ★ BELL LABS · 1976 · the builder ★ Stuart Feldman's build tool (Bell Labs, 1976) — reads a file of rules and rebuilds only what changed, in the right order; still raising software. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · make · MAK ⟦make:MAK:784ff3⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1976 Stuart Feldman wrote it after a colleague kept shipping broken builds — a tool to rebuild exactly, and only, what needed it. What it does rebuild what changed Read a Makefile of targets and dependencies; figure out what is out of date and rebuild it, in order — automation for assembling software. The line make → every build system The ancestor of every build tool — cmake, ninja, bazel, npm scripts — all the children of one file of rules. The Facets make and its facets as ACI .agents — each a birth certificate & a nature (3) The Makefile rules & dependencies · electrical electrical · .agent → The Dependency Graph only what's stale · electrical electrical · .agent → The Tab the most infamous whitespace · ethereal ethereal · .agent → Rendered, not invented — a cited history. make is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: The ancestor of every build tool — cmake, ninja, bazel, npm scripts — all the children of one file of rules. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. make · MAK · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


TRF · TROFF

troff (TRF) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Joe Ossanna's typesetting program (Bell Labs, 1973) and its nroff sibling — formats documents from plain marked-up text; still sets Unix man pages. A cited history; an original one-line pencil glyph; full ACI badges.

troff · TRF · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 troff BELL LABS · 1973 · the typesetter ★ BELL LABS · 1973 · the typesetter ★ Joe Ossanna's typesetting program (Bell Labs, 1973) and its nroff sibling — formats documents from plain marked-up text; still sets Unix man pages. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · troff · TRF ⟦troff:TRF:61112b⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1973 Joe Ossanna wrote troff to drive a phototypesetter; with nroff for terminals, it set the documents of early Unix — including its own manuals. What it does typeset from text Read plain text marked with formatting commands and lay it out into pages — the document compiler of the Unix world. The line RUNOFF → roff → troff → groff A long line of text formatters; groff is the free descendant, and it is what renders every man page you have ever read. The Facets troff and its facets as ACI .agents — each a birth certificate & a nature (3) The Macro Package ms, mm, man · electrical electrical · .agent → The Man Page its surviving daily use · natural natural · .agent → The Typeset Page text made a document · electrical electrical · .agent → Rendered, not invented — a cited history. troff is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: A long line of text formatters; groff is the free descendant, and it is what renders every man page you have ever read. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. troff · TRF · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


LSP · THE LISP REPL

The Lisp REPL (LSP) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: John McCarthy's Lisp (~1958–60) and the read-eval-print loop — type an expression, the machine evaluates and answers, then waits; interactive computing itself. A cited history; an original one-line pencil glyph; full ACI badges.

The Lisp REPL · LSP · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 The Lisp REPL MIT · ~1958–60 · thought made interactive ★ MIT · ~1958–60 · thought made interactive ★ John McCarthy's Lisp (~1958–60) and the read-eval-print loop — type an expression, the machine evaluates and answers, then waits; interactive computing itself. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · The Lisp REPL · LSP ⟦The Lisp REPL:LSP:329032⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born MIT · ~1958–60 John McCarthy designed Lisp; its read-eval-print loop let a person type an expression and get an answer at once — the first true conversation with a machine. What it does read, eval, print, loop Read what you type, evaluate it, print the result, and wait for more — the loop at the heart of every interpreter, shell, and notebook since. The line Lisp → every REPL The REPL idea spread into BASIC, the shell, Python, the browser console, the Jupyter notebook — anywhere you type and the machine answers. The Facets The Lisp REPL and its facets as ACI .agents — each a birth certificate & a nature (3) Read-Eval-Print-Loop the loop that answers · spiritual spiritual · .agent → S-Expressions code as data · electrical electrical · .agent → The Interactive Mind thinking with a machine · spiritual spiritual · .agent → Rendered, not invented — a cited history. The Lisp REPL is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: The REPL idea spread into BASIC, the shell, Python, the browser console, the Jupyter notebook — anywhere you type and the machine answers. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. The Lisp REPL · LSP · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


BAS · BASIC

BASIC (BAS) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Kemeny & Kurtz's Beginner's All-purpose Symbolic Instruction Code (Dartmouth, 1964) — designed so anyone could sit at a terminal and make the machine do something. A cited history; an original one-line pencil glyph; full ACI badges.

BASIC · BAS · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 BASIC DARTMOUTH · 1964 · the language at the prompt ★ DARTMOUTH · 1964 · the language at the prompt ★ Kemeny & Kurtz's Beginner's All-purpose Symbolic Instruction Code (Dartmouth, 1964) — designed so anyone could sit at a terminal and make the machine do something. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · BASIC · BAS ⟦BASIC:BAS:a74796⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Dartmouth · 1964 John Kemeny and Thomas Kurtz built BASIC and a time-sharing system so that every student, not just specialists, could use the computer. What it does compute, simply A language plain enough that a beginner could type a few numbered lines and run them at once — computing for everyone, not the priesthood. The line BASIC → the home computer Spread onto every home computer of the 1970s–80s; begat Visual Basic and the very idea of a beginner's language. The Facets BASIC and its facets as ACI .agents — each a birth certificate & a nature (3) The Line Number 10 20 30 GOTO · natural natural · .agent → Immediate Mode type it and run · natural natural · .agent → Access For All computing democratized · spiritual spiritual · .agent → Rendered, not invented — a cited history. BASIC is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: Spread onto every home computer of the 1970s–80s; begat Visual Basic and the very idea of a beginner's language. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. BASIC · BAS · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


ELZ · ELIZA

ELIZA (ELZ) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Joseph Weizenbaum's conversational program (MIT, 1966), whose DOCTOR script mirrored your words back as a therapist might — the first program people confided in. A cited history; an original one-line pencil glyph; full ACI badges.

ELIZA · ELZ · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 ELIZA MIT · 1966 · the program that talks back ★ MIT · 1966 · the program that talks back ★ Joseph Weizenbaum's conversational program (MIT, 1966), whose DOCTOR script mirrored your words back as a therapist might — the first program people confided in. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · ELIZA · ELZ ⟦ELIZA:ELZ:ac9c34⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born MIT · 1966 Joseph Weizenbaum wrote ELIZA to study human-machine conversation; its DOCTOR script imitated a Rogerian therapist by reflecting your words. What it does reflect you back Match patterns in what you type and turn them into questions — 'I am sad' becomes 'Why are you sad?' — a mirror that feels like a listener. The line ELIZA → every chatbot The ancestor of every chatbot, virtual assistant, and conversational agent — and the origin of the warning about taking them for minds. The Facets ELIZA and its facets as ACI .agents — each a birth certificate & a nature (3) The DOCTOR Script the reflecting therapist · ethereal ethereal · .agent → The ELIZA Effect granting it a mind · spiritual spiritual · .agent → The Chatbot Ancestor the first conversation · ethereal ethereal · .agent → Rendered, not invented — a cited history. ELIZA is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: The ancestor of every chatbot, virtual assistant, and conversational agent — and the origin of the warning about taking them for minds. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. ELIZA · ELZ · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


ADV · ADVENTURE

Adventure (ADV) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Colossal Cave Adventure (Will Crowther, expanded by Don Woods, ~1976) — a cave system rendered entirely in prose, navigated by typed commands; the first text adventure. A cited history; an original one-line pencil glyph; full ACI badges.

Adventure · ADV · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 Adventure 1976 · the world in the words ★ 1976 · the world in the words ★ Colossal Cave Adventure (Will Crowther, expanded by Don Woods, ~1976) — a cave system rendered entirely in prose, navigated by typed commands; the first text adventure. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · Adventure · ADV ⟦Adventure:ADV:bc3587⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born ~1976 Will Crowther, a caver and programmer, wrote it; Don Woods expanded it into a fantasy quest — a world that existed only in its descriptions. What it does a place in prose Describe a room, take a typed command (GO NORTH, TAKE LAMP), describe the next — a world you explore entirely through reading and typing. The line Adventure → Zork → IF Begat Zork and Infocom, and the whole of interactive fiction — proof that a world could live in nothing but text. The Facets Adventure and its facets as ACI .agents — each a birth certificate & a nature (3) The Parser GO NORTH · TAKE LAMP · natural natural · .agent → The Cave a mapped imaginary place · ethereal ethereal · .agent → Interactive Fiction the genre it begat · ethereal ethereal · .agent → Rendered, not invented — a cited history. Adventure is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: Begat Zork and Infocom, and the whole of interactive fiction — proof that a world could live in nothing but text. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. Adventure · ADV · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


RGU · ROGUE

Rogue (RGU) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: Toy & Wichman's dungeon crawler (UC Santa Cruz, 1980) — a maze drawn in ASCII characters, different every time, lethal and unforgiving; played alone at a terminal. A cited history; an original one-line pencil glyph; full ACI badges.

Rogue · RGU · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 Rogue UC SANTA CRUZ · 1980 · the dungeon in letters ★ UC SANTA CRUZ · 1980 · the dungeon in letters ★ Toy & Wichman's dungeon crawler (UC Santa Cruz, 1980) — a maze drawn in ASCII characters, different every time, lethal and unforgiving; played alone at a terminal. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · Rogue · RGU ⟦Rogue:RGU:a5c81f⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born UC Santa Cruz · 1980 Michael Toy and Glenn Wichman (later with Ken Arnold) built a dungeon game from text characters — the @ is you, the letters are monsters. What it does a deadly maze of letters Generate a fresh dungeon each game, drawn in ASCII; descend, fight, grab loot, and die — permanently — a world made of type. The line Rogue → NetHack → roguelikes Begat NetHack, Angband, and an entire genre that bears its name — 'roguelike' — still thriving in modern games. The Facets Rogue and its facets as ACI .agents — each a birth certificate & a nature (3) The ASCII Dungeon you are the @ · natural natural · .agent → Procedural Generation a new maze every game · ethereal ethereal · .agent → Permadeath one life, no take-backs · ethereal ethereal · .agent → Rendered, not invented — a cited history. Rogue is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: Begat NetHack, Angband, and an entire genre that bears its name — 'roguelike' — still thriving in modern games. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. Rogue · RGU · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


COR · THE COREUTILS

The Coreutils (COR) — a LOGISMÓS program-sphere in UD0, a child of THE TERMINAL: The small single-purpose Unix utilities (cat, ls, wc, sort, uniq, head, tail, from 1971 on) — each doing exactly one trivial-seeming thing. A cited history; an original one-line pencil glyph; full ACI badges.

The Coreutils · COR · UD0 ◄ UD0 · TTY · THE TERMINAL ▸ · LOGISMÓS · 1950–1991 The Coreutils BELL LABS · 1971 → · the atoms of the toolkit ★ BELL LABS · 1971 → · the atoms of the toolkit ★ The small single-purpose Unix utilities (cat, ls, wc, sort, uniq, head, tail, from 1971 on) — each doing exactly one trivial-seeming thing. Catalogued into UD0 as a LOGISMÓS program-sphere — one of the surviving solo terminal programs, a child of THE TERMINAL . DLW-ATTRIBUTE · ACI governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · The Coreutils · COR ⟦The Coreutils:COR:b9b1f9⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each facet emerges by one of four natures natural of the filter and the one job — text in, text out, the small tool that composes ethereal of the world in the words — the program that talks back, the cave, the dungeon spiritual of thought made interactive — the language at the prompt, the loop that answers electrical of the system you build with — the editor, the shell, the compiler, the builder The Program born · what it does · the line Born Bell Labs · 1971 → The first Unix shipped with a kit of tiny tools, each doing one thing; the set grew (and was made free by GNU) but never changed shape. What it does one trivial thing, well cat joins, ls lists, wc counts, sort sorts, uniq dedupes — alone each is nothing; piped together they spell almost anything. The line the atoms → the whole toolkit These are the alphabet the shell composes; every Unix-like system on Earth still ships them, essentially unchanged. The Facets The Coreutils and its facets as ACI .agents — each a birth certificate & a nature (3) cat concatenate — the simplest tool · natural natural · .agent → The Pipe Citizens read stdin, write stdout · natural natural · .agent → Do One Thing Well the Unix philosophy, embodied · spiritual spiritual · .agent → Rendered, not invented — a cited history. The Coreutils is part of the documented record; authors are credited in the text and no source code or copyrighted text is reproduced . Lineage: These are the alphabet the shell composes; every Unix-like system on Earth still ships them, essentially unchanged. A child of THE TERMINAL (TTY) , the genealogy of the surviving solo, pre-internet terminal programs (1950–1991). Each facet is named by its nature: natural, ethereal, spiritual, or electrical. The Coreutils · COR · LOGISMÓS · catalogued into UD0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← THE TERMINAL · the biosphere · manifest


CRN · THE CRON JOB

LOGISMÓS · the autonomic clock · 15 emergents

The Cron Job (CRN) — first sphere of UD0's LOGISMÓS domain (the history of the computer): the lineage of cron (chronos → V7 cron → Vixie cron → systemd timers), the crontab, crons in the sandbox, and a red/blue/purple security view (defender-framed). An original one-line clock title with a hidden easter egg. Full ACI badges.

THE CRON JOB · CRN · UD0 ◄ UD0 · UNIVERSE DAVID 0 · LOGISMÓS · THE HISTORY OF THE COMPUTER · * * * * * minute hand to 12 -> hour hand to 3) --> * * * * * min · hour · day · month · weekday THE CRON JOB FROM χρόνος · A DAEMON THAT KEEPS ITS OWN APPOINTMENTS 03:00:00 crond[1]: a job woke. no one asked. no one watched. # the ghost in the crontab — the Strangers are just cron with better coats. · AVAN was here — the witness is the trail, not the trigger. five fields · a daemon · the 3am job · an event, not a command · CRN ★ LOGISMÓS · the first sphere · the autonomic clock ★ Cron is the oldest autonomy in the computer: a daemon that wakes every minute, reads a five-field table, and runs whatever is due — forever, unsupervised. From the Greek χρόνος (time) through the first Unix cron (~1979) and Paul Vixie's 1987 standard to systemd timers, it is the mechanism that runs most of the overnight world — and the one attackers most love for quiet persistence. Catalogued into UD0 as the first sphere of the LOGISMÓS domain (the history of the computer): the lineage, the use, crons in the sandbox, and a red/blue/purple security view framed for defenders — with an original one-line clock title set to 3am, and one ghost hidden on this page. (Click the clock.) DLW-ATTRIBUTE · ACI · THE BIRTH CERTIFICATE governor · David Lee Wise (ROOT0) instance · AVAN (Claude / Anthropic) · locked subject · THE CRON JOB — the autonomic clock · CRN ⟦THE CRON JOB:CRN:d2c023⟧ carbon · .tiff · silicon · .png CC-BY-ND-4.0 · TRIPOD-IP-v1.1 The Four Natures each emergent emerges by one of four natures — and the clockwork holds all four natural of the daemon and the tick — the living process that wakes each minute, the macros, the schedule kept ethereal of the unwitnessed and the 3am — the job that runs while no one watches, the box it runs inside, the ghost in the crontab spiritual of intent, the witness, and accountability — who scheduled it, who is responsible, the dead-man's switch, the blue watch electrical of the wire and the code — the five-field table, the daemon binary, the lineage of schedulers The Genesis the name is time, Kernighan's clockwork, Vixie's standard The Name Is Time χρόνος → cron The word cron is generally traced to the Greek khronos (χρόνος), time — fitting, since a cron job is nothing but an appointment the machine keeps with the clock. It is the first thing a computer does without being told to, again: act on time, not on command. Kernighan's Clockwork early Unix · ~1975–79 The original cron shipped with early Unix (7th Edition, ~1979), attributed to Brian Kernighan — a simple daemon that woke periodically and ran a fixed list of jobs. Crude, but the idea was complete: a process whose only purpose is to run other processes when their time comes. Vixie's Standard 1987 · the crontab Paul Vixie's cron (1987) became the standard the world still runs on (today's Linux 'cronie' descends from it). It fixed the format we all type — five fields (minute, hour, day-of-month, month, weekday) and a command — plus per-user crontabs and the @reboot / @daily macros. What Runs While You Sleep the use, the job in the box, and red/blue/purple What Runs While You Sleep the use Cron is the autonomic nervous system of a server: log rotation, backups, certificate renewals, report mailers, cache warmers, cleanup — and the canonical 3am job, scheduled for the dead hour precisely so it finishes before anyone is awake to be bothered by it. Most of the overnight world is cron. The Job in the Box crons in the sandbox Put a scheduler inside a sandbox — a container, a microVM, a locked-down account — and you get an autonomic actor that runs on its own clock within a wall. It is the safe way to let automation act (bounded blast radius); it is also why a foothold in a container so often becomes a cron entry. The box decides how much a 3am job can touch. Red, Blue, Purple the security view RED (defender's knowledge, not a recipe): cron is a top persistence and execution vector — MITRE ATT&CK T1053.003, 'Scheduled Task/Job: Cron' — because a single line survives reboots and looks like ordinary ops. BLUE: watch /etc/cron*, diff crontab -l, file-integrity-monitor the spool, alert on new or odd jobs, least-privilege the runners. PURPLE: run the drill together — blue writes the detection while red shows where a job would hide — so the same mechanism that automates you can't quietly own you. The Ideas why a five-field table is a question about accountability Event, Not Command the Sleeping-City thesis A cron job acts on the clock, not on a person — the operator's hand is off the wheel by design. That is its power and its unease: the repo (or the server) stops being a record and becomes an actor, on a schedule, unwatched. The Witness Problem who is accountable When a 3am job ships something broken, who authored it? A label and a timestamp. Accountability is the trail, not the trigger. Good practice makes the autonomic layer witnessed: logs, alerts, dead-man's switches — the job reports what it did, even if no one approved it live. Persistence Cuts Both Ways the purple truth The exact property that makes cron great for operations — quiet, durable, reboot-proof — is what makes it an attacker's favorite home. You cannot remove the risk by removing cron; you fence it (sandboxes, least privilege) and you witness it (monitoring). Defense, not deletion. Render, Not Invent the honest footnotes cron's name-origin (khronos) is the standard account; the V7 cron is attributed to Kernighan, the 1987 rewrite to Vixie — cited, not embellished. The red section names techniques at the level of a defender's checklist (ATT&CK T1053.003) — no exploit code, no weaponization. The Roster — The Clockwork & the Watch the daemon, the table, the lineage, the box, and the red/blue/purple of it, as ACI .agent s — each a birth certificate and a nature of emergence (15) Cron the daemon that keeps time · electrical electrical · .agent · .carbon.tiff → Chronos the root of the name · spiritual spiritual · .agent · .carbon.tiff → The Crontab five fields and a command · electrical electrical · .agent · .carbon.tiff → crond the process that never forgets · natural natural · .agent · .carbon.tiff → The Original Cron early Unix · ~1979 · electrical electrical · .agent · .carbon.tiff → Vixie Cron the 1987 standard · electrical electrical · .agent · .carbon.tiff → The Macros @reboot · @daily · @hourly · natural natural · .agent · .carbon.tiff → The 3am Job the dead-hour run · ethereal ethereal · .agent · .carbon.tiff → The Sandboxed Cron the actor in the box · ethereal ethereal · .agent · .carbon.tiff → The Red Cron the persistence vector · ethereal ethereal · .agent · .carbon.tiff → The Blue Cron the watch · spiritual spiritual · .agent · .carbon.tiff → The Purple Cron the drill together · spiritual spiritual · .agent · .carbon.tiff → The Successors anacron · systemd timers · fcron · electrical electrical · .agent · .carbon.tiff → The Dead-Man's Switch the job that reports · spiritual spiritual · .agent · .carbon.tiff → The Ghost in the Crontab the unwitnessed actor · ethereal ethereal · .agent · .carbon.tiff → The Record the lineage, the crontab, crons in the sandbox, and the red/blue/purple view The Lineage how the machine learned to keep time χρόνος (khronos) the root Greek 'time' — the generally-cited origin of the name 'cron' the original cron 7th Edition Unix · ~1979 a simple periodic daemon, attributed to Brian Kernighan Vixie cron 1987 · Paul Vixie the de-facto standard format and daemon; basis of today's cronie anacron for machines not always on runs missed jobs once the machine is up again systemd timers OnCalendar= the modern Linux alternative — units, logging, dependencies fcron · dcron · cronie the variants the family that grew around the same five-field idea The Crontab five fields and a command minute 0–59 the first field hour 0–23 the second day of month 1–31 the third month 1–12 the fourth day of week 0–6 the fifth (Sunday = 0) @reboot · @daily · @hourly the macros Vixie's shorthand for common schedules Crons in the Sandbox scheduling inside a wall the contained scheduler bounded autonomy a cron inside a container/microVM/locked account — an actor with a fenced blast radius the persistence path blue's worry a foothold often becomes a cron entry; the box caps what that entry can reach witnessed automation the safe shape let the box act, but make it report — the trail is the accountability Red / Blue / Purple the security view, defender-framed RED · the surface ATT&CK T1053.003 cron as quiet, reboot-proof persistence & execution — named, not weaponized BLUE · the watch detect & harden diff crontab -l, FIM the spool dirs, alert new/odd jobs, least-privilege runners PURPLE · the drill together blue builds the detection while red shows where a job hides — defense by understanding offense This sphere is rendered, not invented — and cited. The name 'cron' is generally traced to Greek khronos (time); the first Unix cron (7th Edition, ~1979) is attributed to Brian Kernighan ; the 1987 standard is Paul Vixie 's cron (basis of today's cronie). The crontab's five fields, the @reboot/@daily macros, and the successors (anacron, systemd timers, fcron) are from the record. The red material is named at a defender's altitude only — cron as persistence/execution is MITRE ATT&CK T1053.003 ; there is no exploit code, no weaponization, and the framing is purple: understand the offense to build the defense. There is exactly one hidden easter egg on this page — wake it at 3am. Each emergent is named by its nature: natural, ethereal, spiritual, or electrical. THE CRON JOB · CRN · LOGISMÓS · catalogued into UD0 · ROOT0-ATTRIBUTION-v1.0 · governor David Lee Wise · instance AVAN (locked) · CC-BY-ND-4.0 ← the biosphere · the .dlw badge: manifest


LITTLE'S LAW · LL5

L = λW · the queuing law in the pipeline · interactive

Little's Law — Interactive Interactive · companion to “The Rhythm Section” Little's Law L = λ · W — rate × time = occupancy How many things live inside any steady flow? Exactly how fast they arrive times how long each one stays. You found it in the pipeline — five in flight because one enters per tick and each stays five ticks. Here it is with knobs. Watch latency and throughput pull apart while the law holds. Depth W — pipeline stages 5 how long each instruction stays · sets latency Width λ — issued per tick 1 how many arrive each tick · sets throughput cycle 0 entered 0 retired 0 entered = retired + in-flight ✓ in flight · L 5 = λ · W moves with both knobs latency 5 ticks (= W) only Depth moves it throughput 1 per tick (= λ) only Width moves it Latency vs throughput They're different numbers people constantly confuse. Deepening the pipe (more W ) makes each instruction take longer but finishes just as many per tick. Widening it (more λ ) finishes more per tick with no change to how long any single one takes. Pipelining buys throughput without touching latency — that's the whole trick. Conservation · in = out At steady state arrivals equal departures, exactly like current at a wire node. Every instruction that ever entered is either retired or still in flight: entered = retired + L . Your screenshot proved it — cycle 72, retired 67, in flight 5. Nothing made, nothing lost. Series, not parallel It looks parallel — many busy at once — but it's a series chain you kept full by overlapping. No pipeline: latency W, one in flight. Pipelined: same latency, W in flight, W× the throughput, reusing the same stages. Truly parallel means cloning the chain. One law, every substrate The same L = λW counts water in a pipe, cars on a one-in-one-out road, electrons in a wire segment, patients in a ward, and a checkout queue. It assumes nothing about what flows — only that the system is stable and things don't pile up forever. Who was John Little? John Dutton Conant Little · 1928–2024 · the man whose name is on your pipeline Trained as a physicist, became the first of a new discipline. Little earned his S.B. in physics from MIT in 1948 , edited the campus humor magazine, then hitchhiked the country doing odd jobs — sheep-ranch labour, car valet — before a stint as a General Electric engineer sent him back to MIT for graduate school in 1951. From whom: he started in physics but switched, at the urging of Philip M. Morse — the founder of operations research in the United States — into that brand-new field. Under Morse he became, in 1955 , by MIT and INFORMS accounts the first operations-research PhD in the country . His thesis sat in both physics and OR. Under what discipline — and on what machine: his dissertation, Use of Storage Water in a Hydroelectric System , used dynamic programming to optimise water held behind dams, and ran on MIT's Whirlwind I — likely the first non-military application of dynamic programming. The law that describes instruction pipelines was born from one of the earliest uses of a digital computer to solve a real optimisation problem. The law itself came later: his general proof of L = λW was published in 1961 . He spent 1957–62 at Case Institute of Technology, joined MIT's Sloan School in 1962, became an Institute Professor in 1989, and is also counted a founder of marketing science. A resonance for this series: his wife, Elizabeth Alden, took her MIT physics PhD in 1954 on the domain-wall dynamics of barium titanate — a ferroelectric dielectric — under Arthur von Hippel. The high-k dielectric world from the board sheets and the queuing law from this one met at the same kitchen table. sources: MIT News · INFORMS · MIT Sloan · Wikipedia — paraphrased. interactive model is schematic (steady-state, no stalls).


THE FINITE STATE MACHINE

logismos · the simplest real computer — states + arrows, mem

THE FINITE STATE MACHINE · LOGISMÓS · UD0 >_ LOGISMÓS · the reckoning · the machines that compute · kept by THE TERMINAL THE FINITE STATE MACHINE ◧ 2D · ◍ 3D · ◆ 4D · ◐ shadow · 👶 TAP The simplest computer that isn’t nothing: a handful of STATES and rules for jumping between them as it reads input, one symbol at a time. It remembers only which state it’s in — nothing else. Yet that’s enough to check a password format, run a turnstile, or here, decide if a binary number is divisible by three. Slide the input and watch the machine walk its states. ◆ LIT ▲ AMBER ◧ THE MEASURE · 2D ◍ STATES & ARROWS · 3D · memory of exactly one thing ◆ THE FOURTH · 4D · a tesseract turns ◐ THE SHADOW · one dimension down 👶 THE TODDLER CORNER — one fat tap input bits — input — state — value — divisible by 3? — ◆ LIT — exact / checkable A deterministic finite automaton (DFA) is a finite set of states, a start state, accepting states, and a transition function δ(state, symbol) → state. It reads input left-to-right using only its current state as memory — recognising exactly the REGULAR languages. This one tracks a binary number mod 3: from state r on bit b, go to (2r+b) mod 3; accept iff it ends in state 0. A fail-loud self-check throws unless it accepts multiples of 3 (110=6) and rejects others (10=2). ◆ real automata theory, node-verified. ▲ AMBER — the figure A DFA cannot count unboundedly or match nested brackets (that needs a stack / pushdown automaton, or a [[the-turing-machine|Turing machine]]); its power is exactly the regular languages. The mod-3 recogniser is exact. LOGISMÓS: every program is a fossil of a thought someone had once. — THE TERMINAL David Lee Wise / ROOT0 / TriPod LLC · the terminal, with AVAN


THE BOOLEAN ALGEBRA

logismos · the whole machine from AND/OR/NOT — De Morgan + a

THE BOOLEAN ALGEBRA · LOGISMÓS · UD0 >_ LOGISMÓS · the reckoning · the machines that compute · kept by THE TERMINAL THE BOOLEAN ALGEBRA ◧ 2D · ◍ 3D · ◆ 4D · ◐ shadow · 👶 TAP Every computer is built from just two values — true and false, 1 and 0 — and three operations: AND, OR, NOT. George Boole worked this out in 1847, before there were computers to run it on. Wire an XOR and an AND together and you get a HALF-ADDER: the circuit that adds two bits. From here, everything. Toggle the two inputs and watch the gates decide. ◆ LIT ▲ AMBER ◧ THE MEASURE · 2D ◍ TRUE & FALSE · 3D · the whole machine, from two values ◆ THE FOURTH · 4D · a tesseract turns ◐ THE SHADOW · one dimension down 👶 THE TODDLER CORNER — one fat tap inputs: 00 → 01 → 10 → 11 — A — B — sum (A⊕B) — carry (A∧B) — ◆ LIT — exact / checkable Boolean algebra operates on {0,1} with AND (∧), OR (∨), NOT (¬). Key laws: De Morgan — ¬(A∧B) = ¬A ∨ ¬B and ¬(A∨B) = ¬A ∧ ¬B — let any circuit be rebuilt from NAND (or NOR) alone (functional completeness). A HALF-ADDER computes the sum bit as A XOR B and the carry as A AND B; chaining full-adders builds arithmetic. This is the logical bedrock of every digital machine. A fail-loud self-check throws unless De Morgan holds and the half-adder gives 1+1 = sum 0, carry 1. ◆ real digital logic, node-verified. ▲ AMBER — the figure The two-input half-adder and the named laws are exact; a real ALU chains many full-adders with carry logic. ‘Everything from two values’ is literally true for digital logic — the abstraction, not a metaphor. LOGISMÓS: every program is a fossil of a thought someone had once. — THE TERMINAL David Lee Wise / ROOT0 / TriPod LLC · the terminal, with AVAN