Experiments 08

From Floppy to Cloud

How I learned to code, told on the interfaces I learned it on. One screen, nine programs: the prompt takes commands, the page renders its own source, and the cluster heals when you break it.

TypeScript · Rust · WASM

01 / 08Mid 1990sPOST

Award Modular BIOS v4.50G, An Energy Star Ally
Copyright (C) 1984-94, Award Software, Inc.
 
486DX2-66 CPU at 66MHz
Memory Test : 0K
 

Power on. The machine counts the memory it finds.

  1. Mid 1990s POST

    Building blocks

    The first time I built a PC from parts, it was like putting together a puzzle with no picture on the box. Each component either clicked into place or didn’t fit at all. When it finally powered on, it felt like I had created something from nothing.

    The machine was something I put together with my own hands.

    486 DX2 / 8 MB RAM / 120 MB HDD / SVGA

  2. Late 1990s COMMAND.COM

    Blinking cursor

    It started with a black screen and a cursor. No instructions, no clues, just a quiet invitation to type. All I wanted was to play Prince of Persia, but first I had to learn how to talk to the machine.

    The first interface was a blank slate.

    MS-DOS 6.22 / DIR / CD / Patience

  3. Late 1990s PRINCE.EXE

    Prince of Persia

    Two floppy disks and thirty minutes of anticipation before the world appeared. A pixelated prince leapt over guards, missed ledges, and fell into spikes. It was the first time software felt less like a tool and more like a place someone had imagined into existence.

    Loading became part of the myth.

    Two 3.5″ floppies / Disk swap / 60 minutes

  4. 2003 index.html

    Markup fever

    Right-click, View Source. Suddenly the surface of the web had a skeleton. A library book taught me HTML, then CSS, and the page stopped being magic without becoming less magical.

    The web was readable by anyone curious enough.

    HTML 4 / CSS / Notepad / View Source

  5. 2008–2016 python2.7

    func()

    I started with Python 2 because it was the language of a popular Minecraft modding tutorial. It felt like a more polite version of JavaScript, with fewer ways to shoot myself in the foot. But as I built more, I found libraries that did way more than I expected, and the weird parts of Python became a map to new possibilities.

    The language was a toolbox with some hidden compartments.

    Python 2.7 / pip / The Zen

  6. 2016–2020 kubectl get pods -w

    kubectl apply

    Docker made the application portable. Kubernetes made the system explicit. I stopped thinking only in functions and started thinking in rollout, recovery, traces, and blast radius.

    The shape of software got bigger.

    Docker / Kubernetes / Tracing

  7. 2020–now life.wasm

    Borrow checked

    Rust was exacting in the best way. No garbage collector, no undefined behavior, no vague ownership. Every error message was a small lesson in building with more care.

    The compiler made rigor feel humane.

    Rust / wasm-bindgen / Ownership

  8. Now sh

    What comes next

    Kubernetes, Rust, AI. Real-time collaboration, distributed inference, language models that write and read code. The old cursor is still here, but now it feels like a doorway.

    The prompt is another beginning.

    AI / CRDTs / Realtime

What is real here

POST
A simulation of an Award BIOS counting 8 MB of memory.
COMMAND.COM
A shell with eight commands and a disk of nine files.
PRINCE.EXE
The loading sequence, with a real disk swap and a real hour.
index.html
A sandboxed frame rendering the source beside it, as you type.
python2.7
A transcript of a real session, replayed. Nothing is evaluated.
kubectl
A ReplicaSet controller in miniature: desired state, observed state, and the difference.
life.wasm
Conway’s Life in Rust, compiled to WebAssembly. The same engine as experiment 01.
sh
A shell whose commands are this site’s pages.