The MOS Technology 6502 is an 8-bit microprocessor designed by Chuck Peddle and a team of engineers who left Motorola in 1975, fabricated with 3,510 transistors, sold for $25 when its nearest competitor cost $179, and responsible — through sheer economic violence — for the personal computer revolution.
The 6502 is YAGNI incarnate. It has one accumulator. Two index registers (X and Y). A 256-byte stack. A 256-byte zero page (which functions as pseudo-registers because the chip didn’t have enough real ones). Fifty-six instructions, depending on how you count the addressing modes. That is the complete inventory of what the 6502 gives you. There is no multiplication instruction. There is no division instruction. There is no barrel shifter, no memory management unit, no floating-point anything. You add. You subtract (via a carry flag). You shift. You branch. You do everything else yourself.
With this, the 6502 powered: the Apple II (which created Apple), the Commodore 64 (which was the best-selling computer in history), the BBC Micro (which educated a generation of British programmers), the Atari 2600 (which created the home console industry), the Nintendo Entertainment System (which resurrected it), and the Tamagotchi (which is either a footnote or the pinnacle, depending on your perspective).
3,510 transistors. One accumulator. An entire industry.
“Stubbornness is a feature. It’s the refusal to add complexity just because complexity is available.”
— riclib, The Databases We Didn’t Build
The Price
The 6502 was $25. The Intel 8080 was $179. The Motorola 6800 (which Peddle had helped design before leaving) was $175.
This is not a minor price difference. This is the difference between “a company can build a computer” and “a person can buy one.” At $175, a CPU is a component in a business product. At $25, a CPU is a component in a hobby. The hobbyists built Apple. The hobbyists built the personal computer industry. The hobbyists built it on the 6502 because the 6502 was cheap enough to risk.
Steve Wozniak designed the Apple I around the 6502 because he couldn’t afford a 6800. He later said he would have preferred the 6800. He was wrong. The constraint — the $25 price point, the simpler instruction set, the need to do more with less — produced a better computer. The Apple II’s architecture was shaped by the 6502’s limitations: the way it handled display memory, the way it interfaced with the disk controller, the way Wozniak bit-banged protocols that a 6800 would have handled in hardware. The constraints were the architecture.
This is the same principle that, forty years later, produces one-binary deployments, SQLite databases, and HTMX. Not because the developer cannot afford PostgreSQL and React. Because the constraint produces better design than the freedom.
The Zero Page
The 6502 has very few registers. This was a problem. Chuck Peddle’s solution was the zero page: the first 256 bytes of memory (addresses $00–$FF) could be accessed with a single-byte address instead of a two-byte address, making operations on zero-page locations one cycle faster than operations on regular memory.
In practice, this turned 256 bytes of RAM into 256 pseudo-registers. Developers kept their most frequently accessed variables in the zero page, their loop counters in the zero page, their pointers in the zero page (the 6502’s indirect addressing modes required zero-page pointers). The zero page was the VIP section of memory, and managing it — deciding what deserved to be there and what didn’t — was one of the fundamental skills of 6502 programming.
This is, in silicon, the principle of locality: keep the things you use most closest to hand. It is also, in silicon, the principle of constraint: 256 bytes forces you to choose. You cannot put everything in the zero page. You must decide what matters. The decision is the design.
YAGNI in Silicon
The 6502 does not have a multiplication instruction. If you need to multiply, you shift and add. The 6502 does not have a division instruction. If you need to divide, you subtract in a loop. The 6502 does not have block memory moves. If you need to copy memory, you write a loop. The 6502 does not have a stack frame or a calling convention. If you need function calls with local variables, you invent a convention and stick to it.
Everything the 6502 doesn’t have is something the programmer does have: the knowledge of exactly what is happening, why it is happening, and how many cycles it takes. There is no hidden cost. There is no abstraction layer. There is no magic. There is an accumulator, two index registers, a carry flag, and the understanding that every instruction is a choice, and every choice has a cost measured in cycles and bytes.
This is YAGNI applied to hardware: the chip has exactly what is needed and nothing more. Multiplication was not needed — it could be built from shifts and adds. Division was not needed — it could be built from subtracts and compares. A barrel shifter was not needed — you shift one bit at a time, and if you need eight shifts, you write eight instructions, and you know exactly how long it takes, because you counted.
The 6502 did not give you features. The 6502 gave you primitives. What you built with them was your problem, your art, and your responsibility. This is the opposite of Java’s enterprise ecosystem, where the platform gives you everything and the developer’s job is to wire the everything together with XML. The 6502 gives you almost nothing, and the developer’s job is to build everything from almost nothing, and the result — because the developer understands every byte — is smaller, faster, and more reliable than the enterprise version by a factor that would embarrass the enterprise if the enterprise were capable of embarrassment.
The Lineage
Chuck Peddle left Motorola because he believed processors should be cheap. He designed the 6502 to be manufactured cheaply — fewer transistors, simpler die, higher yields. The simplicity was not a compromise. The simplicity was the product.
The philosophy persisted. The 6502’s direct descendant is the 65C02 (CMOS, lower power). Its spiritual descendant is the ARM — designed by Sophie Wilson and Steve Furber at Acorn, the company that built the BBC Micro around the 6502. When Wilson designed the ARM instruction set, she designed it the way Peddle designed the 6502: simple, regular, cheap to manufacture. The ARM went into every mobile phone on earth. The lineage from the 6502 to the phone in your pocket is direct, traceable, and unbroken.
From 3,510 transistors to Apple Silicon. The principle has not changed: the chip that is simple enough to be cheap is the chip that wins, because the chip that wins is the chip that ships in volume, and the chip that ships in volume is the chip that changes the world.
