Chapter 36: Computers and Software
Era span: 1854 Boole → 1980s PCs · Difficulty: extreme
Requires: Ch 18, Ch 35
Unlocks: Ch 39, Ch 42, Ch 45, Ch 46
Computers automate reasoning itself. The lineage is longer than the hardware: logic formalized → information quantified → machines built → software industrialized. This chapter builds the stack in that order, because each layer only works on the one below.
36.1 Theory Before Metal
- Boole (1854): logic becomes algebra — AND/OR/NOT operations on true/false values. Shannon (1937): Boolean algebra IS switching-circuit design; telephone relays compute.
- Turing (1936): the universal machine — one device reading/writing symbols on tape can simulate ANY computation. Also the halting problem: some questions provably unanswerable by any machine. Know the limits BEFORE building (Ch 46 inherits them).
- Shannon's information theory (1948): bits measure information; channel capacity bounds exist; redundancy beats noise (error-correcting codes make unreliable hardware reliable — the quiet miracle under all computing).
| Gate | Symbol | Rule | Relay/tube/transistor form |
|---|---|---|---|
| NOT | ¬A | Inverts | One switch, normally closed |
| AND | A·B | 1 only if both 1 | Series switches |
| OR | A+B | 1 if either 1 | Parallel switches |
| NAND / NOR | ¬(A·B), ¬(A+B) | Each alone is complete: any circuit can be built from one type | Preferred in silicon |
| XOR | A⊕B | 1 if different | Adder core (sum bit) |
Half-adder in one line: sum = A⊕B, carry = A·B. Chain carry into full adders, chain adders into ALUs — arithmetic IS stacked logic, and Shannon's thesis is the translation dictionary.
36.2 Hardware Generations
- Mechanical calculators: Pascal/Leibniz gear arithmetic; Babbage's Difference Engine concept worked, his Analytical Engine (programmed, general-purpose, 1837 design) never got built — precision machining couldn't hold tolerances at affordable cost (Dead end avoided as strategy: mechanical GENERAL-PURPOSE computing; mechanical SPECIAL-PURPOSE calculators remained useful for a century).
- Relay computers (1941–): Zuse Z3, Harvard Mark I — telephone-switch tech computing reliably but slowly (seconds per multiply).
- Vacuum-tube monsters: ENIAC (completed late 1945, publicly unveiled February 1946; ~18,000 tubes; originally programmed by plugboards and switches — built to compute artillery firing tables, though its first major job, in December 1945, was a Los Alamos thermonuclear calculation); then stored-program architecture (von Neumann/EDVAC report 1945; Manchester "Baby" ran first, June 1948): instructions live in memory like data — programs become writable, loadable, self-modifiable. THE architectural decision still governing everything.
- Memory hierarchy: delay lines/core memory (magnetic rings threaded by wires — reliable, tedious) → DRAM (Ch 35); storage on punched cards/tape/magnetic disks.
- Transistorized → integrated generations shrink rooms to chips; microprocessors put whole CPUs on single dies (4004, 1971).
| Generation | Element | Cycle time | Lesson |
|---|---|---|---|
| Relay (Z3, Mark I) | Telephone switches | Seconds/multiply | Reliability before speed |
| Tube (ENIAC) | ~18,000 bottles | ~200 µs add (5,000 additions/s) | MTBF planning; stored program next |
| Transistor | Discrete germanium/silicon | ~µs | Rooms become cabinets |
| IC → microprocessor | 4004 (1971) → 8-bit families | Sub-µs | Cabinets become desks |
36.3 Software: The Second Machine
Hardware without software is jewelry. The stack, in dependency order:
- Machine code/assembler: raw instruction encodings; human-hostile but direct.
- Compilers (FORTRAN, 1957): translate human-readable formulas into optimized machine code — programming effort fell several-fold; skeptics predicted bad code, benchmarks humiliated them.
- Operating systems: batch schedulers → time-sharing (many users, interleaved execution; CTSS/Multics) → UNIX (1969): small kernel + composable tools + portability via C language. Unix patterns (files, pipes, processes) remain the lingua franca.
- Languages by purpose: COBOL (business records), Lisp (symbolic/AI research), ALGOL (structured-programming theory → Pascal/C descendants). Type systems, structured control flow, and modularity tame complexity ("software crisis" responses of the late 60s).
- Engineering culture: version control, testing, code review, documentation — software quality is process quality (Ch 47).
UNIX pattern in four nouns: everything is a file; small tools do one thing; pipes join tools; shell scripts freeze workflows. A team that internalizes this administers ten machines with the effort others spend on one — composability IS staffing.
36.4 Personal Computing Inflection
Microprocessors made computers cheap enough to give away:
- Altair 8800 kit (1975) ignited hobbyists; Apple II (1977) packaged usability (color graphics, floppy storage); VisiCalc (1979) — the spreadsheet — gave businesses their first irresistible reason to buy; IBM PC (1981) standardized the platform; GUIs (Xerox PARC research → Macintosh 1984) removed command-line illiteracy as a barrier.
Adoption economics: value compounds with installed base (compatibility gravity) — platform wars are ecosystem wars, won by developers courted early.
| Machine | Hook | Why it mattered |
|---|---|---|
| Altair 8800 | Kit, S-100 bus | Hobbyists became an industry |
| Apple II | Color + floppy + slots | Usable out of box, expandable |
| VisiCalc | Spreadsheet | First business "must-buy" app |
| IBM PC | Open-ish standard | Clones → commodity → ubiquity |
| Macintosh | GUI + mouse | Computing without memorizing |
36.5 Doctrine
- Standards compound: ASCII text, fixed file formats, open protocols — lock-in fights are expensive; interop wins long-term.
- Backup and redundancy from day one: data outlives hardware; error-correcting codes (§36.1) plus geographic copies prevent catastrophe.
- Automate verification: compilers caught typos; tests catch regressions; formal methods eventually catch logic errors in critical systems. Trust scales with checking machinery.
- Compute budget discipline: algorithms matter more than hardware speed — replacing an O(n²) algorithm with an O(n log n) one buys more than any fab upgrade. Teach big-O thinking alongside soldering.
- Numerical computing is the first customer: each generation of machines earned its keep on numerical solutions of the rate equations of Ch 12 §12.9 — firing tables, weather prediction (Richardson's hand-computed forecast, published 1922; the ENIAC forecasts of 1950), structural, reactor, and orbital calculations. Validate every numerical program against a hand calculation or a known exact case before trusting its output, and halve the step size to check that the answer has converged.
| Move | Cost | Payoff |
|---|---|---|
| ASCII + open formats | Convention effort | Files readable for decades |
| 3-2-1 backups (3 copies, 2 media, 1 offsite) | Disks + routine | Survive fire, theft, fat-finger |
| Tests + review per change | 30–50 % of coding time | Regressions caught, not shipped |
| O(n²) → O(n log n) | One smart afternoon | 100× on real data |
Key threshold: when computation costs less than the labor it replaces per task (payroll, inventory, drafting, simulation), adoption becomes automatic — the same crossover logic as Ch 26's electricity, now applied to thought work. Everything remaining in this book rides that curve.
36.6 The Computing Papers
- Babbage's government project failed honestly: Treasury funded the Difference Engine from 1823 (~£17,000 public money eventually); cost overruns, precision-tool limits, and engineer Clement's disputes killed it — the first documented state mega-program overrun in computing, cited ever since in procurement debates.
- Ada Lovelace's Note G (1843) — Bernoulli-number pseudocode with the loop insight — is regarded as the first published computer program; she died at 36 in 1852. Babbage died bitter; the Analytical Engine remained drawings.
- Hollerith punched cards saved the 1890 census roughly $5 million and two years; his Tabulating Machine Company merged into CTR, renamed IBM in 1924 under Thomas Watson Sr.
- Zuse's Z3 (1941) ran Berlin until bombing destroyed it (1943); he rebuilt machines postwar from memory. Atanasoff–Berry's ABC (1942) never became general-purpose but resurfaced legally: Honeywell v. Sperry Rand (1973) invalidated the ENIAC patents citing Mauchly's 1941 visit — landmark IP ruling, delivered by a judge noting the patent should never have issued.
- UNIVAC I (1951, first commercial computer) predicted Eisenhower's 1952 landslide early on CBS with partial returns — television taught America computers existed overnight.
- IBM System/360 (1964): a $5 billion commitment (contemporary Fortune called it IBM's gamble) betting the company on compatible instruction-set families — the platform concept's costliest proof.
- UNIX began on a scavenged PDP-7 (Thompson, 1969); Ritchie's C rewrite (1973) proved OS portability — the licensing-friendly OS whose descendants run everything from phones to supercomputers.
- The Altair BASIC contract (1975) launched Microsoft; the non-exclusive DOS license to IBM (1980–81) — retained rights to license MS-DOS to clones — is widely assessed as history's most consequential business-contract oversight (an assessment, not a fact; the clone-market outcome it produced IS fact). Compaq's clean-room BIOS reverse-engineering (1982) legalized the PC clone industry — reverse-engineering law shaping markets as much as chips did.
36.7 First-Machine Build Order
Gates on breadboard (AND/OR/NOT by hand) → half-adder → stored-program paper simulator (fetch-decode-execute by hand on paper memory) → relay or tube ALU → assembler → compiler for one tiny language → OS kernel (scheduler + filesystem) → useful application. Teams that skip the paper simulator misunderstand every bug thereafter; teams that build it debug hardware and software separately — the skill that separates engineers from assemblers.