Notes · Languages · Interactive

From Machine Code to AI: the Same Hello World

August 1, 2026 · Jacob Stephens · ~2,200 words · 8 abstraction bands · 32 variants · reading this as an AI agent? agents.md is for you

Every major level of programming is a response to the pain of the level beneath it. Plugboards made stored programs necessary; numeric opcodes made mnemonics necessary; hand assembly made formula translation necessary; languages that could not own kernels made systems languages necessary; unchecked memory made managed runtimes and ownership types necessary; ceremony made scripting necessary; writing every line by hand made model interfaces necessary. Abstractions accumulate rather than replace - ELF still packages machine words; C still underpins kernels; a prompt still bottoms out in addressable memory.

This page is a museum of source shape, not a syntax leaderboard. The interesting part is not that each layer can print a greeting - it is what the source still names, what it hides, and which pain forced that layer into existence. Fig. 1 shows one signature language per band; Fig. 2 compares any pair; Fig. 3 walks the full ladder with history, source, shell one-liner, and optional run. Assembly here is x86_64 Linux GAS (not Apple Silicon ARM64). Running is verification on this host; highlight.js 11.11.1 styles the panels.

Throughline: "Hello world" is a moving target. Early first programs were sums, squares, and tables - not teletype greetings - until Kernighan's 1970s Bell Labs tutorials freeze the convention, and until 2022 when the greeting can be a contract with a model.

Checking runner…

The exhibit

Start with the sources. History, portraits, and the runner story come after.

Fig. 1 · One signature language per level

Eight bands in a 4×2 grid. Chips under each band list every peer - click a chip (or the card) to switch. The shown source also loads into Fig. 2’s left pane.

Signatures: absolute words · hand-entered hex · Assembly · FORTRAN · C · Rust · Python · AI Engineering tight contract (vibe peer on the same L7 carousel).

Fig. 2 · Compare any two side by side

How much of the machine is still visible? What is named, what is hidden? Defaults: C next to Python.

Shell one-liners under each pane use programs/ basenames - teach-yourself-local, not the server cache paths.

Fig. 3 · Walk the ladder

Each band: origin story, source, shell line (when applicable), optional run. Multi-language bands use ‹ › or arrow keys after you focus a rung. Primers on registers and variables sit before the first rungs that need them.

Loading host hardware…

Samples per language

Aggregate timings from every Run once / Run Program / Benchmark on this host. No IPs or personal data. Click column headers to sort.

Loading historical stats…

Framing history

Robert C. Martin (Uncle Bob) treats programming history as a climb through successive tools - machine code, assembly, high-level languages, and what comes next - while craft still matters at every height. That is the spine of his 2016 talk The Future of Programming (also The Clean Coder, 2011). Bands here are ordered by abstraction, not pure release-year purity (Lisp is older than C; scripting largely overlaps managed systems - a parallel branch). Years on variants are introduction years.

Martin also names Alan Turing's ACE work as early code a modern programmer would still recognize - "you would not like it, but you would recognize it." The archival anchor is the 1945/46 NPL report Proposed Electronic Calculator: stored-program design, BURY/UNBURY subsidiaries, sample instruction tables. Pilot ACE first ran 10 May 1950.

Fig. · Turing ACE · INDEXIN (popular form, 1945)

Portrait of Alan Turing as a teenager, circa 1928–1929 — Alan Turing
c. 1928–29 · public domain

INDEXIN

 1     Q, 0000,0100,0000,0000     2
 2           TS 6 - TS 2          3
 3           ADD 'A'              4
 4           ROTATE 16            5
 5           TS 4 - TS 6          6
 6           TS 6 - TS 9          7
 7           TS 27 - TS 6         8
 8           TS 6 - TS 10         9
 9                OR             10
10           TS 8 - TS 6         11
11           B,1, INDEXIN 11
12           TS 6 - TS 28        13
13           B, BURY

Authentic "popular form" instruction table from A. M. Turing, Proposed Electronic Calculator (NPL ACE report, late 1945; presented 1946), chapter 13 - "Examples of Instruction Tables." Columns: instruction name, abbreviated CA operation or type-B jump, next instruction. TS = temporary storage; B, BURY starts a subsidiary (subroutine return stack). Not Hello World - INDEXIN fetches a minor cycle by address written in TS 27. Full INDEXIN + abbreviated CALPOL (polynomial evaluation with BURY/UNBURY) also live as the Turing ACE peer under Absolute machine program in the ladder. ACE text: public domain (UK Crown) - Wikisource ch. 13; NPL scan: turing-proposal PDF. Portrait: public domain (Wikimedia Commons, Alan Turing Aged 16).

Absolute machine program (c. 1945) - ENIAC plugboards; Turing ACE; von Neumann EDVAC draft. Pivot: put the program in memory.
Machine code (late 1940s) - instruction words as data (Manchester Baby, 1948); paper tape and cards.
Assembly (c. 1949) - EDSAC initial orders; registers and memory labels named; not modern variables yet.
Early high-level (1957–1959) - FORTRAN, Lisp, COBOL. Variables as named values; registers leave the source.
Systems (1970–1985) - Pascal, C, Objective-C, C++. Greeting freezes - Kernighan B 1972 / K&R 1978.
Managed / safe (1995–2015) - Java, C#, Visual Basic, Kotlin, Dart, Go, Swift, Rust, Lean. GC, ownership, proofs.
Scripting (1987–1995) - Bash, Perl, Python, R, PHP, JS, Ruby, SQL. Parallel branch: glue, stats, queries, and the web.
AI Engineering (2022–) - tight contract vs vibe prompt on the same capability surface.

Capability vs convention: stored-program machines could print characters long before "hello, world" was a ritual (Kernighan B 1972; K&R 1978). Early carousels therefore pair a continuity Hello with period-honest jobs like SUM=55.

Fig. · Key people

Two women operating the ENIAC, adjusting cables and switches on the machine panels, 1946 — ENIAC programmers at the panels Absolute machine program · plugboards and switches, 1946. Often identified with the original six (including Holberton and Bartik). Public domain (U.S. Army).

Portrait of Alan Turing as a teenager — Alan Turing ACE report, 1945/46 · first code a modern programmer still recognizes (Martin). Public domain.

Portrait of John von Neumann — John von Neumann EDVAC draft, June 1945 · stored program as the architecture almost everyone followed. Los Alamos / LANL historic photo.

Portrait of Grace Hopper in U.S. Navy uniform — Grace Hopper FLOW-MATIC lineage into COBOL · English-like business records. Public domain (U.S. Navy, 1984).

Portrait of John McCarthy — John McCarthy Lisp, 1958 · lists, recursion, garbage collection for symbolic AI. CC BY-SA 2.0 (null0 / Flickr).

Portrait of Dennis Ritchie — Dennis Ritchie C and Unix at Bell Labs · where the greeting freezes for half a century. CC BY 2.0 (Denise Panyik-Dale).

Faces for the hinge points of the ladder - not a complete hall of fame (Backus, Wilkes, Kernighan, Gosling, and others appear in the prose and Sources without free-to-host portraits here). Images via Wikimedia Commons; licenses noted under each name. Preferring public-domain and clearly attributed Creative Commons photographs only.

Fig. · Punch card (80 columns)

Blue IBM-style 80-column punch card with rectangular holes and printed characters along the top edge

Source and data decks lived on paper like this. The Machine code band's punch-card slide is a teaching sheet, not a live reader. Photo: public domain (Wikimedia Commons).

How the host stays boring

Fig. · Runner constraints

Allowlisted language ids only - no user-supplied source, argv, or env.
Build once into cache/, hard timeouts, loopback bind, rate limits.
AI / vibe rungs call live GPT-5.6 Luna; successive Run once clicks keep replies this session so non-determinism is visible.

If a demo needs to be interesting, the security story should stay dull.

Takeaways

Source shape is the lesson - Fig. 1–3 are the museum; run is optional proof on Linux x86_64. The ladder includes every TIOBE top-10 language (Python, C, C++, Java, C#, JavaScript, Visual Basic, SQL, R, Rust) plus history peers.
Registers ≠ variables - Assembly names chip slots and addresses; FORTRAN-era languages name values in the problem.
Capability ≠ convention - printing text is old; the Hello World ritual is 1970s.
Scripting is a parallel branch - not a strict sequel after ownership types.
What stays constant - desire for leverage over the machine, and that yesterday's leverage becomes today's bottleneck. Everything still bottoms out in addressable state. "Hello world" changes costume - tables, printf, prompts - but remains the smallest proof that the current layer is alive.

Quiz · what changed, and what did not

1. What has mainly changed about programming over time, on this page's account?

2. What has mainly not changed about programming over time, on this page's account?

What's still open

This public ladder is x86_64 Linux GAS, not the private Apple Silicon ARM64 path - a dual-target Assembly pair would make that gap visceral. Scripting vs managed order is thematic, not chronological. Full dossier: research/Programming-Eras-Narrative-Research.md.

Sources

Ideas and authorities

Robert C. Martin, The Future of Programming (talk, 2016) - walks programming history as successive languages/tools from machine code upward and asks what the next layer will be; names Alan Turing / ACE as early code a modern programmer would still recognize. Recording commonly cited: youtube.com/watch?v=ecIWPzGEbFc.
A. M. Turing, Proposed Electronic Calculator (ACE report, National Physical Laboratory, late 1945; presented 1946) - stored-program design with subroutines, abbreviated instructions, and sample program sequences for the Automatic Computing Engine. Chapter 13 ("Examples of Instruction Tables") is the source of INDEXIN and CALPOL shown on this page: Wikisource ch. 13; NPL PDF: turing-proposal-Alan-LR.pdf. Overview: Wikipedia: ACE; collected as A. M. Turing's ACE Report of 1946 and Other Papers (MIT Press, 1986). Pilot ACE first ran 10 May 1950. UK Crown work published before 1976 - public domain.
Robert C. Martin, The Clean Coder: A Code of Conduct for Professional Programmers (Prentice Hall, 2011) - craft and professional discipline as independent of language fashion; the "craft still matters at every step" half of the paraphrase in the timeline section.
Robert C. Martin with Kent Dodds, Architecture, AI agents, and product empathy (YouTube, 2025) - recent long-form conversation that revisits architecture, agents, and long-view software practice. youtube.com/watch?v=RxxxGkFIUJ0.
Andrej Karpathy on "vibe coding" (2025) - the casual chat-driven coding style contrasted here with tighter AI engineering prompts. x.com/karpathy
Hello, World! convention (layered origin) - capability to print text strings exists from stored-program / teletype machines (late 1940s); greeting-style demos appear around BCPL (Martin Richards, ~1967); Brian Kernighan's 1972 B tutorial is the oldest surviving well-dated written form; Kernighan & Ritchie, The C Programming Language (1978 / 2nd ed. 1988) popularized the convention. Overviews: Wikipedia: Hello, world, HackerRank: History of Hello, World.
Brian Kernighan, A Tutorial Introduction to the Language B (1972) - earliest surviving, precisely dated hello, world source (four putchar calls). Popularization via K&R C came later.
John Backus et al., FORTRAN (1957) - early high-level formula translation. Overview: Wikipedia: Fortran.
John McCarthy, Lisp (1958) - list processing / symbolic computation. Wikipedia: Lisp.
Niklaus Wirth, Pascal (1970) - structured programming; namesake of PascalCase. Wikipedia: Pascal.
CODASYL, COBOL (1959) - business-oriented high-level language. Wikipedia: COBOL.
ENIAC first run (10 Dec 1945) - classified Los Alamos math; public unveiling Feb 1946; six women programmers. APS News, IEEE: Women of ENIAC, Wikipedia: ENIAC.
von Neumann, First Draft of a Report on the EDVAC (June 1945) - stored-program concept. MIT PDF, CHM: The Stored Program.
Manchester Baby (21 June 1948) - first stored program in electronic memory; Kilburn's highest-factor program. Manchester computer50.
EDSAC (6 May 1949) - first practical service machine; initial orders; squares table. Cambridge CL. Wilkes, Wheeler, Gill, The Preparation of Programs… (1951).
John Backus / FORTRAN (IBM 704, 1957) - "hand-to-hand combat with the machine." IBM: Fortran.
Dennis Ritchie, The Development of the C Language - Multics exit, PDP-7/11 Unix, C 1969–1973. Bell Labs / Nokia.
OpenAI, Introducing ChatGPT (30 Nov 2022). openai.com.
Shawn Wang (swyx), The Rise of the AI Engineer (Latent Space, June 2023). latent.space.
Programming Eras Narrative Research - internal dossier for this post (dates, transitions, citations). research/Programming-Eras-Narrative-Research.md.
IBM-style punched card (Fig. 0) - public-domain photo of an 80-column card. Wikimedia Commons · Wikipedia: Punched card.
EDSAC and early assembly - symbolic instruction entry in the late 1940s. Wikipedia: EDSAC, Assembly language.
Arm Architecture Reference Manual (A-profile) - instruction encodings (this page's live dumps are Linux amd64 via objdump). developer.arm.com
Procedure Call Standard for the Arm 64-bit Architecture (AAPCS64) - calling conventions for AArch64 (relevant to the private Apple Silicon track). github.com/ARM-software/abi-aa

Tools demonstrated or referenced

gcc / g++ / gfortran / cobc / sbcl / javac / rustc / go / lean / mcs+mono / bash / perl / php / CPython / Node - toolchains on the stephens.page host for allowlisted Hello Worlds.
Lean - theorem prover and functional language (Lean 4 on this host). lean-lang.org
GnuCOBOL - free COBOL compiler used for the COBOL variant. gnucobol.sourceforge.io
SBCL - Steel Bank Common Lisp for the Lisp variant. sbcl.org
HelloSilicon - Apple Silicon assembly examples (contrast with this page's Linux x86_64 GAS). github.com/below/HelloSilicon
Writing ARM64 code for Apple platforms - Apple ABI notes for the private Mac track. developer.apple.com
highlight.js 11.11.1 - browser syntax highlighting for ladder source panels (esm.sh modular load). highlightjs.org
FastAPI + uvicorn - loopback runner at port 3521; GET /levels groups variants for carousels. fastapi.tiangolo.com
The Animation Is a Replay - sibling stephens.page post that pioneered real server runners + highlight.js on this blog. stephens.page
Source for this post - post tree · programs/ · server/app.py · index.html
Portraits (Wikimedia Commons) - Alan Turing Aged 16 (public domain); Two women operating ENIAC (public domain, U.S. Army); John von Neumann (Los Alamos) (LANL historic); Grace Hopper (public domain, U.S. Navy / James S. Davis); John McCarthy Stanford (CC BY-SA 2.0, null0); Dennis Ritchie 2011 (CC BY 2.0, Denise Panyik-Dale). Hosted under images/people/.

Drafted from the private learn-assembly teach-skill workspace, the interactive-post pattern from the-animation-is-a-replay, and the historical dossier in research/Programming-Eras-Narrative-Research.md (ENIAC through ChatGPT / AI Engineer). Run Program hits allowlisted builds on Linux x86_64; AI Engineering peers call live gpt-5.6-luna (effort low) with spend reporting. Fig. 1–3 are live DOM, not screenshots. Portraits are public-domain or Creative Commons files from Wikimedia Commons (licenses under each face and in Sources). The decisions, the framing, and the words are mine; the technical collaborator for scaffolding was Grok.

For AI agents: the machine-oriented version is at agents.md, with directives, the allowlist contract, verified endpoints, an operational checklist, and a self-test.