What Computer Architecture Is

You already know what a computer is — a machine that fetches instructions and executes them. This master's course is about the layer where that machine is designed: computer architecture, the discipline of deciding what a processor should do and how to build it so that it is fast, cheap and power-efficient all at once.

The single most important idea in the whole subject is that a computer is a stack of abstractions. A programmer writing Python never thinks about electrons in silicon; a physicist doping a transistor never thinks about your web browser. Each layer hides the mess below it and offers a clean interface to the layer above. Architecture lives at the seam in the middle of that stack — the exact boundary where software stops and hardware begins.

The stack, top to bottom

Here is the whole tower. Step down through it: at the top is the app you care about, at the bottom are electrons obeying quantum mechanics, and every rung is a promise to the rung above that it need not look any lower. The two shaded rungs — the Instruction Set Architecture (ISA) and the microarchitecture — are what "computer architecture" actually means.

The ISA: a contract, not a chip

The Instruction Set Architecture is the visible interface of the processor: the set of instructions it understands, the registers a program can name, how memory is addressed, and what each instruction is guaranteed to do. It is a specification — a contract. On one side, compiler writers promise to emit only these instructions; on the other, hardware designers promise that any chip bearing the name will execute them correctly.

Because it is only a contract, the same ISA can be honoured by wildly different machines. Every \text{x86} chip from a 1993 Pentium to a 2024 server runs the same basic instruction set — which is why a program compiled decades ago still runs today. ARM and RISC-V are two other ISAs; the phone in your pocket almost certainly speaks ARM.

the ISA (architecture) is what the machine does — the programmer-visible contract: instructions, registers, memory model;
the microarchitecture is how a specific chip implements that contract — pipelines, caches, branch predictors, execution units;
one ISA → many microarchitectures. Intel and AMD build very different chips that honour the same \text{x86} contract.

Why the seam is worth a fortune

Freezing the ISA while letting the microarchitecture evolve is the trick that built the entire computing industry. Software written against the contract keeps working, so a company can pour billions into a faster chip and every existing program instantly benefits — no rewrite required. The stable interface is precisely what lets the two sides of the seam innovate independently. Almost everything in the rest of this course — pipelining, out-of-order execution, caches, multicore — is a microarchitectural trick to run the same old instructions faster.

In the 2000s Intel bet on a brand-new ISA, Itanium (IA-64), that was cleaner and more parallel on paper than the ageing, baroque \text{x86}. It flopped. The reason is the seam: the world's software was written against the \text{x86} contract, and no amount of architectural elegance was worth abandoning that mountain of working code. Meanwhile \text{x86} chips kept getting faster underneath the same contract. The lesson of architecture is that a stable interface with billions of users is one of the most valuable things in engineering — often more valuable than a better design.

Casually people say "the architecture of this CPU" to mean its internal design — but in this field the words are precise. Architecture (the ISA) is the contract you could read in a manual and program against; microarchitecture is the confidential engineering of one chip that fulfils it. "Skylake", "Zen 4" and "Apple M-series" are microarchitectures; \text{x86-64} and \text{ARMv8} are architectures. Mixing them up will get you into trouble the moment someone asks "does this run on that ISA?"

Where this course goes

We start by learning to measure a machine honestly — because architecture is an engineering discipline, and you cannot improve what you cannot quantify. The very next lessons build the vocabulary of performance, then Amdahl's law, the ceiling on every speedup you will ever chase. From there we descend the stack — transistors, the ISA, the pipeline — and then climb back up through the tricks that make modern chips fast.