Microprocessor
A microprocessor is a complete central processing unit fabricated on a single integrated circuit, pulling the arithmetic, control, and register logic that earlier computers spread across many discrete chips or entire circuit boards onto one piece of silicon. The word "central processing unit" predates the microprocessor by decades — mainframes and minicomputers had CPUs built from racks of transistor or small-scale-integration logic — so the microprocessor is not the invention of the CPU but the collapse of the CPU onto one chip, and that collapse is the entire point: it is what turned processing from something a company bought by the cabinet into something that could be soldered onto a board for a few dollars.
The first commercial microprocessor was the Intel 4004, delivered in 1971 for Busicom's calculator line, and it establishes the template every later processor follows. It was a 4-bit design of roughly 2,300 transistors running near 740 kHz, built by a small Intel team including Federico Faggin, Ted Hoff, Stan Mazor, and Busicom's Masatoshi Shima. What made it significant was not raw speed but the architectural bet: instead of designing fixed calculator logic, Intel built a general programmable processor and moved the product's behavior into a ROM program, so the same silicon could become many different products by changing software rather than changing hardware. That substitution — programmable general logic plus stored program in place of custom wired logic — is the reason the microprocessor generalized out of calculators and into everything.
A microprocessor is organized around a small number of cooperating blocks, and understanding the data path between them explains how a stored program actually executes. The arithmetic logic unit performs the actual operations; a register file holds the operands and intermediate values close to the ALU; a control unit decodes each instruction and sequences the signals that route data; and a bus connects the processor to external memory holding both the program and its data. Execution is a repeating fetch-decode-execute loop: fetch the next instruction from memory using the program counter, decode what it asks for, execute it through the ALU or a memory access, then advance and repeat.
The 1970s saw a rapid progression from 4-bit toward 16-bit, and the sequence of parts is worth knowing because it tracks the early industry's whole arc. Intel followed the 4004 with the 8-bit 8008 in 1972 and the more usable 8080 in 1974; competitors arrived quickly, including Motorola's 6800, the cost-cut MOS Technology 6502 that powered the Apple II and Commodore machines, and Zilog's 8080-compatible Z80 from the Faggin-founded Zilog. Intel's 16-bit 8086 of 1978 then defined the x86 instruction-set architecture whose descendants still run most personal computers and servers, which is why a late-1970s design decision remains load-bearing in hardware shipping today.
The distinction between a microprocessor and a microcontroller is about what else lives on the chip, and it matters because most processors ever made are the latter. A microprocessor is the CPU alone and expects external memory and peripheral chips around it; a microcontroller integrates the CPU together with program memory, data memory, and input/output peripherals on one chip so it can run as a self-contained system. The bare microprocessor is what sits at the center of a general-purpose computer where flexibility and expansion matter; the microcontroller is what sits inside an appliance, a car subsystem, or a toy, where a single cheap self-sufficient chip matters more than expandability, and by unit volume the embedded microcontroller vastly outnumbers the desktop-style processor.
Performance growth over the following decades came from several compounding levers, not from clock speed alone. Transistor budgets grew roughly along the trajectory Gordon Moore described, letting designers add wider data paths, caches to hide slow memory, pipelines that overlap the stages of multiple instructions, and eventually multiple cores on one die once single-core frequency scaling ran into power limits in the mid-2000s. Each lever addressed a different bottleneck — width, memory latency, instruction throughput, then parallelism — so the modern processor is less a faster 4004 than a deep stack of techniques layered on top of the same fetch-decode-execute core the 4004 established.
Read microprocessor as the moment the central processing unit stopped being furniture and became a component: the same programmable fetch-decode-execute engine that filled a cabinet in a minicomputer, pressed onto one piece of silicon cheap enough to put a general-purpose computer inside a calculator, a car, and eventually almost everything.