Kernighan, Brian
▶ Watch on YouTubeCore ideas
Kernighan traces computing's prehistory from punch-card batch processing to time-sharing systems like MIT's CTSS (which he used firsthand as a summer intern in 1966, running on an IBM 7090 with a then-enormous 150KB of memory), through the ambitious but overreaching Multics project (a joint MIT/Bell Labs/GE effort to build an "information utility" that proved too expensive and too slow to deliver). He recounts the now-legendary story of UNIX's birth: after Bell Labs withdrew from Multics in 1969, Ken Thompson — whom Kernighan calls "kind of a singularity" among programmers — used a little-used PDP-7 to write, largely from scratch in assembly language, an entire operating system in about three weeks while his wife and infant son were away. Kernighan stresses he personally never wrote operating system code himself, and situates UNIX's success partly in Bell Labs' unique culture: a large concentration of highly skilled researchers (many PhDs in physical sciences) in one physical building, an open, informal, faintly rebellious environment, and fast, face-to-face feedback loops that let ideas go from morning conception to working code by evening. He identifies UNIX's core design philosophy as optimizing for programmer productivity and community — not building toward any particular end-user application — and highlights the file-system abstraction (treating devices, and later even other resources, as read/write file interfaces) as the paradigm case of finding one generalizable mechanism instead of proliferating special cases, an idea pushed even further in the later Plan 9 operating system.
Kernighan corrects the common misconception that UNIX was originally open source: it was proprietary but licensed freely in source form to universities, which let generations of students and faculty (himself included, as author of a widely used book) build deep expertise that eventually enabled independent efforts — Berkeley's BSD variant, and much later Linus Torvalds' Linux — to build "UNIX-like" systems free of any AT&T code. He walks through the broader history of programming languages: hand-coded machine instructions, then assembly languages tied to specific hardware, then higher-level, portable languages like Fortran (for engineering/scientific computation) and COBOL (business use) in the late 1950s, which "democratized" programming beyond dedicated specialists, followed by system programming languages like C in the 1970s (built to write text editors, compilers, and operating systems themselves) and then object-oriented languages like C++ once C-scale codebases became too complex to manage safely. He attributes C's long dominance to hitting a "sweet spot" between expressiveness and efficiency at a time when hardware was extremely constrained, reinforced by its tight coupling with the portable, widely-adopted UNIX ecosystem.
On writing "The C Programming Language" with Dennis Ritchie in 1977, Kernighan credits Ritchie's exceptionally clear prose (praising his C reference manual as a model of technical writing) and describes his own contribution as finding realistic, representative examples — small text-processing tasks typical of UNIX work — that teach readers what they'll actually need roughly when they need it, a philosophy he says he still values over "pure syntax" examples in typical programming books. He describes AWK (co-created with Al Aho and Peter Weinberger in the late 1970s) as built around a simple, highly effective pattern-action paradigm — scanning files line by line, automatically splitting fields, and running a matched action — that lets tasks requiring 5–20 lines in Python collapse into one or two lines of AWK, calling it the language offering the best "bang for the buck" for exploratory data work; he calls grep essentially a simplified, single-pattern version of the same paradigm. On modern software, Kernighan expresses real concern about today's deep, opaque dependency chains (pip-installing "a gazillion megabytes" of unknown packages) as both a productivity and a security risk compared to the much smaller library surface of the UNIX era, while still valuing linguistic diversity broadly — arguing dozens of niche or "playground" languages (especially functional languages) are where ideas like recursion, closures, and first-class functions get tested before migrating into mainstream languages, even though only a dozen or so languages account for the vast majority of real-world usage.
Kernighan also describes his role co-designing AMPL, an algebraic modeling language for mathematical/linear programming, developed in 1984 with Bob Fourer and Dave Gay to let people write optimization models (objective functions, constraints, decision variables) in natural mathematical notation, cleanly separated from both the underlying data and the solver software that actually computes results — he wrote the original C++ prototype but attributes most of the substantive design and the associated textbook to his collaborators. Reflecting on complexity theory, he notes his own 1968 PhD thesis on graph partitioning (with Shen Lin) predates Stephen Cook's foundational NP-completeness work entirely — they developed practical heuristics without any formal vocabulary for why the problem resisted exact solution — and says he defers to colleagues' consensus that P likely does not equal NP without holding strong intuitions of his own. Recalling his 1964 undergraduate thesis surveying AI, he describes that era as an "AI summer" of unwarranted optimism (machine translation, theorem-proving, and game-playing all seen as near-term solvable), drawing the lesson (via an Arthur C. Clarke quote) that short-run predictions run wildly optimistic or pessimistic while long-run technological change should not be bet against. On modern machine learning, he disclaims deep expertise but voices concern that models trained on historically biased data will reproduce and potentially amplify that bias, while allowing that ML could also function as a revealing "mirror" prompting societal correction — while remaining fundamentally agnostic (echoing Turing) on how close human-level machine intelligence might be. He closes reflecting on computing's double-edged societal effects (bringing his own family closer via frequent digital communication, while worrying about surveillance, distraction, and how universal "voice" via computing enables both empowerment and the erosion of shared truth in politics), and recalls Bell Labs' 1970s "golden era" — building something, watching colleagues actually adopt and use it — as his fondest professional memory, embodied by AWK's decades of continued real-world use.
Excerpts
On Ken Thompson writing the first UNIX in three weeks:
“Ken Thompson found what is characterized as a little-used PDP-7, where he started to do experiments with file systems... and then this famous story that his wife went away to California for three weeks, taking their one-year-old son, and in three weeks he sat down and wrote an operating system which ultimately became UNIX. So software productivity was good in those days.”
On UNIX's core design philosophy:
“I think one aspect of the fundamental philosophy was to provide an environment that made it easy, or easier, productive to write programs... it was meant to be an environment where it was really easy to write programs so the programmers could be highly productive, and part of that was to be a community... it was kind of a virtuous circle of more and more stuff coming out that was really good for programmers.”
On the risk of bias in machine learning trained on historical data:
“I think there are serious problems in certain kinds of machine learning, at least because what they're learning from is the data that we give them, and if the data we give them has something wrong with it, then what they learn from it is probably wrong too... if it's in the data because of historical treatment, then that machine learning stuff will propagate that, and that is a serious worry.”