Chapter 36: Computers and Software

Era span: 1854 Boole → 1980s PCs · Difficulty: extreme
Requires: Ch 35 hardware, Ch 18 text culture ·
Unlocks: Ch 42, Ch 45, Ch 46, every data system after

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).

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 — its first production job was artillery firing tables); 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).

36.3 Software: The Second Machine

Hardware without software is jewelry. The stack, in dependency order:

1. Machine code/assembler: raw instruction encodings; human-hostile but direct.
2. Compilers (FORTRAN, 1957): translate human-readable formulas into optimized machine code — programming productivity multiplies ~10× overnight; skeptics predicted bad code, benchmarks humiliated them.
3. 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.
4. 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).
5. Engineering culture: version control, testing, code review, documentation — software quality is process quality (Ch 47).

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.

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 — an O(n²) fix buys more than any fab upgrade. Teach big-O thinking alongside soldering.

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.