From the PDP-11 to AI: What Computing Must Not Forget
From address buses and paper manuals to distributed systems, AI-assisted software, quantum horizons, and the return of first principles.
Simona’s Version ·(30-Second Summary)
Computers have become vastly more powerful, but the important questions remain: what is the system doing, what does it depend on, and who is responsible when it fails?
The PDP-11 teaches us to build understandable systems; the 6502, to respect limits; and the Z80, to consider the surrounding ecosystem. Cloud services, blockchains and AI bring those lessons into sharper focus.
Convenience can hide complexity, but it cannot remove responsibility. Let's use todays powerful software tools but understand their limits, check their output and keep authority firmly under control.
SYSTEM LOG / APPROXIMATE MILESTONES
At a glance
- 1970 · PDP-11 introduced
- Early 1970s · Unix and early C development
- 1975 · 6502 introduced
- 1976 · Z80 introduced
- Late 1970s, approx. · CP/M and microcomputer ecosystems expand
- 1981 · IBM PC introduced
- 1991 · Linux kernel project begins
- Early 1990s · Public web takes shape
- 2010s, approx. · Cloud-native and container era
- 2020s · Modern generative AI era
- Current era · Post-quantum cryptographic migration
01 / ENTRY POINT
Prologue: Before convenience became invisible
I remain in temperament, a Unix person which encourages an unusual habit: when a new platform promises to remove complexity, I ask where the complexity has gone. Because complexity rarely disappears - more often it changes address, moves behind an interface, or becomes somebody else’s operational responsibility.
The PDP-11, 6502 and Z80 belonged to an era when the relationship between code and machine was often more directly exposed. Software was already a commercial industry: IBM’s 1969 decision to price software and services separately was an important milestone. [1] They are not interchangeable objects of nostalgia; each placed a different set of boundaries around a programmer’s work. Together they help explain why abstraction, scarcity and compatibility still govern the systems we build. And their influence extends far beyond those who personally programmed them.
This article is less a catalogue of processors than an account of changing relationships: between an instruction and an intention, between a local machine and a network, and between the person who builds a system and the person who must trust it. The dates matter, but the recurring questions matter more.
02 / SYSTEMS
The PDP-11: the machine that made systems feel like systems
Introduced in 1970, DEC’s PDP-11 occupied a consequential middle ground. It was a minicomputer rather than a room-filling mainframe or a later personal machine. Its relatively regular architecture, general-purpose registers and addressing modes gave programmers a tractable model of computation. Hardware still had weight and texture, but it could support a coherent operating-system design rather than demand a separate invention for every application.
Unix began on the PDP-7 in 1969 and subsequently moved to the PDP-11; it did not originate on the later machine. The kernel’s rewrite in C in 1973 became a major step towards portability. [2] The PDP-11 was not the sole cause of Unix, and Unix was never simply a transcript of the hardware; their association nevertheless mattered. The development of C and the portability it subsequently enabled helped turn an operating system from a machine-specific arrangement into a set of ideas that could travel. Processes, files, pipes and permissions became a vocabulary in which disparate tasks could be described and composed. The abstraction of a byte stream was especially powerful precisely because it refused to make every programme know the entire nature of its neighbour.
In minicomputer culture, access was shared, time was scheduled, and systems had to remain intelligible to more than one person. That social fact is often missing from hardware histories. The enduring PDP-11 lesson, for me, is not that one instruction set should be revered. It is that a carefully chosen abstraction can make a collection of components act like a system—and can give people a common language for reasoning about it when something goes wrong.
An abstraction earns its place when it makes the underlying system easier to reason about, not merely easier to ignore.
03 / CONSTRAINTS
The 6502: constraints as a programming language
The 6502 arrived in 1975 at a price that helped widen the practical possibilities of microcomputing. [3] In the machines built around it, computing could be encountered at home, in a classroom, or on a workbench rather than only through an institution’s allocation of time. An inexpensive processor did not make a whole computer free or simple. It did, however, change who could reasonably imagine building and programming one.
Eight-bit programming made constraints unusually visible. Memory was small; display, input and timing were close to the code; a convenient general-purpose register file was not waiting to absorb every design mistake. Addresses and cycles were not implementation trivia. They were part of the problem statement. Good work often depended on knowing what could be reused, what could be precomputed and what deserved a byte of storage at all.
There is a romantic account of scarcity in which every limit magically produces elegant code. It does not. Constraints can also produce brittle tricks and obscure maintenance. The valuable lesson is more disciplined: when resources are finite and their cost is visible, design decisions become explicit. Modern abundance can conceal those decisions until a latency budget, battery, embedded controller or security boundary makes them visible again.
The 6502 asks a direct question that remains useful in much larger systems: what must the machine actually do, and what are we spending to make it do that? Asking it is not an argument against abstraction. It is a way to make abstraction answerable to the physical conditions beneath it.
04 / ECOSYSTEMS
The Z80: the ecosystem machine
Introduced in 1976, the Z80 belonged to another decisive expansion of practical programming. [4] Its compatibility with much existing 8080 software, alongside additional instructions and implementation choices, gave designers a path into an already developing software world. In the CP/M era, that mattered. Instruction compatibility did not guarantee that a complete application would run unchanged: operating-system interfaces, hardware access and storage formats also mattered. [5] A processor’s usefulness was increasingly measured not just by what it could execute, but by what people could bring with them.
Microcomputer ecosystems formed around operating systems, assemblers, applications, documentation, peripherals and the people who knew how to make them cooperate. CP/M did not erase differences between machines; compatibility was a practical target, not a universal guarantee. Yet a recognisable software environment made skills and programmes more portable than isolated hardware might have allowed.
The Z80 also illustrates a mode of embedded thinking that remains familiar: a machine may be modest, specialised and long-lived, while still carrying inherited assumptions from a much wider ecosystem. Compatibility lowers the cost of participation, but it also preserves old interfaces and old obligations. The practical programming culture that spread around such systems understood a point we sometimes rediscover in enterprise technology: adoption depends on the surrounding network, not the chip alone.
05 / COMPARISON
Three machines, three lessons
The PDP-11 speaks to system abstraction: choose interfaces that let people build and inspect coherent wholes. The 6502 speaks to resource intimacy: know the cost and behaviour of what is underneath. The Z80 speaks to ecosystem compatibility: a technically elegant component can matter less than the network of tools, conventions and users it can join.
None of these principles defeats the others. An abstraction without an understanding of resources can hide expensive or dangerous behaviour. Resource awareness without stable interfaces can make every programme a private puzzle. Compatibility without scrutiny can turn historical accidents into permanent design constraints. Useful engineering lives in the tension among all three.
PDP-11
System abstraction · Make components intelligible together.
6502
Resource intimacy · Know what each convenience costs.
Z80
Ecosystem compatibility · Design for the world around the machine.
06 / EXPANSION
From terminals to personal computers, networks, and the web
For much of computing’s early life, a terminal represented access to a scarce shared resource. Personal machines changed that relationship. People could experiment without reserving institutional time, and an expanding market for software rewarded programmes written for users who were not themselves operators. The IBM PC’s introduction in 1981 marked an influential step in that story, though it was part of a much broader and messier personal-computing landscape.
Networking then changed the unit of design again. A programme could depend on a remote service, a protocol, a name or a route. The Web was proposed at CERN in 1989, developed into a working browser and server in 1990, and announced more widely in 1991. It made publishing and linking information a global activity. [6] What began as a way to share documents became a platform for applications, commerce and public life. Programming was no longer primarily an arrangement of instructions inside one enclosure.
That expansion was liberating, but each widening circle added another boundary at which assumptions could fail. The household computer brought autonomy; the network brought reach; the web brought an audience. It also brought dependencies on naming, transport, browsers, servers and institutions that most users never see. Convenience and shared failure have grown together.
07 / SOURCE
Open source, Linux, and the Unix idea escaping the laboratory
The availability of source code changed who could inspect, adapt and learn from working systems. It did not automatically make those systems secure or well maintained. It made inspection possible, and made a particular form of collaboration durable. The Linux kernel project, begun in 1991, became one important part of a wider collection of free and open-source tools that carried Unix-like practice into many kinds of machine.
The Unix idea was never just a kernel. It was also a preference for understandable tools, text interfaces where appropriate, documented conventions, and components that could be combined without negotiating a private contract every time. Pipes and protocols express the same cultural hope: let one useful thing communicate with another through a comprehensible boundary.
As a practitioner, I value the difference between being able to read a programme and having actually understood it. Source availability supports audit, reproducibility and education; it does not substitute for the effort or institutions required to sustain them. Composability similarly creates both power and dependence. A small component can be excellent on its own while the assembled system still behaves in surprising ways.
08 / DISTRIBUTION
The cloud and the inversion of the computer
Virtualisation loosened the apparent bond between a programme and one physical machine. Containers made packaging and deployment more repeatable. APIs encouraged services to expose capabilities across organisational and network boundaries. In the cloud-native era of the 2010s, a computer increasingly appeared to its user as an address, a contract or a bill rather than a box one could point to.
This is an inversion of the old mental model. In a small machine, the difficulty was fitting the computation into the hardware in front of you. In a distributed system, capacity can appear almost elastic, while the hard question becomes where computation and state actually reside. A request may cross services, queues, regions and vendors. A single screen can depend on many independent clocks and failure modes.
Observability is the discipline that tries to make these paths legible through logs, metrics, traces and careful questions. It is not the same as omniscience. Measurements are selected views of a system, and a missing signal can be as consequential as a noisy one. The PDP-11 lesson returns at a larger scale: abstractions need enough explanatory power that an operator can reason backwards from an effect to a cause.
The modern machine may be a relationship among machines. Its boundaries still have to be drawn somewhere.
09 / DEFENCE
Security changes when software becomes infrastructure
Cybersecurity work across enterprise systems and hands-on research has taught me to be cautious of tidy boundaries. Protecting a machine remains necessary, but an organisation now depends on software supply chains, identities, cloud controls, cryptographic services and external providers. A secure endpoint cannot redeem an unexamined relationship of trust elsewhere in the system.
Dependencies connect source repositories to build processes, packages, deployments and updates. Identity determines which person or service may act, and under what conditions. Cryptography protects important exchanges, yet its guarantees depend on keys, implementations, lifecycle management and honest assumptions about what is being authenticated. These are governance questions as much as technical ones.
Autonomous systems make the question sharper. When software can select and carry out actions with limited immediate human review, the scope of its authority matters. So do reversibility, evidence, oversight and the ability to stop. Defence therefore shifts from guarding individual machines to governing interacting systems: understanding the dependencies, constraining permissions, testing claims and preserving a path to accountable human judgement.
10 / PROGRAMMABLE VALUE
Web3, programmable value, and the new old problems
Blockchains propose a shared record whose updates can be verified according to defined rules, often without placing every participant under one conventional operator. Smart contracts extend this idea to executable conditions over value and state. That is a meaningful design space. It is not an exemption from the older questions of who controls an interface, what a programme assumes, and how errors are corrected.
A wallet mediates authority for its holder; a bridge links distinct systems and their security assumptions; an oracle introduces claims about events outside a chain. Governance determines how rules may change and who has practical influence when they do. Calling a system decentralised does not answer these questions. It changes their arrangement, sometimes in ways that are hard to see from a simple user interface.
State, trust and failure are the old problems returning with new consequences. An append-only record preserves previous entries; a later transaction may correct the current state without erasing its history. Recovery depends on the protocol and application, while forks, upgrades and administrative controls complicate absolute claims of immutability. Automatic execution can make a flawed assumption immediate. Transparency of code may assist scrutiny while still leaving users dependent on experts, interfaces and institutions. I find it more useful to map those dependencies soberly than to argue from either inevitability or dismissal.
11 / ASSISTANCE
AI-assisted programming: acceleration versus comprehension
Code generation can shorten the distance between an idea and a working draft. It can suggest tests, explain unfamiliar syntax and relieve some repetitive effort. None of those benefits establishes that the resulting programme is correct. Plausible code is particularly easy to accept when it resembles what we expected to see, and particularly hard to interrogate when we did not understand the problem before asking for an answer.
Review must therefore address behaviour, boundaries and provenance, not just style. Where did a suggested dependency come from? Which requirements were inferred rather than stated? What data may have crossed a model boundary? Hallucinated APIs and invented explanations are practical risks; so are quieter errors that pass a superficial test while misrepresenting a system’s actual guarantees.
I would rather treat an assistant as an instrument that expands the range of questions we can investigate than as a substitute for investigation. Responsibility remains with the people and organisations that design, approve, deploy and operate the programme; using an assistant does not remove those obligations. Generating a draft can be faster. Delivering a reliable system also requires review, integration and maintenance; those costs must be measured, rather than assumed away. The need to understand what has been written has not diminished.
12 / TRANSITION
Quantum computing and post-quantum transition
Quantum computing is a different computational model, with algorithms that may offer advantages for particular problems. Post-quantum cryptography is a present-day engineering migration: choosing and deploying cryptographic approaches intended to resist attacks from a sufficiently capable future quantum computer. Conflating the two encourages either extravagant predictions or complacency.
There is no need to claim that practical, universal quantum breaking is imminent to take the transition seriously. Some information must remain confidential for many years. Material intercepted now might be retained for an attempt to decrypt it later: the harvest-now-decrypt-later concern. Systems with long service lives, hard-to-replace devices and complex trust chains cannot safely begin planning only when the threat becomes immediate.
The useful work starts with inventory: which algorithms, keys, protocols, certificates, products and data-retention commitments actually exist? Then come priorities, testing, interoperability and cryptographic agility—the ability to change mechanisms without rebuilding the whole enterprise. NIST published FIPS 203, 204 and 205 in August 2024: ML-KEM establishes shared key material, while ML-DSA and SLH-DSA provide digital signatures. These serve different purposes; they are not interchangeable replacements for every cryptographic component. [10] The story is less about a dramatic machine arriving overnight than about managing dependency and time.
13 / RESPONSIBILITY
The personal through-line: abstraction, agency, and responsibility
Looking across these eras, I keep returning to the relationship between abstraction and agency. The PDP-11 and Unix made it possible to think in processes and files rather than only in device details. The 6502 resisted forgetting the device. The Z80 showed how inherited interfaces can determine what a system is free to become. Later networks and platforms multiplied the number of actors sharing the consequences of a design.
My long-running interest in anticipatory intelligence and in containing autonomous agency follows from that history rather than sitting outside it. To anticipate is not to claim certainty about the next technology. It is to identify where capabilities, dependencies and permissions may combine in ways that outstrip our ability to explain or control them. To contain agency is not to forbid useful automation. It is to specify scope, evidence and intervention before a system’s actions acquire momentum.
Practical security work reinforces a simple discipline: distinguish what has been demonstrated from what has been assumed. A sound decision can acknowledge uncertainty without surrendering to it. That was true when resources were counted in bytes. It remains true when the resource being allocated is authority across an organisation.
ADDENDUM / EVIDENCE AND PRACTICE
When faster writing meets slower understanding
Recent evidence resists a single verdict on AI-assisted programming. METR’s 2025 randomised study involved 16 experienced developers and 246 tasks in familiar repositories; AI access increased completion time by 19% in that setting. Its February 2026 update reported that selection effects and problems measuring concurrent agent work made the follow-up an unreliable estimate of the current effect. Neither result licenses a universal claim about today’s tools. [7] [8]
A July 2026 preprint studying 802 developers at one company reported substantially increased merged-pull-request throughput alongside a larger review burden. Because adoption was not randomly assigned, the authors caution against exact causal attribution. A separate May 2026 longitudinal preprint found a shift towards evaluating and correcting AI output, but its productivity findings are participants’ reports rather than independently timed gains. These studies support measuring the whole workflow; they do not establish that more code means better software. [9] [11]
Five questions before granting a system authority
- What can it read, change, spend or delete?
- Which boundaries are enforced independently of its own judgement?
- What evidence would expose an incorrect action?
- Who can stop it, and what remains reversible?
- Does the measured benefit include review, recovery and maintenance?
These are engineering questions inspired by the history above, not a claim that older computers were intrinsically safer. Simplicity can aid inspection; safety still depends on design, implementation and operation.
14 / END OF FILE
Epilogue: what survives every hardware revolution
Every generation changes what can be built and who can build it. The remarkable thing is how often the elementary questions survive. What is the state? Where is the boundary? What does this component promise, and what happens when that promise fails? Who can act, who can observe, and who remains responsible when the action is complete?
I do not want to return to smaller memories or slower links for their own sake. I want systems that retain something of the clarity those limits sometimes demanded. Readable interfaces, defensible assumptions, proportionate authority and honest accounts of uncertainty are not obsolete preferences. They are conditions for using powerful tools without mistaking convenience for understanding.
The durable inheritance of these machines is not their clock speed or their instruction count. It is the invitation to look beneath the layer currently in front of us. Hardware will continue to change. Human judgement must keep pace—not by pretending to know every detail, but by taking responsibility for knowing which details matter. The machine can execute an instruction. It cannot relieve us of the obligation to decide whether that instruction deserves to be executed. Carpe Diem.
SOURCE REGISTER / CHECKED 12 OCTOBER 2026
References and reading
Historical statements are distinguished from the author’s interpretation. New research is labelled by study design; arXiv hosting does not itself establish peer review.
- Burton Grad (2002), “A Personal Recollection: IBM’s Unbundling of Software and Services.” First-person historical account.
- Dennis M. Ritchie, “The Evolution of the Unix Time-sharing System.” Primary history of PDP-7/PDP-11 Unix and the 1973 C rewrite.
- Computer History Museum, 1975 timeline. MOS 6502 launch context.
- Computer History Museum, 1976 timeline. Zilog Z80 introduction.
- Zilog, Z80 CPU User Manual, UM008011-0816 (2016). Instruction set and architecture.
- CERN, “A short history of the Web.” Proposal, implementation and public availability.
- METR (2025), “Measuring the Impact of Early-2025 AI on Experienced Open-Source Developer Productivity.” Randomised trial; context-specific result.
- METR (24 February 2026), “We are Changing our Developer Productivity Experiment Design.” Follow-up limitations.
- He et al. (July 2026), “AI Writes Faster Than Humans Can Review.” Observational enterprise study; preprint.
- NIST (2024), approval of FIPS 203, 204 and 205. Final standards for key establishment and signatures.
- Vella and Blincoe (May 2026), “The Impact of AI Coding Assistants on Software Engineering.” Longitudinal self-report study; preprint.