I do not miss old computers because they were slow, beige, or difficult. I miss the agreement they made with the person who bought one.
The machine arrived as a thing you could understand. It had a power switch, a programming language, documentation, visible expansion points, and a reasonably direct relationship between what you asked it to do and what it did. You could spend years learning it without discovering that your accumulated knowledge had been remotely declared obsolete.
Modern computers are astonishingly capable. The problem is not their speed. The problem is that their social contract has become worse.
Storage Should Survive the Computer
The computer is a replaceable engine. My work is not.
That distinction should be visible in the architecture. If the compute unit fails, I should be able to detach the storage, attach it to another compatible machine, and continue. Replacement should feel like changing a motor, not negotiating the return of my own memory.
External storage is not merely a backup accessory. It is an assertion of ownership. The files, programs, settings, notes, and experiments belong to the person using the machine. Compute can be upgraded around them.
Cloud storage can satisfy part of that goal, but it can also invert it. A remote service may preserve data while making access depend on an account, subscription, network, application version, or company that can disappear. The important property is not whether the storage sits inside or outside the room. The important property is whether the user can recover it with ordinary tools and move it to another computer without asking permission.
Installation Should Sometimes Be Physical
Software installation has become an abstract ritual: accounts, stores, package managers, permissions, dependency resolution, license dialogs, and background updates. Physical attachment can be much clearer.
Connect the thing and it is present. Remove it and it is gone.
That “thing” might be storage, an interface, a sensor, a cartridge, a development module, or a complete compute unit. The physical boundary gives the user a model. There is less ambiguity about what was added, where it lives, or how to take it away.
I do not want every feature embalmed in a proprietary plastic cartridge. I want the useful directness of attachment. A modular computer could identify a newly connected component, display exactly what capability it provides, and let the user decide whether to activate it. Putting a physical object onto a marked location could be enough to install a tool or open its contents.
The point is not nostalgia. The point is legibility.
A Real Computer Can Be Extended
An appliance hides its boundaries. A computer exposes them.
An extendable machine lets people add memory, storage, interfaces, controllers, displays, accelerators, and entirely unanticipated devices. This is not only a repair feature. It is an invitation to invention.
The expansion connector says, “The person who designed this machine did not imagine its final use.”
That humility matters. A sealed computer may be beautifully optimized for the day it ships, but it also assumes that the manufacturer knows every future need. An open electrical and software interface leaves room for the person holding the machine to disagree.
Extension does require discipline. Electrical limits, protocol versions, physical dimensions, and security boundaries must be specified. An expansion bus that can silently take over the machine is not friendly merely because it is accessible. Openness works when the contract is complete enough for someone else to build against it.
Documentation Is Part of the Computer
People still print documents. I print datasheets because a stable page is a powerful instrument. It can lie beside a board, accept pencil marks, survive a reboot, and remain readable after a website changes.
A computer should come with the knowledge required to use and understand it:
- a clear introduction;
- a complete programming reference;
- electrical and expansion specifications;
- a circuit diagram;
- recovery instructions;
- worked examples that begin with the machine exactly as delivered.
This is not packaging material. It is part of the product.
Complete documentation also makes right-to-repair concrete. “Repairable” is an empty adjective when the circuit is secret, the parts are unidentified, diagnostic modes are locked, and the recovery image can only be obtained from a vanished server.
A schematic does more than help a technician. It tells every curious owner that the machine is allowed to be understood.
Programming Should Be There at Power-On
One of the loveliest properties of an older personal computer was that learning to program did not begin with installing a programming environment.
Turn it on. Type something. See what happens.
The first lesson was not account creation, command-line package installation, dependency management, or choosing among seventeen nearly identical tools. The computer already contained the bridge between curiosity and action.
A modern machine can do this much better. It can include a friendly language, a serious systems language, an editor, examples, offline documentation, a debugger, and a safe route from a tiny experiment into the real hardware. Beginner access does not require a toy universe disconnected from the machine. It requires a shallow first step and a long path forward.
Developer friendliness is not a niche concession. Games, experiments, homemade tools, strange peripherals, and tiny personal programs are how a computer becomes culturally alive. “Serious business use” may justify a purchase, but play teaches people that the machine can become something else.
Knowledge Should Not Expire on Schedule
Hardware improves. Operating systems change. Interfaces evolve. None of that requires treating old knowledge as waste.
If a program has a clear machine contract, a newer system should be able to preserve that contract directly or emulate it. If an old storage format is understood, tools should remain available to read it. If people learned a programming environment deeply, a new generation should offer a path forward rather than a ceremonial bonfire.
Compatibility has costs. Preserving every bug forever can distort a platform. Old interfaces may be insecure or tied to assumptions that no longer hold. The answer is not eternal accidental behavior. It is a documented boundary: preserve the meaningful model, isolate dangerous behavior, and provide explicit migration when exact compatibility is impossible.
The most valuable compatibility is not binary compatibility. It is continuity of understanding.
The Missing Reboot
I want a new computer with the confidence of an old one:
- my work survives the engine;
- attachment has visible meaning;
- extension is expected;
- documentation is complete;
- programming begins immediately;
- repair is permitted;
- knowledge compounds instead of expiring.
None of this requires returning to old performance or old limitations. We can keep modern displays, networks, processors, fabrication, and languages. We can build machines that are faster, safer, and easier without making them more opaque.
The reboot I want is not a retro enclosure around a modern sealed appliance. It is a return to the idea that a personal computer should become more personal the longer a person lives with it.