The Stored-Program Computer

Build the control path in hardware from parts you already have.

1. Make a 4-bit binary counter from the flip-flops of the earlier blueprint — that is the program counter.
2. Add a register to hold the fetched word — the instruction register.
3. Use the top bits of the instruction register to drive a decoder, one output per opcode.
4. Wire the decoder outputs to enable the accumulator's load, the adder, and the counter's parallel-load input.

The decoder is the whole control unit: it turns a bit pattern into a set of enable signals, and that is all “executing an instruction” means.

Note the JUMP path especially. A jump is nothing more than loading the program counter from the instruction instead of incrementing it — no special machinery, just a different source for one register.

The architecture's great strength has a cost that has shaped computing ever since.

1. Count memory accesses for one instruction on your simulator: one to fetch it, often one more to fetch its operand.
2. Now note that instructions and data share ONE memory and ONE path to it.
3. Work out what happens as the processor gets faster and the memory does not.

Code and data compete for the same channel, so the processor spends much of its time waiting for memory. That is the von Neumann bottleneck, and it has grown steadily worse because processor speed improved far faster than memory latency.

Every modern mitigation is an answer to it: caches keep recently used words close; pipelining fetches the next instruction while executing the current one; Harvard architecture gives code and data separate paths, which is why most microcontrollers and every CPU's L1 cache are split into instruction and data halves.

Put a date on it, because the moment is unusually well defined.

1. On 21 June 1948 the Manchester Small-Scale Experimental Machine ran a program stored in its own memory — the first machine to do so.
2. The program searched for the highest proper factor of a number, chosen because it was slow and would exercise the machine hard.
3. It ran 52 minutes and about 3.5 million operations to find the answer for 2^18.
4. The memory was a Williams tube — a cathode-ray tube storing bits as charge spots on the phosphor, and readable as a visible pattern on the screen.

The Baby had 32 words of 32 bits — 128 bytes — and seven instructions. Everything in this batch is present in it: gates, a store, an accumulator, a program counter, and a conditional jump.