Some Thoughts About The Computing Historian Recovering Ideas We Threw Away
2026-04-14
TL;DR
Some Thoughts About The Computing Historian: Recovering Ideas We Threw Away
The internet is asynchronous multi-tasking. We already solved it in hardware. Software academia re-complicated it.
Design recovery is archaeology — and we need a meta-language for the dig.
L;R
We Finally Have It
The internet is asynchronous multi-tasking. Many independent machines, running at their own speeds, communicating when they choose to.
This is not a new idea. Hardware has always been asynchronous. Every chip on a PCB runs at its own speed. Every peripheral operates independently. Hardware engineers have been composing asynchronous components for decades. It works.
Software did not inherit this. Software multi-tasking is a rotary switch — a scheduler cycling through tasks, one at a time, pretending to be simultaneous. The OS is a software implementation of something a hardware switch does cheaper, faster, and without a growing list of security vulnerabilities.
L1 caches are beginning to make CPU cores genuinely independent. But this is an overly complicated path to something you can achieve by buying several Arduinos.
The Concurrency Illusion
Software inherited “concurrency” problems from shared memory. Shared memory is a local decision that became a global constraint. The internet does not share memory. Machines share data — they send messages, they do not hand off pointers. This is not a coincidence. It is the correct design.
Every “concurrency” problem on the internet is simpler than the equivalent problem in a multi-threaded process, for exactly this reason. The difficulty has been re-introduced artificially by building internet services that internally revert to shared-memory designs.
The wheel was invented. Then reinvented with a flat side.
What Academia Optimized For
Modern computing has been shaped by academic concerns, not UX concerns. The abstractions that dominate — type systems, garbage collection, monads, effect systems — are refinements of notation for humans writing programs. They are not refinements of how machines work.
Casey Muratori’s The Big OOPS makes this precise: the abstractions that evolved are measurably inefficient for real reprogrammable machines. The gap between the abstraction and the machine has grown to the point where performance requires heroic effort to recover what was given away for free at the start.
Sketchpad was written in machine code. No type checker. No GC. It worked. It still impresses. The intellectual content was not in the language — it was in the design. We didn’t really need 50+ years of incremental complications added to programming languages to use CPUs as building materials.
Programming vs. Re-Programming
The fundamental invention of computer science is not “programming” itself. The fundamental invention is that of “re-programming” — the study of how to use reprogrammable machines effectively.
This distinction matters. A reprogrammable machine has GOTO. Removing GOTO from the notation does not remove it from the machine. It removes it from a specific paradigm for thinking about programs. That paradigm — functional, structured, referentially transparent — makes re-programming easier within its assumptions. It does not describe reality. It describes a useful fiction layered over reality.
The fiction has costs. The costs compound — and today we speak in terms of giga-bytes instead of kilo-bytes.
Design Recovery
Old software contains designs. The code that implements them is written for machines that no longer exist, in notations that no longer compile, under assumptions that were never written down.
Design recovery is the act of lifting a design out of its implementation — finding the decisions, the structure, the intent — and re-expressing it for a new machine.
This is archaeology. The artifact is not the pottery shard. The pottery shard encodes the artifact. The design is what you are after.
What notation captures a design without committing it to an implementation? Factbases of triples are a candidate — subject, predicate, object, nothing assumed about execution order or machine model. A design expressed as a factbase is substrate-neutral. It can be queried, transformed, re-emitted into any target notation.
This is what design recovery requires: a representation that sits above the code, below the marketing diagram, and carries enough structure to reconstruct intent.
We threw this away when we decided that code was the design.
See Also
Email: ptcomputingsimplicity@gmail.com
Substack: paultarvydas.substack.com
Videos: https://www.youtube.com/@programmingsimplicity2980
Discord: https://discord.gg/65YZUh6Jpq
Leanpub: [WIP] https://leanpub.com/u/paul-tarvydas
Twitter: @paul_tarvydas
Bluesky: @paultarvydas.bsky.social
Mastodon: @paultarvydas
(earlier) Blog: guitarvydas.github.io
References: https://guitarvydas.github.io/2024/01/06/References.html
Paid subscriptions are a voluntary way to support this work.