You've probably seen the photos. Tangles of wire thicker than your arm. And room-sized machines. So women in lab coats plugging cables into panels like telephone operators from another dimension. And you've wondered: what is all that stuff, actually?
The short answer: it wasn't silicon. Not at first. Early computers ran on glass, metal, mercury, and a surprising amount of mechanical ingenuity. The components were physical in a way modern chips simply aren't — you could see them, hear them, smell them burning out Small thing, real impact..
Let's walk through what actually lived inside those machines Easy to understand, harder to ignore..
What Early Computers Actually Used
Before transistors, before integrated circuits, computers were built from components that look more like radio parts or laboratory equipment than anything you'd recognize as "computing hardware." The evolution happened in distinct waves, each solving the fatal flaws of the last The details matter here..
The relay era — mechanical switches doing math
The very first programmable computers — Konrad Zuse's Z3 (1941), the Harvard Mark I (1944) — didn't use electronics at all for their logic. They used electromechanical relays And that's really what it comes down to..
A relay is simple: an electromagnet pulls a physical switch closed when current flows through its coil. That's it. In real terms, on. Off. But one bit. That's why the Z3 used about 2,600 of them. The Harvard Mark I? Roughly 3,500, plus thousands more for its paper-tape readers and counters.
Relays were reliable-ish. Constantly. Three. And they clicked. They'd been used in telephone exchanges for decades. But they were slow — switching in milliseconds, not nanoseconds. On the flip side, the Mark I ran at about 3 additions per second. Consider this: a room full of relays sounded like a typewriter factory during a typing contest. Per second And that's really what it comes down to..
Not the most exciting part, but easily the most useful That's the part that actually makes a difference..
Vacuum tubes — the first electronic brains
If relays were the steam engine, vacuum tubes were the internal combustion moment. In real terms, eNIAC (1945), the first general-purpose electronic computer, used 17,468 vacuum tubes. Most were 6SN7 dual triodes — essentially two amplifiers in one glass envelope Turns out it matters..
Tubes worked by thermionic emission. In practice, no moving parts. Switching speeds in microseconds. A control grid modulated their flow to an anode. A heated cathode boiled off electrons. ENIAC could do 5,000 additions per second — roughly 1,600x faster than the Mark I That's the part that actually makes a difference..
This is where a lot of people lose the thread.
But tubes had problems. Lots of them That alone is useful..
They ran hot. And they were huge. Think about it: technicians spent more time replacing tubes than running programs. Practically speaking, eNIAC consumed 150 kilowatts and required its own air conditioning system — a novelty in 1945. Still, a single flip-flop (one bit of memory) needed two tubes plus supporting components. The mean time between failures was measured in hours. They burned out constantly. ENIAC's 20 accumulators — each holding one 10-digit number — occupied entire panels That's the part that actually makes a difference..
Mercury delay lines — memory that moved at the speed of sound
Early computers needed memory. On top of that, tubes were too expensive for bulk storage. Enter the mercury delay line.
The concept: convert electrical pulses into sound waves, send them through a tube of mercury, convert them back at the other end, and feed them right back in. A circulating loop. Also, total memory: 512 words. On top of that, the EDSAC (1949) at Cambridge used 32 tanks, each holding 32 words of 17 bits. About 2 KB.
Mercury was used because its acoustic impedance matched the quartz transducers, and its temperature coefficient of velocity was low enough to stabilize with careful thermostats. The tanks were kept at 40°C in heated cabinets. If the temperature drifted, the delay changed, and data corrupted.
Honestly, this part trips people up more than it should.
Access was sequential. On the flip side, average access time: 1. But it worked. 5 milliseconds. Even so, you had to wait for your bit to come around. And it was cheaper than tubes The details matter here..
Williams-Kilburn tubes — the first random-access memory
Freddie Williams and Tom Kilburn at Manchester figured out how to store bits on a CRT screen. The Williams tube (1947) wrote charge dots on a phosphor coating using an electron beam, then read them back by detecting the induced current on a pickup plate. Each dot: one bit. A single tube could hold 1,024 bits Simple as that..
It was the first true RAM — random access, no waiting for mercury to slosh around. The Manchester Baby (1948), the world's first stored-program computer, used four Williams tubes for its 32-word memory And that's really what it comes down to..
But they were temperamental. Now, the charge leaked. You had to refresh constantly. Focus drifted. But a sneeze near the power supply could wipe memory. Still — it proved the concept. Every modern DRAM chip descends from this idea.
Magnetic core memory — the breakthrough that stuck
By the mid-1950s, magnetic core memory replaced everything else. Tiny ferrite rings (cores), each threaded with three or four wires. On top of that, magnetize one direction for 1, the other for 0. Day to day, read by flipping the core and sensing the induced pulse. Destructive read — so every read required a write-back Most people skip this — try not to..
The Whirlwind computer at MIT (1953) was the first to use it reliably. Cores were hand-threaded. But it was non-volatile, random-access, and fast — 10 microsecond cycle times. Mostly by women. Under microscopes. That said, a 4K memory plane took weeks to assemble. And it didn't forget when power failed.
Core memory dominated for two decades. The Apollo guidance computer used it. So did the IBM System/360. It wasn't until semiconductor RAM arrived in the early 1970s that cores finally died Which is the point..
Why This History Matters
You might think: okay, old parts. Who cares?
Here's why. Every constraint above shaped how we think about computing.
The relay era forced programmers to think in terms of sequential, mechanical steps. Mercury delay lines meant memory was serial — you optimized code for access patterns, not just algorithmic complexity. Williams tubes introduced the refresh cycle. The tube era made speed possible but reliability a daily battle — which birthed the first error-detection codes and checkpoint/restart concepts. Core memory gave us the first truly random-access, non-volatile main memory — and the word "core dump" when a program crashed and memory was printed for debugging It's one of those things that adds up..
Modern architecture didn't appear from nowhere. Practically speaking, it was forged by these constraints. So the von Neumann architecture — stored program, unified memory — was a direct response to the pain of rewiring ENIAC for every new problem. Cache hierarchy? Plus, born from the speed gap between CPU and core memory. Virtual memory? A trick to make small core memories act larger.
You can't understand why computers work the way they do without knowing what they were built from.
How the Components Actually Worked Together
It's one thing to list parts. It's another to see how they formed a system. Let's trace a single instruction through an early machine — say, the IBM 704 (1954), the first mass-produced computer with core memory and floating-point hardware.
The fetch cycle
The program counter holds an
The fetch cycle
The program counter, now a dedicated register called the Instruction Counter (IC) on the IBM 704, points to the next word in core memory. When the fetch phase begins, the address stored in the IC is fed into the address decoder, which activates one of the many core planes that make up the memory array. The decoder selects a specific row and column, and the sense amplifiers associated with that row amplify the tiny magnetic polarity of each core bit. Because each core stores a single bit, the entire 48‑bit instruction word is read out sequentially, one bit at a time, and assembled in the instruction register Turns out it matters..
At the same time, the timing unit—a modest network of vacuum‑tube flip‑flops—generates the precise pulse sequence needed to latch the fetched word into the instruction register while simultaneously advancing the IC by one word (or by the length of the current instruction, if variable‑length opcodes are used). This timing is crucial: the whole fetch operation must complete before the next stage can begin, and any mis‑alignment would cause a race condition that would corrupt the next instruction Which is the point..
Not obvious, but once you see it — you'll see it everywhere.
The decode‑execute pipeline
Once the instruction resides in the instruction register, the control unit—a matrix of wired‑logic gates and plug‑board connections—examines the opcode field. Based on the pattern it recognizes, it energizes a specific set of functional units:
- Arithmetic‑Logic Unit (ALU) – a collection of binary adders, shifters, and logical gates built from tubes and diodes. If the opcode calls for addition, subtraction, or a logical AND/OR, the ALU receives the operand fields from the instruction register and performs the operation in a few microseconds.
- Floating‑point hardware – a separate set of specialized circuits that handle normalized mantissas and exponents, allowing the 704 to perform real‑number calculations far faster than software emulation could.
- Input/Output channels – dedicated I/O control logic that can address peripheral devices such as magnetic tape drives, card readers, or cathode‑ray tube displays. These channels operate independently of the main CPU, pulling data into or out of core memory via DMA (direct memory access) mechanisms that were pioneering for the era.
The result of the execute phase is written back to core memory or to a dedicated register file, depending on the instruction type. Because core memory is non‑volatile, the write operation can be performed without an immediate refresh, but the sense‑write cycle is deliberately destructive: the selected core is momentarily flipped, a pulse is generated to confirm the write, and then the original state is restored by a compensating drive pulse. This “write‑back‑after‑read” dance ensures data integrity while preserving the random‑access property that made core memory so valuable But it adds up..
Interlocking the pieces
What makes the IBM 704 (and its contemporaries) remarkable is not the individual brilliance of its relays, tubes, or magnetic cores, but how tightly they are woven together:
- Deterministic timing – Every fetch, decode, and execute step is synchronized by a master clock that toggles at a fixed frequency (about 600 kHz on the 704). This clock drives the address decoder, the sense amplifiers, and the control unit in lockstep, guaranteeing that each instruction occupies a predictable number of cycles.
- Interrupt handling – When an external device signals an interrupt, the CPU pauses its current instruction stream, saves the current program counter into a dedicated PSW (Program Status Word) register, and jumps to a predefined service routine. After servicing, it restores the saved state and resumes execution. This mechanism, born out of the need to cope with asynchronous I/O, laid the groundwork for modern interrupt architectures.
- Branch prediction (implicit) – Early machines lacked sophisticated branch predictors; instead, they relied on a simple conditional jump instruction that tested a bit in the PSW. If the condition failed, the program counter was simply overwritten with the address of the next sequential instruction. This straightforward approach taught programmers to structure code in ways that minimized costly jumps—a habit that persists in modern compiler optimizations.
Through this tightly choreographed dance, the disparate components—relays that once clacked out binary decisions, tubes that amplified fragile voltages, magnetic cores that stored a single bit of permanence—coalesced into a functioning computer. The whole system was limited by the physics of its parts: a 48‑bit word could hold only a modest amount of data, and the 10‑microsecond memory cycle imposed a hard ceiling on instruction throughput. Yet those very limitations forced engineers to invent clever workarounds—micro‑coded instruction sequencers, indexed addressing modes, and the earliest forms of assembler—each of which became a building block for later designs The details matter here..
Why This History Matters
Understanding how early machines actually worked reveals a set of enduring principles:
- Resource awareness – Every cycle of core memory, every tube’s amplification, every relay’s bounce carries a cost. Modern software engineers still grapple with latency and bandwidth, but the discipline of “counting cycles” originated in these early architectures.
-
Abstraction through layering – The 704’s hardware exposed only a few primitive operations (load, store, add, shift, conditional jump). By combining these primitives in software, programmers could build higher‑level constructs such as subroutines, loops, and data structures. This early practice of layering abstractions foreshadowed the modern separation between ISA, micro‑architecture, and high‑level languages.
-
Modularity and interchangeability – Although the machine was built from discrete relays, vacuum tubes, and core planes, each functional block (e.g., the sense amplifier, the adder, the core stack) was designed to be replaceable or upgradable without redesigning the entire system. This mindset of modular components later evolved into the standardized bus architectures and plug‑in cards that define today’s computers It's one of those things that adds up. No workaround needed..
-
Error detection and resilience – Tube failures were common, so engineers incorporated parity bits into core memory and used duplicate relay paths for critical control signals. When a discrepancy was detected, the machine could halt or invoke a recovery routine. These rudimentary fault‑tolerance techniques planted the seed for modern ECC memory, watchdog timers, and reliable exception handling.
-
Instruction‑set economy – With limited opcode space, the 704’s designers chose instructions that could serve multiple purposes (e.g., the same add instruction could also be used for address calculation when combined with indexing). This economy of instruction encoding influenced later RISC philosophies, where a small, well‑chosen set of operations yields high performance through clever composition.
-
Legacy of documentation and education – IBM released detailed manuals that explained not just the wiring diagrams but also the timing charts and programming examples. By treating the machine as a teachable artifact, they cultivated a generation of engineers who understood both hardware and software viewpoints—a dual perspective that remains essential in today’s system‑on‑chip design.
Together, these principles show that the IBM 704 was more than a collection of relays, tubes, and cores; it was a laboratory where the foundational habits of computing were forged. Plus, recognizing this lineage reminds us that today’s optimizations—whether in cache‑friendly algorithms, low‑latency networking, or energy‑aware compilers—are built on the same mindset that once made a 600 kHz clock feel like a breakthrough. So the discipline of counting every cycle, the instinct to layer abstractions, the drive for modularity, the early attempts at fault tolerance, and the thrift in instruction design all survived the transition from vacuum‑tube behemoths to silicon‑scale processors. In honoring the ingenuity of those early engineers, we gain a clearer view of how to push the next generation of technology forward.
