Kernighan Traces Unix, C Inventions to Shielded Bell Labs Monopoly
Ryan Peterman
Bell Labs produced foundational computing breakthroughs like Unix and C because guaranteed telephone monopoly revenues insulated researchers from corporate deadlines and performance metrics, granting staff years of unguided exploratory freedom.
Funded by AT&T's legally guaranteed monopoly profits, Bell Labs directed 1% to 2% of national revenues directly into open-ended fundamental research, allowing scientists to pursue speculative projects for multiple years without commercial milestones. (6:34)
Ken Thompson built the initial Unix operating system, an assembler, and a text editor in three weeks on a PDP-7 with 8k of memory, laying the groundwork for Dennis Ritchie's C language to achieve industry dominance through minimal runtime overhead and hardware transparency. (27:56)
Princeton has seen computer science major enrollments plunge from over 200 in the class of 2026 to a projected 80–90 two years later, as students pivot toward hardware and robotics while relying on LLMs over in-person faculty office hours. (55:51)
Generative AI code generation introduces an epistemological infinite regress: while LLMs work roughly 90% of the time, the lack of tells in the failing 10% necessitates AI checkers to verify AI checkers, undermining the manual craft of software verification. (71:20)
Detailed notes
## Background
This interview was published by Ryan Peterman on YouTube on October 26, 2026. The episode features Brian Kernighan, former Bell Labs member of technical staff and co-author of the seminal C book, discussing what Bell Labs was like and the stories behind the famous tools built there.
## TL;DR
Brian Kernighan reflects on his decades-long career at Bell Labs, exploring the unique economic and organizational conditions that allowed foundational technologies like Unix, C, and awk to flourish without top-down deadlines. He recounts working alongside luminaries like Ken Thompson, Dennis Ritchie, and Richard Hamming, and details famous historical anecdotes such as faking a spell-check demo for the CIA director and wearing a fake badge past security. Transitioning to his academic perspective at Princeton, Kernighan addresses the contemporary impact of large language models on computer science education, the decline in office hours, and the epistemological limits of AI code validation. He concludes with career advice grounded in serendipity, urging young engineers to cultivate wide interests and say yes to unexpected opportunities.
## Atmosphere & style
The conversation carries a warm, conversational, and nostalgic tone, combining Kernighan's understated self-deprecation with deep historical reverence for early computing pioneers. Ryan Peterman adopts an attentive, deferential interview style, giving Kernighan ample room to wander through vivid institutional memories and technical reflections. Watching the exchange feels like sitting in on a relaxed masterclass with a humble computing legend, balancing lighthearted humor—such as workplace insurrections with fake badges—against thoughtful philosophical concerns regarding modern AI abstractions and the loss of manual craft.
## Bulletin
- [06:34](https://www.youtube.com/watch?v=sMllOlxVgD0&t=394s) Funded by AT&T's legally guaranteed monopoly profits, Bell Labs directed 1% to 2% of national revenues directly into open-ended fundamental research, allowing scientists to pursue speculative projects for multiple years without commercial milestones.
- [27:56](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1676s) Ken Thompson built the initial Unix operating system, an assembler, and a text editor in three weeks on a PDP-7 with 8k of memory, laying the groundwork for Dennis Ritchie's C language to achieve industry dominance through minimal runtime overhead and hardware transparency.
- [55:51](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3351s) Princeton has seen computer science major enrollments plunge from over 200 in the class of 2026 to a projected 80–90 two years later, as students pivot toward hardware and robotics while relying on LLMs over in-person faculty office hours.
- [01:11:20](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4280s) Generative AI code generation introduces an epistemological infinite regress: while LLMs work roughly 90% of the time, the lack of tells in the failing 10% necessitates AI checkers to verify AI checkers, undermining the manual craft of software verification.
## Key takeaways
- [06:34](https://www.youtube.com/watch?v=sMllOlxVgD0&t=394s) AT&T's regulated public monopoly funded open-ended research at Bell Labs by allocating 1% to 2% of national revenues without demanding short-term commercial returns.
- [16:31](https://www.youtube.com/watch?v=sMllOlxVgD0&t=991s) Bell Labs maintained an egalitarian, report-light hierarchy where researchers held the shared title of Member of Technical Staff and actively avoided promotions into administrative management.
- [27:56](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1676s) Ken Thompson created the first working Unix operating system, assembler, and text editor in a three-week burst while his family was away, using an obsolete DEC PDP-7 with 8k of 18-bit words.
- [30:03](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1803s) Doug McIlroy served as a vital intellectual mentor at Bell Labs, pioneering macro processors, authoring core Unix utilities like sort and diff, and building early PL/I compilers.
- [36:55](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2215s) High-profile Bell Labs product demonstrations occasionally relied on scripted simulations, including Kernighan using shell scripts with sleep commands to simulate spell-checking for CIA Director William Colby.
- [39:46](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2386s) The C programming language won industry dominance due to its tight hardware mapping, omission of heavy runtimes or garbage collection, and symbiotic partnership with Unix.
- [43:05](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2585s) Foundational Unix software including awk and make were built as rapid weekend prototypes by small groups of researchers solving immediate personal bottlenecks.
- [53:09](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3189s) Undergraduate attendance at office hours has dropped significantly as students rely on LLMs like Claude, cutting off high-bandwidth human mentorship and spontaneous research opportunities.
- [55:51](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3351s) Computer science major enrollments at Princeton are dropping sharply as undergraduates move toward electrical, computer, and aerospace engineering in search of insulation from AI automation.
- [01:11:20](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4280s) Software engineering faces an infinite regress problem when using AI-generated code and AI-generated tests, removing the craft of manual memory and logic verification without obvious error indicators.
- [01:16:47](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4607s) Large language models represent another layer in computing's abstraction ladder, mirroring the historical friction and eventual broad adoption seen during John Backus's introduction of Fortran compilers.
- [01:23:33](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5013s) Kernighan recently modernized the canonical 'one true Awk' codebase by adding native UTF-8 support and clean CSV input parsing for modern datasets.
- [01:24:28](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5068s) Adopting Richard Hamming's advice to 'just say yes' allows careers to develop like Galton boards, where broad exploration and prepared minds bias random life bounces toward favorable outcomes.
## Detailed walkthrough
### [00:00](https://www.youtube.com/watch?v=sMllOlxVgD0&t=0s) Teaser and Introduction
The episode opens with Brian Kernighan marveling at the astonishing speed with which Ken Thompson originally brought Unix to life: in just three weeks, Thompson built himself an editor, an assembler, and an entire operating system—completely on his own. Ryan Peterman introduces Kernighan as a former member of the technical staff at Bell Labs, co-author of the seminal C programming language book, and the figure responsible for popularizing the ubiquitous "Hello World" program.
Teasing themes explored throughout the conversation, Kernighan paints a vivid picture of the singular workplace environment at Bell Labs, observing that “there were no deadlines, there were no projects, there were no objectives, goals, whatever set by other people.” Peterman also previews stories of historic computer artifacts—including a repository commit containing an unencrypted secrets file with employee passwords—and probes Kernighan on whether modern large language models are a net positive or negative for computing education, to which Kernighan wryly quips, “So who shall I insult today?”
[00:49](https://www.youtube.com/watch?v=sMllOlxVgD0&t=49s) What Bell Labs Was and How Kernighan Got Hired
Bell Labs served as the dedicated research arm of AT&T, established around 1925 on West Street in New York City after AT&T absorbed local telephone companies across the United States and recognized the need for deep fundamental research to improve telephone service. In the early 1960s, the lab relocated its headquarters roughly 25 miles west of New York City to Murray Hill in northern New Jersey. The Murray Hill facility was a massive operation housing approximately 3,000 people across a single connected set of buildings, pursuing research ranging from semiconductor physics, materials, and optical fibers to applied mathematics and an emerging interest in computing.
Kernighan’s path to Bell Labs began while he was a graduate student at Princeton University. In the summer of 1966, he interned at MIT's Project MAC, using Fernando Corbató's Compatible Time-Sharing System (CTSS) to write software for the fledgling Multics operating system. The following summer in 1967, he secured an internship at Bell Labs in Murray Hill working alongside Doug McIlroy. After another academic year at Princeton spent stalling on his doctoral dissertation, Kernighan returned to Bell Labs for a second summer internship in 1968. Collaborating with Shen Lin on a graph partitioning problem suggested by his advisor, they developed the heuristic now known as the Kernighan–Lin algorithm. Kernighan quickly wrote up his dissertation, took a single week off, and accepted a permanent offer to join Bell Labs in 1969, where he remained until 2000.
- Bell Labs was originally established around 1925 on West Street in Manhattan before moving around 1963 to a centralized campus in Murray Hill, New Jersey.
- The Murray Hill campus housed around 3,000 employees under one connected roof.
- Kernighan worked under Doug McIlroy in the summer of 1967 and partnered with Shen Lin in the summer of 1968 on graph partitioning heuristics.
[04:16](https://www.youtube.com/watch?v=sMllOlxVgD0&t=256s) Joining Bell Labs and Its Contemporary Reputation
When asked whether he weighed competing job offers after finishing his doctorate, Kernighan notes that he never even considered an alternative: “You know, I think I didn't consider any other option whatsoever.” The work was engaging, the people were kind and brilliant, and the laboratory was geographically convenient. He never sat for a formal interview; instead, he describes his hiring as falling smoothly along the natural line of gravity. His transition was smoothed by informal academic networks between Princeton and Bell Labs, along with a sterling precedent set by another Princeton student who had excelled at MIT the year prior.
At the time, Bell Labs held immense prestige across the broader scientific community. In the physical sciences, it was an undisputed powerhouse, having birthed the transistor, pioneered information theory, and invented error-correcting codes. Crucially, Bell Labs was not an insular corporate redoubt; its researchers published openly in premier academic journals, presented at key conferences, and collaborated directly with university faculty. While its mathematical talent focused primarily on applied rather than pure theory, the lab was widely recognized across academia as an elite institution at the scientific frontier.
```mermaid
flowchart TD
accTitle: Evolution of AT&T Bell Labs Research Culture
accDescr: Diagram showing the pipeline of Bell Labs research from monopoly funding down to legendary scientific breakthroughs and recruitment.
subgraph Culture ["Lab Environment & Autonomy"]
B --> C["Long-Term Horizon (2–3 Year Explorations)"]
C --> D["High Tolerance for Failure & Iteration"]
D --> E["Open Academic Publishing & Collaboration"]
end
subgraph Output ["Breakthrough Innovations"]
E --> F["Transistors & Semiconductors"]
E --> G["Information Theory (Shannon)"]
E --> H["Error-Correcting Codes (Hamming)"]
E --> I["Modern Computing & Unix"]
end
```
[06:34](https://www.youtube.com/watch?v=sMllOlxVgD0&t=394s) The Economics Behind Bell Labs' Inventions
Addressing why a single corporate entity produced so many profound foundational technologies, Kernighan highlights the unique financial architecture of AT&T as a regulated public monopoly. AT&T provided telephone service to roughly 80% or more of the United States. In exchange for agreeing to universal service obligations—providing phone lines even to remote rural areas—and accepting government-mandated caps and regulatory oversight on service rates, AT&T was granted a predictable, legally protected rate of return on its capital investments.
This structure allowed AT&T to skim a modest percentage—roughly 1% to 2% of reliable national revenues—to bankroll open-ended fundamental research. Free from quarterly market pressures and direct competitors, management could grant researchers extraordinary latitude. Scientists were free to pursue speculative research paths for two or three years without immediate commercial justification, operating on the principle that even if individual projects proved fruitless, an aggregate collection of exceptional minds would consistently yield discoveries of immense societal and practical value.
- AT&T operated as a regulated public monopoly serving roughly 80% of the United States population.
- Regulators guaranteed a fixed return on capital in exchange for universal telephone access across the country.
- A steady 1% to 2% slice of recurring revenues was allocated directly to Bell Labs research without demanding short-term product turnaround.
[08:53](https://www.youtube.com/watch?v=sMllOlxVgD0&t=533s) Recruiting Talent and the Early Days of Computer Research
When evaluating why top-tier talent gravitated toward Murray Hill, Kernighan points out that for top graduates in physical sciences or mathematics during the 1950s and 1960s, career pathways outside university faculties were largely confined to government facilities, IBM, or Bell Labs. Bell Labs stood out because of its towering intellectual pedigree, housing legends such as Claude Shannon, Richard Hamming, Hendrik Wade Bode, and Harry Nyquist. Joining Bell Labs meant joining the international scientific vanguard rather than disappearing into proprietary obscurity.
When Kernighan arrived in 1969, computer science was still in its relative infancy, and it was not yet clear who the defining heroes of software engineering would be. Computing had not yet achieved the historical renown of the lab’s physics and communications divisions, but it inherited the same intellectual freedom, generous institutional backing, and collaborative culture that had made the lab's earlier engineering breakthroughs possible.
[10:43](https://www.youtube.com/watch?v=sMllOlxVgD0&t=643s) Meeting Dick Hamming and the Emergence of Computer Science
When asked whether researchers in those early days were viewed as legendary computer scientists or simply team leads, Brian Kernighan reflects that back then, “it's not even clear what a computer scientist is.” To illustrate the casual brilliance that permeated the halls, he recalls his first internship at Bell Labs in the summer of 1967. Due to a lucky clerical quirk, he was assigned a private office of his own—a perk virtually unheard of for an intern. Around 11:00 AM on his very first day, feeling completely lost about what he was supposed to do, an older man strolled past his open door and casually said, “Hi, I'm Dick. Let's go to lunch.” Kernighan agreed, enjoyed an easy conversation over a meal, and only discovered who his companion was upon checking the nameplate on the adjacent door afterward: it was Richard Hamming, author of the very numerical analysis textbook Kernighan had used the previous semester, creator of Hamming error-correcting codes, and soon-to-be Turing Award winner.
The exchange highlights how unpretentious the environment was at a time when computing had not yet developed a formalized academic discipline, reward system, or widespread institutional prestige. Ryan Peterman notes that Leslie Lamport once made a similar observation about computing lacking the respect given to mathematics or physics. Kernighan agrees, sharing that when he entered graduate school at Princeton in 1964 under electrical engineering, the department was bifurcated: senior, highly esteemed faculty worked on traditional topics like information theory, communications, and solid-state physics, while an energetic cohort of fresh degree-holders wanted to explore computing. Because the department elders did not grasp the fledgling field, Kernighan suspects none of those young pioneers secured tenure at Princeton at the time. His own initial technical advisor for a year was John Hopcroft, who, though Kernighan laughingly admits it quickly became apparent that he was not cut out for theoretical work, eventually won a Turing Award and served as Dean of Engineering at Cornell University.
- Brian Kernighan began at Bell Labs as an intern in the summer of 1967, accidentally scoring a private office.
- Richard Hamming casually invited the bewildered intern to lunch on his very first day.
- John Hopcroft served as Kernighan's first graduate advisor at Princeton before pursuing his distinguished theoretical career at Cornell.
[14:16](https://www.youtube.com/watch?v=sMllOlxVgD0&t=856s) A Day in the Life of a Member of Technical Staff
Kernighan points out that personnel in their department never referred to themselves as "engineers" because they were not truly engaged in conventional engineering; instead, everyone shared the broad title Member of Technical Staff (MTS). A typical day lacked any semblance of regimentation. Researchers arrived at their leisure—anywhere between 8:00 AM and 2:00 or 3:00 PM—and worked in private offices with the doors left wide open. The workday was centered on thinking, programming, or wrestling with proofs, frequently interrupted by spontaneous blackboard debates with colleagues passing by in the halls. Employees strolled the facility's famously long corridors to grab coffee, ran into peers from other disciplines, and attended internal or external technical talks held every week or two.
The environment closely resembled that of a premier university, but with one critical distinction: there were no students. Kernighan views this absence as a double-edged sword. On one hand, researchers had 100% of their time to pursue self-directed work alongside towering peers such as Ken Thompson and Dennis Ritchie without instructional duties. On the other hand, they missed out on the unique intellectual spark and questioning that incoming students bring to research—though Kernighan quips that when he first arrived, he was supposed to fulfill that role of the "bright new young person."
[16:31](https://www.youtube.com/watch?v=sMllOlxVgD0&t=991s) Management, the "I Am Great" Report, and Merit Reviews
Unlike modern tech corporations driven by sprint deadlines, quarterly milestones, and granular project goals, Bell Labs imposed no external schedule on researchers. To explain how the organization prevented people from merely coasting, Kernighan describes their annual evaluation ritual. Once a year, every researcher had to summarize their accomplishments on a single side of a single piece of paper, an exercise universally dubbed the "I am great" report.
```mermaid
flowchart TD
accTitle: Bell Labs Annual Performance and Merit Review Process
accDescr: A hierarchy illustrating how one-page self-reports flowed into peer-based management evaluations and merit pool distribution.
subgraph Input["Researcher Level"]
A["Single-page summary<br/>('I am great' report)"]
end
subgraph Evaluation["Collegial Evaluation"]
B["First- & second-level managers meet<br/>(~30 reports reviewed in a small group)"]
C["Evaluate deep technical merit<br/>(Distinguish substance from fluff)"]
D["Rank order into peer<br/>equivalence classes"]
end
subgraph Compensation["Annual Compensation"]
E["Raise Pool (x%) allocated:<br/>x + ε or x - ε without bonuses"]
end
A --> B
B --> C
C --> D
D --> E
```
First- and second-level managers would gather in a room to review approximately thirty reports from their branch of the organizational tree. Because these managers were former researchers who remained technically active and deeply knowledgeable, they evaluated the substance of the work rather than superficial productivity metrics. Kernighan underscores why this technical literacy was indispensable:
> “If you are not technical enough to understand what they're talking about, it's hard for you to tell the [bullshit] from the actual useful content, right?”
Management took an intentionally patient view. If an ambitious project did not pan out over a couple of years or remained an ongoing work in progress, it was fully supported; only total inaction over extended periods raised alarms. The dynamic among managers was collegial rather than competitive: managers advocated for each other's team members rather than fighting for territory. The process established qualitative equivalence tiers, which then mapped to a single raise pool where individuals received slight variations around the department average percentage (an `x + ε` or `x - ε` adjustment), free of executive bonus games. When Peterman notes that the modern "Member of Technical Staff" title is often used as a status symbol, Kernighan emphasizes that Bell Labs was entirely egalitarian: everyone operated strictly on a first-name basis, stripping away formal titles, doctoral honors, and corporate hierarchies.
[21:13](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1273s) The Flat Hierarchy of Bell Labs and Why Promotions Were Avoided
In research at Bell Labs, nearly everyone held the title of Member of Technical Staff (MTS). While there was an array of supporting roles—such as lab technicians and associate members of technical staff—an MTS was roughly equivalent to a Principal Investigator (PI) in modern academia. In computing, researchers worked largely on their own without dedicated assistants; a physicist, by contrast, might oversee several people to run physical experiments or handle materials deposition.
Above the MTS level, management remained remarkably flat: first-level management consisted of department heads, followed by directors at the second level, executive directors, and vice presidents. Despite these tiers, researchers actively avoided moving up the ladder because management was widely viewed as a dead end for one’s hands-on work. As Brian Kernighan explained:
> “Most people did not want to be promoted because that would be seen as the end of their personal technical career that it would move them away from the kind of work that they really enjoyed doing.”
Being promoted was something researchers deliberately resisted during the golden era spanning the late 1960s through the early 1980s. When Ryan Peterman asked whether peers ever discussed personal “career development,” Kernighan recalled never giving it a second thought for himself. He was having a good time surrounded by brilliant colleagues. When he eventually stepped into first-level management as a department head, the role was not about issuing top-down directives. Instead, a manager's duty was to understand their team's technical work thoroughly enough to represent them fairly during annual merit reviews, spot opportunities to connect peers working on complementary problems, and provide constructive feedback to nudge people toward success. As Kernighan described the environment:
> “There was never any this is what you have to do. there was no no uh there just wasn't any it wasn't guidance at all at most there was a gentle gravitational pull towards stuff that would be useful or interesting.”
A few individuals did have ambitions for management, but the flat structure in research offered very little upward mobility. Those wanting conventional corporate advancement typically transferred to the development organizations, where traditional management hierarchies and rules of engagement applied. By contrast, managing research staff was notoriously impossible; Kernighan quipped that research was “much more a bunch of cats and you can't really hurt them.”
```mermaid
flowchart TD
accTitle: Bell Labs Research Organization Structure
accDescr: A diagram illustrating the flat hierarchy of Bell Labs research alongside the development organization track.
VP --> ED
ED --> DIR
DIR --> DH
DH --> MTS
MTS -.->|"support staff (primarily physics)"| TECH
end
subgraph Dev["Development Division"]
DMGMT["Traditional Hierarchical Management"]
MTS -->|"transfers seeking conventional career advancement"| DMGMT
end
```
---
[25:16](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1516s) Becoming a Manager and Recognizing an Exceptional Group
Kernighan had zero ambition to join management and turned down early blandishments to head departments elsewhere in research, believing his own group was uniquely special. Eventually, leadership targeted him to run his own unit, deploying classic, contradictory management persuasion: arguing on one hand that management was inevitable so he might as well take it, while warning on the other that if he passed it up, the opportunity might never return—or worse, someone less capable would be put in charge. Kernighan finally relented around 1981, roughly twelve years after joining Bell Labs.
As a department head, Kernighan managed around ten people, including Bjarne Stroustrup, while working alongside luminaries like Dennis Ritchie and Ken Thompson. The management role brought a significant drop in personal enjoyment: he had to sit through more meetings, monitor projects that spanned diverse subfields, and articulate others' work across the company.
When Peterman asked how Kernighan knew his group was so extraordinary at the time, Kernighan admitted that they had no foresight about who would eventually win Turing Awards. The recognition came simply from daily practice:
- The researchers were visibly brilliant and worked on problems that were genuinely interesting and useful.
- Team members relied on the very tools their colleagues were inventing; the Unix operating system, its programming languages, and its utilities formed their daily computing environment.
- Colleagues could immediately gauge the value of someone’s work because they were its first end users.
---
[27:56](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1676s) Ken Thompson: The Three-Week PDP-7 Feat
When asked who possessed the most untouchable technical chops, Kernighan immediately pointed to Ken Thompson:
> “Ken Thompson's the obvious one. I think certainly the best programmer I've ever met, unparalleled.”
Kernighan recounted the legend of how the first version of Unix came to life in 1969. Thompson had access to an obsolete Digital Equipment Corporation PDP-7, a primitive minicomputer equipped with only 8k of 18-bit words. Thompson had been experimenting with disc scheduling algorithms to make disk operations run faster. When his wife took their young son to visit family in California for three weeks, Thompson seized the quiet window. Working completely alone in assembly language, without modern conveniences or high-level languages, he wrote code on another host machine with a text editor, punched it onto paper tapes, carried the tapes over to feed the PDP-7, and ran tests. In just three weeks, Thompson single-handedly created:
- An editor
- An assembler
- A fully functional operating system
When Peterman marvelled at how anyone could pull that off without the internet or Stack Overflow, Kernighan laughed, noting: “Because he's a boatload smarter than you and I put together.”
---
[30:03](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1803s) Doug McIlroy: The Master Critic, Toolmaker, and Visionary
Kernighan emphasized that Thompson was not an isolated genius; Bell Labs had an entire cadre of off-scale talent, prominently including Doug McIlroy. McIlroy served as Kernighan's mentor during his first summer internship at Bell Labs. McIlroy initially assigned him to work on memory storage allocators (similar to `malloc`), but Kernighan almost immediately drifted to a completely different project. McIlroy never objected, and Kernighan was invited back for a second summer.
McIlroy's intellect earned the highest possible praise within Bell Labs; as Kernighan highlighted, “Ken Thompson says Doug's the smartest person he ever met.” McIlroy possessed a unique gift for constructive technical critique. He served as the external reader on Kernighan’s Princeton PhD dissertation, vastly improving both its prose and technical substance, an editorial mentorship he sustained across his life. Beyond mentoring, McIlroy was a prolific pioneer who directly created foundational software and computing concepts:
- Authored essential Unix tools, including `sort` and `diff`.
- Contributed to programming language design, writing one of the very first PL/I compilers.
- Invented the concept of macro processors in programming.
- Served as the department head who supported and created space for Ken Thompson, deftly guiding without ever telling him what to do.
[31:48](https://www.youtube.com/watch?v=sMllOlxVgD0&t=1908s) Richard Hamming: A Department Head with No Reports
Brian Kernighan reflects on the legendary figures of Bell Labs, recalling Richard Hamming. Ryan Peterman notes having read that Kernighan once worked alongside a department head who remarkably had zero direct reports. Kernighan confirms that this was indeed Hamming. When Kernighan first met him around 1967, he could tell Hamming was a department head because his office had carpet on the floor and he was listed as such in the company phone directory. Kernighan admits he initially held a naive assumption that management status came from supervising people, but Hamming had purposefully engineered his role differently: he worked hard to attain the title and organizational clout of a department head so he would not be brushed aside, but completely bypassed the administrative overhead. As Kernighan explains, in any large organization an ordinary Member of Technical Staff (MTS) could easily be ignored, whereas a department head commanded respect and leverage without being saddled with administrative "dog work."
Hamming had certainly paid his dues, having arrived at Bell Labs around 1946. He was an early pioneer in computing who foresaw that computation would fundamentally reshape scientific research across every discipline. He boldly predicted that more than half of future research would be carried out on computers rather than inside physical laboratories—a forecast for which his contemporaries famously ridiculed him at the time.
- Richard Hamming joined Bell Labs in roughly 1946 and stayed until his retirement in the mid-1990s.
- In Bell Labs corporate hierarchy, executive perks like office carpeting signaled managerial standing.
- Hamming secured the clout and audience of a department head without having any subordinates reporting to him.
---
[33:50](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2030s) Explaining Unix in AT&T Public Relations Films
Peterman brings up an archival AT&T promotional film available on YouTube titled *UNIX: Making Computers Easier to Use*, where a young Kernighan is seen casually leaning back with his feet up on a desk, explaining technology to the camera. Kernighan explains that AT&T routinely produced these public relations films to persuade the general public and business communities that the company was an innovative, benevolent institution contributing to the public welfare. A professional filmmaker, Eric Belove, was brought in during the late 1970s or early 1980s to interview staff in natural conversations and splice the footage into an engaging, accessible story.
Around that period, Unix was beginning to gain visibility outside Bell Labs, and AT&T wanted to showcase how it improved computing and daily operations. Kernighan’s assignment was to serve as the bridge between technical engineers and everyday viewers, demystifying Unix and articulating why it was novel and practical. When Peterman notes that viewers often contrast Kernighan's clear communication style with the stereotypically awkward computer nerds in the video, Kernighan credits empathy and feedback:
> “Part of it is probably just putting yourself to some extent into the other person's shoes.”
He emphasizes finding the right metaphors and concrete examples for audiences who have zero background in the subject, adding that teaching in person is far easier because you can immediately gauge whether people understand and adapt on the fly, whereas film offers no real-time feedback.
---
[36:55](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2215s) VIP Demos and the CIA Director's Faked Pipeline
Kernighan and Mike Lesk were on a regular rotation conducting what were colloquially known as "dog and pony shows"—guided tours and demonstrations for visiting dignitaries and high-ranking corporate executives brought through Bell Labs. Kernighan would host these VIPs in a small room, have them sit on a couch, and showcase the power of Unix. His signature demonstration highlighted Unix pipes: chaining small, modular programs together so the output of one flowed directly into the input of the next. To make the concept intuitive, he showed a spell-checking pipeline that parsed a document into individual words, mapped them to lowercase, sorted them, and compared them against a dictionary file to isolate unrecognized words.
```mermaid
flowchart LR
accTitle: Unix Spell-Checking Pipeline
accDescr: Flowchart showing how Unix utilities were combined using pipes to build a spelling checker demo.
subgraph Ingest["Text Processing"]
Doc["Document"] --> Collect["Extract Words"]
Collect --> Lower["Convert to Lowercase"]
Lower --> Sort["Sort & Uniq"]
end
subgraph Compare["Spell Check"]
Sort --> Diff{"Compare"}
Dict["System Dictionary"] --> Diff
Diff --> Errors["Flagged Misspellings"]
end
```
The most memorable of these demos occurred when William Colby, the Director of the CIA, visited Bell Labs alongside Bill Baker, the president of Bell Labs who also chaired the President’s Foreign Intelligence Advisory Board. Colby arrived with a security escort who literally had a briefcase handcuffed to his wrist—sparking quiet jokes among staff about whether it contained nuclear launch codes or secret weapons. Knowing from experience that running the spelling pipeline live on the era's slow hardware took far too long, Kernighan took a pragmatic shortcut: the night before, he pre-computed the results into a file. During the demo, he ran a simple shell script that executed `sleep 2` before invoking `cat` on the saved output. Colby left thoroughly impressed by the lightning-fast speed of Unix. As Kernighan wryly observes:
> “I guess it does tell you you don't believe what you see in demos.”
---
[39:46](https://www.youtube.com/watch?v=sMllOlxVgD0&t=2386s) Why C Succeeded: The Sweet Spot of Efficiency and Expressiveness
Addressing the enduring impact of the C programming language and the landmark book he co-authored with Dennis Ritchie, Kernighan evaluates why C became so singularly influential. He argues that C struck a rare balance between low-level performance and human readability:
> “I think it hit a sweet spot in some sense of efficiency and expressiveness.”
When Dennis Ritchie developed C around 1972, computing hardware was severely constrained. The Digital Equipment Corporation PDP-11 on which C originally ran was equipped with just 24 kilobytes of memory and a half-megabyte disk. The machine had to hold the operating system, the compiler, and file buffers simultaneously. Because of these extreme hardware limitations, C had to remain compact and transparent: a programmer could easily mentally map a C statement directly onto the corresponding machine instructions of the PDP-11.
C avoided runtime overhead, garbage collection, and heavy safety checks simply because there was no memory or CPU budget to spare for them. Furthermore, its original design goal was narrow and practical: writing the Unix operating system itself, which did not require non-essential language abstractions. This generated a powerful symbiosis between Unix and C. Unix offered an environment far more productive, elegant, and enjoyable than competing commercial operating systems of the day, and developers adopted Unix—and by extension C—because it made computing genuinely fun.
- First PDP-11 environment for C: roughly 24 kilobytes of main memory and a 0.5 MB hard drive.
- C omitted extensive runtime checks to conserve precious memory footprint and CPU cycles.
- The symbiotic growth of Unix and C created a self-reinforcing developer ecosystem that displaced clumsy vendor operating systems.
Ryan Peterman introduces episode sponsor WorkOS, noting that companies like OpenAI, Anthropic, and Cursor use it to simplify adding enterprise-grade capabilities. The platform provides APIs for single sign-on (SSO), SCIM directory sync, and role-based access control (RBAC)—features required by enterprise buyers that can distract developers from core product features. Peterman highlights several newer WorkOS capabilities designed specifically for AI agents:
- **Auth for Agents:** Assigns an independent identity to each agent using short-lived, scoped tokens rather than long-lived API keys, ensuring that revoking a single session terminates everything operating underneath it.
- **Airlock:** An authorization layer that validates every agent action against human-readable rules written in plain English, preventing unsupervised execution and unvetted approvals.
- **Pipes:** Connects agents to over 300 third-party tools while abstracting away manual token management.
---
[04:43:39](https://www.youtube.com/watch?v=sMllOlxVgD0&t=17019s) The Origins of awk and Building for One's Own Needs
Peterman reflects on learning foundational Unix tools in college, including Douglas McIlroy's `diff`, `grep`, and `awk`, asking Kernighan to share the backstory of how awk came into existence. Kernighan explains that the project took shape around 1976–1977 out of converging interests among three Bell Labs researchers:
- **Al Aho:** A longtime friend since their undergraduate days at the University of Toronto (where Aho was a year ahead) who went on to Princeton and was deeply interested in regular expressions and text pattern recognition.
- **Brian Kernighan:** Had been experimenting, mostly unsuccessfully, with designing a text editor capable of manipulating numbers as seamlessly as text.
- **Peter Weinberger:** Brought an interest in database structures, report generation, and systems like IBM's RPG (Report Program Generator).
```mermaid
flowchart TD
accTitle: The Creation of awk at Bell Labs
accDescr: Diagram illustrating the contributions of Aho, Kernighan, and Weinberger to the initial implementation of awk.
Their goal was to create a tool where strings and numbers were treated as equal, first-class citizens. After collaborating on the design, Weinberger built the prototype over a single weekend. Kernighan emphasizes that Weinberger was not only a gifted programmer but also heavily leveraged Bell Labs' emerging tooling ecosystem: Steve Johnson's compiler-compiler Yacc, Mike Lesk's lexical analyzer generator Lex, and Aho's existing regular expression routines from `egrep`. After roughly five to ten years, Aho and Weinberger stepped back from day-to-day maintenance, leaving Kernighan to shepherd the language forward.
Peterman asks if most legendary Unix utilities originated this way—programmers feeling an itch and writing a tool rather than designing for hypothetical users. Kernighan confirms this pragmatic genesis:
> "It's not from hypothesizing what somebody else might find useful. It's more like my what do I need? it's kind of bothering me at this point that I could improve if I just had a better tool or a language or something."
As a prime example, he points to Stu Feldman's creation of `make`. A colleague complained about an unexpected bug, realizing, *"Oh, it's because I forgot to recompile one of the files."* Feldman automated the dependency tracking in another weekend project. The catch with such rapid success, Kernighan notes, was adoption outrunning revision:
> "And then, boy, within a few days, he's got a bunch of users. And then all of the mistakes he made in his first design he can't fix."
Addressing Unix naming conventions, Kernighan clarifies the source of `grep`. While Ken Thompson tells the story best, the utility's name maps directly to the line-editor command in `ed`: `g/re/p`, meaning perform a **g**lobal search for a **r**egular **e**xpression and **p**rint the matching lines.
---
[04:48:41](https://www.youtube.com/watch?v=sMllOlxVgD0&t=17321s) What Bell Labs Lost and the Era of Low-Hanging Fruit
Looking back at his decades at Bell Labs, Kernighan reflects on the unique environment and what made it irreplaceable:
> "Well, I miss the people. Although I'm still in contact with a fair number of them one way or another. Um but the people were it was just an amazing collection of really good nice people, bright, fun to work with, lots of good ideas and so on."
Beyond the collegiality, he misses the historical window of opportunity. Computing was young, creating an abundance of unharvested, foundational ideas—an "era of low-hanging fruit." While Kernighan demurs that he is no longer in the right intellectual circles to pinpoint modern equivalents, he muses that rapid advancements in AI might offer a similar greenfield today.
The decline of that golden era followed corporate upheaval. As AT&T weathered regulatory and market challenges, it repeatedly spun off business units. The resulting entities were smaller, the research division grew fragmented, and funding dwindled. Scientists were ultimately forced to spend time justifying budgets and raising capital—a development Kernighan describes as the antithesis of the original research culture:
> "So that part I don't miss at all."
---
[04:50:04](https://www.youtube.com/watch?v=sMllOlxVgD0&t=17404s) Beard Trimming in Harvard's CS50 and Conquering Stage Fright
Peterman brings up an archival video circulating on YouTube from Kernighan's guest-teaching days, asking why he was filmed trimming his beard during a university lecture. Kernighan laughs, recalling that David J. Malan (who later built CS50 into an international phenomenon) was actually an undergraduate in that hall.
The incident took place in September 1996, during Kernighan's first lecture filling in for Margot Seltzer while she was on sabbatical:
- Seltzer traditionally opened CS50 by demonstrating the precision needed to program a computer by having the audience give step-by-step instructions for making a peanut butter and jelly sandwich—invariably resulting in jelly on the desk or peanut butter smeared on someone's head.
- Not being a fan of peanut butter and jelly, Kernighan adapted the demonstration to fit his own appearance: *"I have this ratty beard."*
- He carried an assortment of grooming tools onto the stage, ranging from ordinary hand scissors to a full-sized electric hedge trimmer, and challenged the room to command his grooming without injuring him. He notes wryly that the hedge trimmers were indeed plugged in.
Teaching that 450-student CS50 course was Kernighan's first encounter with a lecture of that scale. However, he had already overcome the dread of public speaking decades earlier at Bell Labs. During his early years, neighbor Vic Vyssotsky asked if he would teach an introductory Fortran class to a group of staff physicists. Working through that Fortran seminar burned away his stage fright entirely. By the time he stepped in front of hundreds at Harvard, the venue size no longer mattered:
> "David Malan can tell you that more accurately because he's really good at it."
[53:09](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3189s) Teaching, Overcoming Stage Fright, and the Impact of LLMs on Education
Reflecting on public speaking, Brian Kernighan explains that the only real way to conquer anxiety is simply forcing oneself to do it repeatedly, beginning in small groups before moving to larger audiences. While conference presentations offer one forum, he finds teaching far superior because of its intimacy, even when addressing large lectures of over 400 students. In a lecture setting, an instructor can gauge whether the room is tracking the material. He shares practical speaking techniques: viewing the audience as friends, slightly blurring one's vision so it seems like direct eye contact without fixating on anyone, or locking onto a single receptive individual who appears to be resonating with the talk. With sufficient practice, worry naturally recedes.
```mermaid
flowchart TD
accTitle: Shifts in CS Higher Education via LLMs
accDescr: Diagram showing how LLMs lead to reduced office hours and enrollment shifts toward hardware disciplines.
subgraph ClassroomImpact["Classroom Dynamics"]
LLM["Adoption of LLMs (e.g., Claude)"] -->|"Instant answer retrieval"| NoOfficeHours["Drop in office hours visits"]
NoOfficeHours --> LostConnection["Loss of high-bandwidth human contact & serendipitous job/research leads"]
end
subgraph EnrollmentShift["Major Decisions"]
AIFear["Concerns over AI replacing pure programmers"] --> DropCS["CS enrollments down by 50% to 60%+"]
DropCS --> ShiftEng["Students pivot to hardware & physical fields: ECE, MechE, Aerospace (Robotics)"]
end
```
Turning to modern education at Princeton, Ryan Peterman asks whether large language models and instant AI answers are ultimately a net positive or negative. Kernighan remarks that “it's too early to tell,” but highlights one immediate downside widely observed by faculty: students have largely stopped attending office hours. Bypassing human preceptors, graduate students, and professors to consult tools like Claude strips away high-bandwidth communication and serendipitous opportunities. Kernighan observes: “The bandwidth when you're talking to somebody in person is enormously higher than when you're talking to Claude or whatever.” When students skip face-to-face interaction, faculty cannot get to know them personally or pass along job openings and research opportunities.
- Office hours visits have cratered across departments as undergraduates consult LLMs rather than instructors.
- Kernighan stresses that the informal, non-transactional human contact of office hours is vital for future career networking.
---
[55:51](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3351s) The Drop in Computer Science Enrollments
A surprising second-order effect of the AI boom at Princeton is a sharp downturn in computer science majors. While overall Princeton undergraduate enrollment remains completely fixed, students are “voting with their feet” by pivoting away from pure software. Kernighan estimates that while the graduating class in the spring of 2026 numbered slightly over 200 CS majors, the cohort graduating two years later will likely drop to fewer than half—perhaps down to 80 or 90 students, representing a potential two-thirds reduction.
Many of these undergraduates are moving into Electrical and Computer Engineering (ECE) or Mechanical and Aerospace Engineering (MAE), drawn toward robotics and hardware fields perceived as far less vulnerable to automation by generative models. While Kernighan acknowledges media narratives claiming human programmers are obsolete, he considers that framing “oversimplified,” even if student anxiety about post-graduation job markets is entirely justifiable. A modest silver lining for faculty is that smaller class cohorts afford more meaningful individual contact with the remaining students.
- Princeton's total student body remains constant, but departmental distribution has dramatically rebalanced.
- CS majors dropped from over 200 in the class of 2026 to an estimated 80–90 two years out.
- Hardware-centric fields (ECE and mechanical/aerospace engineering) have gained students due to perceived insulation from AI displacement.
---
[58:20](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3500s) Cameo in *A Beautiful Mind* and Meeting John Nash
Around 2001, shortly after Kernighan and his wife relocated to Princeton, Ron Howard's production team held an open casting call on campus for extras in *A Beautiful Mind*. Hundreds gathered in a large lecture hall, where a casting director wandered the aisles selecting participants. Kernighan was picked—while his wife was bypassed, a choice Kernighan jokingly calls “nuts.” He was subsequently cast as an attendee at the Nobel Prize ceremony scene, which was filmed inside the New Jersey Performing Arts Center in Newark.
The shoot lasted 22 grueling hours, beginning around 5:00 a.m. Kernighan notes that viewers cannot easily spot him because background actors were forbidden from wearing reflective eyeglasses, and he was outfitted in formal black tie—attire he had never previously worn. The gig paid modest non-Equity wages, leading him to joke that he would have earned more flipping burgers at McDonald's. However, the role gave him an Erdős–Bacon number of 5 (an Erdős number of 3 via co-authorship paths, and a Bacon number of 2 through an actor who shared the screen with Kevin Bacon).
Later, Kernighan encountered the real John Nash on several occasions around Princeton. Though Nash was notoriously introverted, Kernighan recalls one terrifying encounter: ten minutes into delivering an internal mathematics department lecture, Kernighan was hitting his stride when John Nash unexpectedly strolled into the room. Kernighan remembers: “I could just feel everything tightening up inside.” Nash asked a question during the presentation, and though Kernighan cannot recall the specific query, he managed to compose himself and finish.
- Filming took place over roughly 22 hours at the New Jersey Performing Arts Center (NJPAC) in Newark.
- Kernighan is uncharacteristically dressed in black tie and lacks his trademark glasses to prevent set-lighting glare.
- Kernighan holds an Erdős–Bacon number of 5 (Erdős number of 3, Bacon number of 2).
---
[01:01:46](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3706s) The Mythical 1972 Go Commit and the Evolution of Version Control
Ryan Peterman brings up a curious programming trivia item: the official Git repository for the Go programming language features a first commit backdated to 1972 authored by Brian Kernighan, containing an early “Hello World” program in B, followed by 1974 commits converting it to C and ANSI C. Kernighan reacts with complete surprise: “Yeah, right. I have no idea what this is.” He clarifies that he had no involvement with that Git repo, noting that he did not even start using Git until roughly ten years ago, and suspects Go co-creator Robert Griesemer or the Go team imported his vintage tutorial code as a historical homage.
This sparks a discussion on the emergence of version control systems. Kernighan points out that in 1972, Git did not exist, and Unix itself was not running that particular early B program. True version control did not appear until the mid-1970s, starting with Marc Rochkind's Source Code Control System (SCCS) within the Programmer's Workbench project at Bell Labs. That was succeeded by Walter F. Tichy's Revision Control System (RCS), followed by the Concurrent Versions System (CVS), later centralized systems, and ultimately distributed tools like Git.
```mermaid
flowchart LR
accTitle: Evolution of Version Control Systems
accDescr: Historical progression of version control tools from mid-1970s SCCS to modern Git.
- The 1972 Go repo commit was constructed retroactively by the Go team using Kernighan's B tutorial code; Kernighan only adopted Git in the 2010s.
- SCCS was created at Bell Labs in the mid-1970s as part of the Programmer's Workbench initiative.
- RCS (developed by Walter F. Tichy) and CVS followed as standard version control milestones before Git's dominance.
[01:03:45](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3825s) Grace Emlen and the Bell Labs Badge Insurrection
Ryan Peterman brings up a detail he noticed in Brian Kernighan's memoir: an acknowledgment thanking someone named "Grace Emlen." After digging further into a Bell Labs alumni tracker that records where former employees moved on to, Peterman discovered that Grace Emlen's entry humorously read: "relocated witness protection program."
Kernighan laughs and explains that this was born out of an act of workplace rebellion. At one point, Bell Labs management mandated that all employees had to wear identification badges so guards and colleagues could tell legitimate staff apart from random visitors walking the halls. The researchers resented this bureaucratic imposition:
> “And people were not very enthused about wearing badges. And so there was a bunch of kind of quiet insurrection about it. And one of the bits of insurrection was the creation of badges that were fakes.”
Grace Emlen was an entirely fictitious creation, likely invented by Fred Gramp, playing on the word "gremlin." The staff went so far as to create a small gremlin-like figure, attach an official badge to her, and seat her permanently inside the Unix room. They even managed to insert her name into various official corporate records.
Subverting badges became a widespread sport among the staff. Kernighan himself wore a badge featuring Mickey Mouse:
> “Nobody looked at the badges. They just see a blur and there was a badge, so it was okay.”
Kernighan wore his Mickey Mouse badge everywhere, including during a meeting with Bill Gates, who never seemed to notice. Peterman asks whether the badge system was digital back then, but Kernighan clarifies it was entirely low-tech—paper slips inserted into plastic holders, making it trivially easy to slip a customized picture over the official insert.
[01:06:10](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3970s) Cracked Historical Passwords and Early Security
Peterman mentions another historical artifact found online: an old Unix repository containing an encrypted secrets file from Bell Labs. Because the file had been encrypted using the outdated DES algorithm (or early crypt tools), modern computing power made brute-forcing it trivial, eventually revealing the plain-text passwords of many early Unix pioneers. Peterman reveals that Kernighan’s password was simply `/.,/.,`—a pattern chosen purely because it was effortless to hammer out on a keyboard.
Kernighan is amused, remarking that former Bell Labs colleague and Google CEO Eric Schmidt had recently emailed several of them asking, “Gee, did you see this?” Kernighan notes that the system was likely encrypted using either DES or an algorithm modeled after a World War II cipher machine like a Hagelin machine, which early Unix `crypt` was based on. Kernighan defends their lax password habits:
> “In our defense, this was at a time when the machines weren't [networked] and the passwords were kind of why would you need them anyway sort of thing.”
Because network security was non-existent and machines were isolated, no one took passwords seriously. Kernighan suspects the leaked file originated from an old Berkeley tape, where someone had copied the research Unix password file from Murray Hill to a UC Berkeley system decades ago.
[01:07:39](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4059s) The Compulsion to Write Books and *Shifts*
Moving toward the end of the conversation, Peterman asks Kernighan about his prolific writing career. Beyond co-authoring *The C Programming Language* (K&R), Kernighan has written dozens of foundational books. Kernighan explains that writing scratches the same itch as teaching:
> “Trying to explain stuff to people who are not experts in it. In some way, I find that attempt to communicate rewarding, worthwhile. Um, it's a way to have influence at a distance perhaps. So, teaching is kind of retail. You're in the same room with a bunch of people. Writing a book is wholesale if you like.”
He recalls an ancient conversation with Donald Knuth, who remarked that there are people who have written no books, people who have written one book, and people who have written many books; Kernighan falls squarely into the last group.
Peterman invites him to do a commercial plug for his newest work. Kernighan points across the room to a cover lying beneath the camera for his forthcoming MIT Press book titled *Shifts: Important Ideas in Computing*, scheduled for release in January. He summarizes the book's core premise: tracing major paradigm shifts throughout the history of computing, including:
- **Analog to Digital:** A transformation without which modern digital cameras and media recording would be impossible.
- **The Stored-Program Computer:** Building a single general-purpose device capable of executing any program via arbitrary instructions.
- **Integrated Circuitry:** The hardware revolution progressing from the discrete transistor to complex ICs and modern microprocessors.
- **High-Level Programming Languages:** The journey away from tedious assembly language to higher-level abstractions that make instructing computers far more accessible.
```mermaid
flowchart TD
accTitle: Major Historical Computing Shifts
accDescr: Diagram illustrating the sequence of foundational computing paradigm shifts discussed by Brian Kernighan leading up to modern AI.
subgraph Foundational["Early Architectural Shifts"]
A["Analog to Digital"] --> B["Stored-Program Computer"]
end
subgraph Scaling["Implementation Shifts"]
B --> C["Transistors to Integrated Circuits"]
C --> D["Assembly to High-Level Languages"]
end
subgraph Frontier["Current Shift"]
D --> E["Artificial Intelligence & LLMs"]
end
```
Kernighan emphasizes that the final chapter tackles the artificial intelligence and LLM revolution, which stands apart from historical shifts because humanity is currently living right in the middle of it:
> “And then the the the final uh thing that's a big big paradigm shift that's different I think from most of the others is that we're in the middle of it and it's incredibly visible and that's the AI large language model stuff which is changing incredibly rapidly and is affecting everybody and everybody's noticing it which is different from most of the other things that we've talked about.”
He notes that even his wife, who does not come from a computer science background, is constantly asking him what LLMs mean and what the future holds, underscoring how broadly felt this particular disruption is compared to past technological leaps.
[01:11:20](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4280s) Obsolete Technologies: From Punch Cards to AI Code Generation
Peterman points out that many working software engineers now have large language models generating 100% of their production code. For people who genuinely love the craft of writing code, this transition feels bittersweet, as typing out code seems on the verge of obsolescence. Peterman asks whether Kernighan ever felt a similar sense of loss when older computing methods became obsolete during his career.
Kernighan laughs off any nostalgia for punch cards:
> “Well, I don't miss punch cards in the slightest. No way. I I was thinking, you know, my my thesis was done on my PhD thesis was done on punch cards and that was three boxes of cards and I realized that that was 30 pounds of stuff I had to carry around for my thesis.”
While heavy, cumbersome physical media are unmissable, Kernighan acknowledges that certain aspects of manual coding provide a deep intellectual satisfaction that automated tools risk removing. Currently teaching a Princeton class that involves C programming, he finds great joy returning to fundamentals like manual pointer manipulation and memory layout.
While manual memory management can be frustrating, the intellectual challenge of debugging and getting it to work is inherently rewarding. Kernighan argues that simply prompting a tool like Claude to spit out code completely removes that joy:
> “Is it there if you prompt your favorite claude or whatever to generate it for you? I don't think so. I don't think that at all.”
He adds that even when an LLM writes code, an engineer still must carefully evaluate whether it actually works, whether it is the most effective approach, and whether the prompt solved the real underlying problem in the first place—a process that still requires deep domain knowledge to navigate successfully.
[01:13:43](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4423s) The Dilemma of LLM-Generated Code and the Infinite Regress of Testing
Kernighan shares an ongoing personal use case where he relies on large language models—primarily Claude, alongside others—to generate SQL. A colleague at the Institute for Advanced Study has a database but lacks programming skills to query it effectively. To bridge that gap, Kernighan uses LLMs to translate her natural-language inquiries into SQL queries. However, this workflow introduces a fundamental validation problem: because Kernighan himself is not an SQL expert, and neither he nor his colleague knows the expected output ahead of time, evaluating whether the LLM produced a correct query is exceptionally difficult.
In practice, Kernighan finds that Claude outputs a perfectly fine query roughly 90% of the time. The remaining 10% of the time, it produces completely incorrect results, with no obvious tell to distinguish the sound queries from the broken ones. Ryan Peterman points out that domain expertise seems mandatory simply to judge output quality. Kernighan agrees, noting that modern software engineering faces an epistemological dilemma: developers cannot manually test large programs, requiring AI to help generate tests, which then demands another mechanism to verify the validity of those generated tests. Kernighan summarizes this problem sharply: “...there’s this infinite regress of you know check the checker who checked the checker kind of thing.”
```mermaid
flowchart TD
accTitle: The Infinite Regress of AI Validation
accDescr: Flowchart illustrating the recurring loop of needing AI or expertise to validate prior automated outputs.
NL["Natural Language Query"] -->|"Prompt LLM"| SQL["Generated SQL Query (~90% Correct / ~10% Wrong)"]
SQL -->|"Execution"| DB["Database Output"]
DB -->|"Requires Verification"| Test["AI-Generated Test Cases"]
Test -->|"Requires Validation"| Meta["Meta-Checker / Domain Expert"]
Meta -.->|"Infinite Regress"| Test
```
- **Outsourcing cognitive effort**: Kernighan observes that many programmers have completely outsourced their daily workflows to LLMs. While they gain massive leverage—often becoming ten times as productive in raw functional code output—Kernighan speculates that “at the same time they’re probably losing 10% of their brain cells or failing to exercise them properly.”
- **Student anxiety and job market shifts**: Princeton students actively worry whether software engineering jobs will exist by the time they graduate. Kernighan acknowledges that the role has already fundamentally shifted compared to two or three years ago and will change again shortly, leaving faculty uncertain about how best to guide students.
---
[01:16:47](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4607s) Moving Up the Abstraction Chain: From Fortran to AI
Peterman poses a hypothetical scenario: if language models eventually become perfect, what happens to computer science majors? Kernighan pushes back on the premise itself: “Well, I mean, first you you have a premise there which is that these things will become perfect and I suspect they won't become perfect although they may become a lot better than they are right now.” Consequently, humans will always be needed to judge their outputs and steer systems in sensible directions.
Rather than ending programming, Kernighan views generative AI as another rung in the historical ladder of computer abstractions. Just as modern developers rarely write assembly language or manual C because they trust optimizing compilers and higher-level runtimes, developers using LLMs will operate at a higher plane to build more ambitious software. As an example, he highlights a former student who graduated a few years prior and built a successful company leveraging LLMs for natural language translations, primarily for UI-based systems. As underlying models improve, the product automatically becomes more capable.
When Peterman asks whether programmers mourned assembly language when C emerged, Kernighan corrects the chronology, pointing back to the arrival of Fortran around 1956–1957:
- **John Backus and Fortran’s design**: Working at IBM, John Backus feared that programmers would reject Fortran if the compiled output ran slower or proved less elegant than handwritten assembly. Backus consciously bypassed syntactic elegance to prioritize raw translation efficiency.
- **The breakthrough point**: Fortran gained universal acceptance once the compiler began discovering optimizations that human assembly programmers missed.
- **Wider accessibility and portability**: Once Fortran caught on, concerns over lost assembly craftsmanship faded. Domain specialists like chemists and physicists could suddenly write programs without mastering machine-specific assembly (such as the IBM 7090), and their source code could run across different hardware architectures.
---
[01:19:58](https://www.youtube.com/watch?v=sMllOlxVgD0&t=4798s) Favorite Languages, Benchmark Reflows, and the Haskell Struggle
When reflecting on his personal language preferences across his career, Kernighan notes that for daily small tasks, he still defaults to Awk, jokingly calling it “kind of silly but okay. At least I know it.” For medium or large software projects, he turns to Python, praising its balance of expressive syntax and practical execution speed. He occasionally returns to C when maintaining legacy programs or teaching university coursework.
To compare languages systematically, Kernighan used to run a pedagogical benchmark in his classes. He implemented a simple text-reflow algorithm (wrapping arbitrary lines of text to a maximum of 60 characters, mimicking basic browser rendering) across more than two dozen programming languages:
| Language | Relative Performance & Characteristics Observed |
|:--- |:--- |
| **Awk** | Smallest implementation across the board (~15 lines of code); reasonably fast. |
| **C** | The fastest execution speed; clunky string handling; required explicit memory management. |
| **Perl** | Consistently the fastest of the scripting languages. |
| **Python / PHP** | Solid, middle-of-the-pack performance; acceptable expressiveness. |
| **C++** | Noticeably slower than expected for a compiled systems language. |
| **Java** | Ran slower than several interpreted scripting languages. |
| **Lua** | Highly approachable; Kernighan picked up the manual and implemented the program in roughly 30 minutes. |
| **Haskell** | Extremely difficult; required weeks of effort to complete. |
Explaining why Haskell proved so challenging, Kernighan explains: “It’s a different way of thinking and I just didn’t grok it I really didn't...” He points out that the reflow task involved taking variable-length input lines and generating uniform-length output lines out of phase, creating an asynchronous input-output frequency mismatch that clashed with his mental model of Haskell’s pure paradigm. Even after a Haskell expert pointed out specialized character libraries to boost performance, the paradigm remained unnatural to him. Kernighan concludes: “Now this is not a knock on Haskell. I mean there are people who love it but I'm not one of them.” Peterman then pivots to ask what still motivates Kernighan to write code today, noting his recent work adding Unicode support to the one true Awk repository.
[01:23:33](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5013s) Modernizing AWK: Adding UTF-8 and CSV Support
Brian Kernighan reflects on the ongoing intellectual challenge and pure enjoyment of programming, specifically detailing the modern improvements he recently implemented in AWK. Much of the world's text is now encoded in Unicode (specifically UTF-8), and he recognized that AWK simply did not handle it properly. At the same time, Kernighan found himself frequently working with CSV datasets, an area where AWK’s traditional whitespace-delimited processing proved extremely clunky. To solve this, he built a dedicated input mechanism so users could process CSV files cleanly and natively.
Both of these technical overhauls coincided with his work on the second edition of *The AWK Programming Language*, published just a couple of years prior. As Kernighan puts it, leaving the tool untouched was no longer an option: “in this day and age it would be really embarrassing if you couldn't handle Unicode.”
[01:24:28](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5068s) Career Advice for Young People: The Hamming Philosophy of Saying "Yes"
Ryan Peterman asks how students and early-career professionals can discover what they should work on or be passionate about, noting that Kernighan seemed to stumble into programming quickly and loved it immediately. Kernighan responds that finding your path requires aggressive exploration rather than passive isolation: “I think probably what you tell them is to go do as many different things as you can in the hope that something will resonate.” He draws an analogy to dating, pointing out that one doesn't find a life partner by sitting alone in a room thinking about it; one goes out to parties or uses apps to put themselves in environments where discovery is possible.
Recalling his time at Bell Labs, Kernighan references a conversation with mathematician Richard Hamming. Contrasting Hamming's outlook with Nancy Reagan’s famous anti-drug slogan "Just Say No," Kernighan shares Hamming's counter-advice:
> “Hamming said just say yes. Not to drugs presumably, but the idea that if somebody comes along with something and you think 'I don't know, let me try it' and applied with some common sense, that seems like a reasonable way to handle a lot of different things.”
Kernighan adds a humble caveat that individual experiences vary wildly, cautioning listeners that career and life advice should always be taken carefully when coming from him.
[01:26:15](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5175s) Life as a Galton Board and the Prepared Mind
Peterman closes by asking what advice Kernighan would give his younger self knowing everything he knows today. Kernighan conceptualizes his entire trajectory using the metaphor of a Galton board—the triangular pegboard where a marble dropped at the top bounces unpredictably off an array of nails before settling into a bin along a normal distribution curve at the bottom. He views his life choices less as master planning and more as serendipitous bounces: “I'm like a ball dropped into a Galton board and you know and I come out somewhere at the bottom. But the decisions which nail, when I hit a nail, which way do I go? I have no idea.”
However, Kernighan emphasizes that this randomness is not entirely beyond control, invoking Louis Pasteur's famous adage: “chance favors the prepared mind.” By cultivating broad curiosity, reading, experimenting, and meeting diverse people, an individual primes themselves to take advantage of unexpected collisions. Peterman summarizes that a prepared mind essentially biases the Galton board's bounces toward better outcomes, a framing with which Kernighan agrees.
```mermaid
flowchart TD
accTitle: The Galton Board Metaphor for Career Serendipity
accDescr: Diagram illustrating how an individual encounters random career opportunities like nails on a Galton board, and how mind preparation biases the outcome.
subgraph Inputs ["Exploration & Mindset"]
A["Curiosity & Diverse Experiences"]
B["Hamming's 'Just Say Yes'"]
end
subgraph Process ["The Galton Board of Life"]
C["Chance Opportunities & Encounters"]
D{"Prepared Mind Bias"}
end
subgraph Outputs ["Outcomes"]
E["Serendipitous Career Success"]
end
A --> D
B --> C
C --> D
D --> E
```
[01:27:42](https://www.youtube.com/watch?v=sMllOlxVgD0&t=5262s) Outro and Peterman's Ergonomic Keyboard Project
Peterman thanks Kernighan for his time and transitions to his closing remarks for the audience. He asks viewers to like, comment, and suggest future guests, noting that previous prominent interviewees—including Barbara Liskov, Michael Stonebraker, and Marc Brooker—were all invited as a direct result of viewer comments.
He then shows off a prototype of his custom ergonomic split keyboard, explaining that the project reached its Kickstarter funding goal within eight hours of launch. While the team moves into the manufacturing tooling phase, late pledges remain open via the campaign link in the episode description.
## Notable quotes
> [53:09](https://www.youtube.com/watch?v=sMllOlxVgD0&t=3189s) The bandwidth when you're talking to somebody in person is enormously higher than when you're talking to Claude or whatever. — Brian Kernighan
## Mentioned
A Beautiful Mind, Al Aho, Anthropic, AT&T, AWK, Barbara Liskov, Bell Labs, Bill Baker, Bill Gates, Bjarne Stroustrup, Brian Kernighan, C, CIA, Claude, Claude Shannon, Compatible Time-Sharing System (CTSS), Cornell University, CVS, David J. Malan, Dennis Ritchie, Digital Equipment Corporation, Donald Knuth, Doug McIlroy, ed, egrep, Eric Belove, Eric Schmidt, Fernando Corbató, Fortran, Fred Gramp, Git, Go, grep, Harry Nyquist, Harvard University, Haskell, Hendrik Wade Bode, IBM, Institute for Advanced Study, John Backus, John Hopcroft, John Nash, Ken Thompson, Kickstarter, Leslie Lamport, Lex, Louis Pasteur, make, Marc Brooker, Marc Rochkind, Margot Seltzer, Michael Stonebraker, Mike Lesk, MIT Press, MIT Project MAC, Multics, Nancy Reagan, OpenAI, PDP-11, PDP-7, Peter Weinberger, PL/I, Princeton University, Python, RCS, Richard Hamming, Robert Griesemer, Ron Howard, Ryan Peterman, SCCS, Shen Lin, Shifts: Important Ideas in Computing, Steve Johnson, Stu Feldman, The AWK Programming Language, Unix, UNIX: Making Computers Easier to Use, Vic Vyssotsky, Walter F. Tichy, William Colby, WorkOS, Yacc
## Video description
Brian Kernighan is a former Bell Labs member of technical staff, co-author of the original C book, and the one who popularized “Hello World.” We talked about what Bell Labs was like and the stories behind all the famous tools that were built there.
• My ergonomic keyboard project I mentioned, you can follow along here: https://read.compose.llc/
• The Kickstarter page for it: https://www.kickstarter.com/projects/ryanlpeterman/compose-simple-ergonomics-beautifully-done
• WorkOS: makes your app Enterprise Ready with easy to use APIs to add SSO, SCIM, RBAC, and more in just a few lines of code, check them out at https://workos.com/
𝗧𝗶𝗺𝗲𝘀𝘁𝗮𝗺𝗽𝘀:
00:00 Intro
00:42 What Bell Labs was and how he got hired
06:34 Why so many inventions came from Bell Labs
14:15 A day in the life at Bell Labs
27:55 The most impressive people he worked with
33:50 The AT&T film explaining Unix
39:46 Why C was so influential
43:25 How awk was created
48:40 What he misses most about Bell Labs
54:10 Are LLMs bad for computer science education
01:01:46 His 1972 commit in the Go repo
01:03:43 Grace Emlen, the fake Bell Labs employee
01:07:39 Why he writes so many books
01:19:58 His favorite and least favorite languages
01:24:28 Advice for students and young people
01:27:42 Outro
𝗪𝗵𝗲𝗿𝗲 𝘁𝗼 𝗳𝗶𝗻𝗱 𝗕𝗿𝗶𝗮𝗻:
• Personal website: https://www.cs.princeton.edu/~bwk/
• Princeton University faculty profile: https://www.cs.princeton.edu/people/profile/bwk
• Wikipedia: https://en.wikipedia.org/wiki/Brian_Kernighan
• UNIX: Making Computers Easier to Use: https://www.youtube.com/watch?v=XvDZLjaCJuw
• Brian Kernighan’s first Harvard CS50 lecture (1996): https://www.youtube.com/watch?v=6Ba1XFVy7qw
• A Beautiful Mind: https://www.universalpicturesathome.com/movies/a-beautiful-mind
• Shifts: Important Ideas in Computing: https://www.amazon.com/Shifts-Nine-Ideas-Revolutionized-Computing/dp/0262064294/
• Labscam (Penn & Teller at Bell Labs, 1989): https://www.nokia.com/bell-labs/about/dennis-m-ritchie/labscam.html
• Labscam video: https://www.youtube.com/watch?v=qnsmDNamd2g
• Understanding the Digital World (new edition): https://www.amazon.com/Understanding-Digital-World-Computers-Internet/dp/0691288879
In conversation with Ryan Peterman, computer scientist Brian Kernighan argues that foundational breakthroughs such as Unix and C emerged from a unique institutional ecosystem at Bell Labs, which combined monopoly-backed research freedom with practical, resource-constrained toolmaking. Looking at modern computing, he views artificial intelligence as another historical layer of abstraction, though one complicated by verification dilemmas and shifting academic incentives.
The Economics and Culture of Bell Labs (6:34)
Bell Labs operated as the research arm of AT&T, which held a regulated monopoly serving roughly 80% or more of the United States. In exchange for universal service commitments and rate caps, AT&T received a guaranteed return on capital, enabling it to funnel 1% to 2% of recurring revenues directly into unconstrained, fundamental research. Researchers worked without sprint cycles, corporate deadlines, or rigid project mandates, spending years pursuing open-ended questions. Quality was maintained not through layers of management, but through collegial annual reviews where technically active peers evaluated single-page summaries of work.
Constraint-Driven Tool Design and Unix (27:56)
The technologies developed at Bell Labs succeeded largely because their creators were their own primary users. Ken Thompson famously built an editor, an assembler, and the original Unix kernel in just three weeks on an obsolete PDP-7 minicomputer equipped with only 8k of 18-bit words. When Dennis Ritchie designed C around 1972, the target PDP-11 had only 24 kilobytes of memory and a 0.5-megabyte disk. This extreme resource scarcity compelled C to omit garbage collection and heavy runtime checks, creating a transparent, highly efficient language that mapped directly onto hardware instructions.
AI as an Abstraction Layer and Validation Dilemmas (73:43)
Kernighan contextualizes modern generative AI not as the death of programming, but as the latest step in computing's abstraction hierarchy, comparing it to the historic shift from handwritten assembly to Fortran and C. However, he highlights an epistemological dilemma inherent in large language model outputs. In his own experiments translating natural language into SQL, tools like Claude generated correct queries roughly 90% of the time, but the remaining 10% failed without obvious telltales. Because complex software cannot be fully vetted by hand, using automated tools to write and test code risks creating an infinite regress of unverified systems.
Changing Educational Landscapes and CS Enrollments (55:51)
At Princeton University, the rise of coding assistants and automated tools has catalyzed a dramatic shift in undergraduate career choices. While total university enrollment is fixed, Kernighan observes that computer science majors dropped from over 200 students in the class of 2026 to an anticipated 80 to 90 two years later. Seeking insulation from perceived AI displacement, students are instead pivoting to hardware-centric disciplines such as Electrical and Computer Engineering or Mechanical and Aerospace Engineering, drawn toward physical domains like robotics.
Navigating Careers through Prepared Serendipity (86:15)
Reflecting on his career path, Kernighan rejects the premise of deliberate career planning, comparing his trajectory to a marble descending a Galton board and bouncing unpredictably among pins. Drawing on Richard Hamming's advice to 'just say yes' to novel technical challenges, he maintains that while career collisions remain largely random, cultivating wide curiosity and learning fundamental concepts prepares an individual to capitalize on unexpected opportunities when they arise.
While the corporate restructuring of AT&T ended the protected research sanctuary of Murray Hill, Kernighan suggests the rapid expansion of artificial intelligence may offer a comparable frontier of foundational problems, provided practitioners maintain the critical domain expertise needed to evaluate automated systems.
[53:09] Brian Kernighan: The bandwidth when you're talking to somebody in person is enormously higher than when you're talking to Claude or whatever.
Original transcript
[0:00] And so in three weeks he builds himself
[0:01] an editor, an assembler and an operating
[0:04] system. And there you have it
[0:05] >> by himself.
[0:06] >> Yeah. Oh yeah, absolutely.
[0:08] >> This is Brian Kernneahan, Exbell Labs
[0:10] technical staff, co-author of the
[0:12] original Cbook, and the man who
[0:14] popularized Hello World and I asked him
[0:16] all about what it was like working
[0:18] there.
[0:18] >> There were no deadlines. There were no
[0:20] projects. There were no objectives,
[0:22] goals, whatever set by other people.
[0:25] >> There was a secrets file that was
[0:27] committed to the repo. And so you and
[0:30] all your colleagues passwords are
[0:32] actually
[0:33] >> Yeah.
[0:33] >> So I saw yours is do you believe that
[0:38] LMS are a net negative or a net
[0:40] positive?
[0:41] >> So who shall I insult today?
[0:43] >> Here's the full episode.
[0:49] >> Could you explain what Bell Labs was and
[0:52] what is the story behind you getting a
[0:54] job there? So Bell Labs uh was like the
[0:59] uh research arm of AT&T. It was founded
[1:04] in I think 1923 25 something like that.
[1:08] AT&T at that point was growing. It had
[1:10] absorbed a bunch of the local telephone
[1:12] companies across the whole country and
[1:14] they realized they just needed to
[1:15] understand things better so that they
[1:17] could improve service. So they set up a
[1:19] research operation which was called Bell
[1:21] Telephone Laboratories. It was in New
[1:23] York on West Street. Um and people did
[1:28] all kinds of things related to improving
[1:31] telefan.
[1:32] Um in 19 call it 63 something like that
[1:37] early 60s they basically moved the whole
[1:41] operation to New Jersey northern New
[1:43] Jersey a place called Murray Hill which
[1:47] near Summit and things like that. So
[1:48] call it 25 miles west of New York City.
[1:51] Um and that was a big operation. There
[1:53] were probably 3,000 people in one
[1:56] connected set of buildings doing um
[1:59] research in all kinds of things. Uh
[2:03] physics, semiconductor physics, devices
[2:05] like that, chemistry, optical fiber
[2:08] kinds of things, just all sorts of
[2:10] research. And then uh more on the soft
[2:12] end there was mathematics and
[2:14] increasingly there was computers
[2:16] computer related things as they
[2:18] gradually came to the realization that
[2:19] computing was going to be part of the
[2:21] future in some way or another. In the
[2:25] summer of 1966,
[2:28] I was a grad student here at Princeton,
[2:30] but I got an internship at MIT in
[2:33] Cambridge working in project MAC, which
[2:36] was basically the Multix project. And so
[2:40] I used CTSS, that first original time
[2:43] sharing system done by uh Corby and
[2:47] friends to develop software for the
[2:51] Multic system which was just just
[2:53] starting up. And that was a lot of fun.
[2:57] I enjoyed it. I'm not sure I ever did
[2:59] anything that was very useful, but but
[3:01] part of it was then the next year I got
[3:05] an internship at Dell Labs in Murray
[3:08] Hill. So I was still a graduate student
[3:10] and that would be roughly the third year
[3:13] here. I got this internship at Bell Labs
[3:16] and that was a lot of fun and I worked
[3:18] there. I worked actually with Doug Mroy
[3:22] um for the summer came back here
[3:25] continued to stall on doing my thesis
[3:28] work which I guess is what one does. And
[3:31] then I got another internship in the
[3:33] summer of 1968 and there I worked with
[3:35] Shan Lynn and he and I worked on a
[3:37] problem which had been suggested by my
[3:39] adviser here and this is graph
[3:42] partitioning. Um and he and I worked on
[3:45] it and we came up with an algorithm that
[3:48] did a pretty decent job on part of it. I
[3:50] came up with several special cases that
[3:52] you could do really well and then I
[3:55] wrote up the thesis really quickly and
[3:57] escaped
[3:59] [laughter]
[3:59] >> escaped Princeton. escape from
[4:01] Princeton. I took a whole week off and
[4:03] went to Bell Labs because they had given
[4:04] me a return offer which was very sweet
[4:06] of them. Um, and I stayed there then
[4:08] until roughly 2000 in the [snorts] group
[4:13] that had done or was doing a variety of
[4:15] things.
[4:16] >> Did you consider other career
[4:18] opportunities at the time?
[4:19] >> You know, I think I didn't consider any
[4:22] other option whatsoever. I I mean, I had
[4:24] really enjoyed the the summers. The two
[4:26] summers were great. The people were
[4:28] really, really nice and interesting.
[4:30] There was stuff to do. Uh, it was close.
[4:32] I didn't have to go anywhere as it were.
[4:35] And so, I literally never considered
[4:39] anything else. I never had a job
[4:40] interview, nothing like that. I just
[4:42] went there. So, it was kind of like
[4:44] falling down the fall line or something
[4:46] like that. I think partly it was helped
[4:49] along by some sort of old boy network
[4:52] where somebody here at Princeton knew
[4:54] somebody at Bell Labs because there's a
[4:55] lot of back and forth between the two
[4:58] institutions and so I'm sure that that
[5:02] kind of thing helped. It also helped I
[5:05] think at MIT that a guy who had had an
[5:09] internship the year before me had done a
[5:11] bangup job for them and so that probably
[5:14] these folks from Princeton are maybe
[5:16] okay. Um, so I'm grateful to him too.
[5:20] >> Nowadays, Bell Labs is so legendary. But
[5:24] at that time, what was the social
[5:26] perception? If I were to have talked to
[5:28] your peers and said, "Hey, what do you
[5:30] think of Bell Labs?" What would they
[5:31] have said at that time?
[5:33] >> I suspect that it depended on the field,
[5:35] but probably for most of them, they
[5:36] would have thought, "Yeah, yeah, this is
[5:37] a really good place." Because in the
[5:39] physical sciences, it was obviously the
[5:42] powerhouse in a lot of respects. That's
[5:44] where your transistor came from, for
[5:46] example. Um, and a lot of things related
[5:49] to communications. That's where
[5:50] information theory came from. It's where
[5:53] error correcting codes came from. All
[5:54] these things that were sort of critical
[5:57] advances in technology had come from
[5:59] Bell Labs. Bell Labs was a part of the
[6:01] scientific community. People who went to
[6:04] Bell Labs published in exactly the same
[6:06] journals, went to the same conferences,
[6:09] collaborated with people in the same
[6:11] universities. And so it was really an
[6:13] integral part. I think of the scientific
[6:15] community at the time and that was you
[6:18] know largely I will say the physical
[6:21] sciences kind of thing but it obviously
[6:23] sort of spread out into other things
[6:26] that were peripherally related and
[6:27] certainly the mathematicians were
[6:29] absolute first rate as well tended to be
[6:31] applied mathematicians rather than
[6:33] theoretical ones. Everything you just
[6:36] said there is in insane value for
[6:40] humanity, the transistor and all of
[6:42] those other things. Why is it that so
[6:46] much of it came from one research lab
[6:49] tied to a company that today is not
[6:52] known for all these amazing innovations.
[6:56] >> AT&T bankrolled all kinds of
[6:59] contributions that Bell Labs made. And I
[7:01] think the way it worked was that AT&T
[7:03] provided telephone service to
[7:05] essentially the whole country. I mean
[7:06] maybe it was 80% but it was very
[7:08] substantial fraction of the whole
[7:09] country. [snorts] And that meant that
[7:12] they had a pretty guaranteed revenue
[7:15] stream. Now it was regulated. They were
[7:17] a regulated public monopoly. That's the
[7:19] the jargon term. And that meant that
[7:21] their rates were set or restricted or at
[7:25] least evaluated by lots and lots of
[7:27] agencies, states and the federal
[7:29] government. So there was a limit to what
[7:31] they could do. The quid proquo was they
[7:34] got sort of a guaranteed rate of return
[7:37] on their investment in whatever they did
[7:39] with the phone company. And the quid
[7:41] proquo would be that they provided
[7:43] telephone service to essentially
[7:45] everybody. Even if you were way out in
[7:48] the boonies or something like that, AT&T
[7:49] would provide the service. and they were
[7:52] able to rip off a small fraction that I
[7:54] will make up a number and say 1 or 2% of
[7:57] their pretty much guaranteed revenues to
[8:00] fund a research operation that would let
[8:03] them improve the service. And so that
[8:05] was the the basic call it financial
[8:08] arrangement. And the other thing is it
[8:10] was very stable. you could sort of
[8:12] predict there would be this steady
[8:13] increase in um revenues [snorts]
[8:17] but predictable in a way that would
[8:19] guarantee that there would always be
[8:21] money to do something. There was no
[8:23] competition because AT&T had essentially
[8:26] what amounted to this monopoly and so
[8:28] that meant that they could take a very
[8:30] long view of what they were doing. And
[8:33] so somebody had an idea and wanted to
[8:35] work on it for a year or two or three
[8:38] fine go for it. And if you got a bunch
[8:40] of people doing this, even if your idea
[8:42] is dumb, my idea is dumb, somebody else
[8:44] might have a good idea. And so if you
[8:46] aggregate that, the output would be
[8:50] probably something useful almost all the
[8:52] time.
[8:53] >> What gave this lab such recruiting pull
[8:56] in your opinion? Like how did how are
[8:58] all the best people coming to this
[9:01] place?
[9:02] >> Well, I think it depends. For me, it was
[9:03] certainly happen stance, just blind
[9:05] luck, being in the right place at the
[9:07] right time, following people who had
[9:08] done something that in some way prepared
[9:10] the way. I think if you were a
[9:13] physicist, getting your degree in
[9:15] physics at pick your favorite good
[9:16] university, uh where would you go to do
[9:18] physics? Well, the opportunities would
[9:20] fundamentally be government lab perhaps
[9:24] uh or a place like maybe IBM or maybe
[9:30] Bell Labs. and Bell Labs had a sterling
[9:33] reputation, well-earned for doing
[9:36] exceptional work in that area. So, so
[9:40] that would be let's say anybody doing
[9:42] physics, chemistry, materials, all of
[9:43] that kind of stuff. Um, I think somewhat
[9:46] the same would be true of anything
[9:48] related to mathematics, especially the
[9:50] mathematics of communication or anything
[9:51] related to communication systems. That's
[9:53] where Shannon was, that's where Hamming
[9:55] was, uh, Bodh Nyquist, all of those
[9:59] people before those. So that kind again
[10:02] tremendous reputation for the place and
[10:04] as I said they were part of the
[10:05] scientific community. It wasn't like it
[10:07] was off in Mars somewhere and it wasn't
[10:09] like you went there and disappeared. You
[10:11] went there and you were part of the
[10:13] broader community. And so I think the
[10:15] computing stuff came along and had some
[10:17] of the same advantages. But it wasn't
[10:20] clear who the heroes were at that point.
[10:23] It was earlyish because remember I was I
[10:25] went there in 1969. So this was
[10:28] computers were still pretty young at
[10:30] that point.
[10:31] >> A lot of those names you mentioned, I
[10:33] mean they were in my, you know,
[10:37] textbooks when I was studying and so
[10:39] they're they're kind of the heroes and
[10:40] and everything. But so at that time
[10:43] you're saying your perspective was they
[10:45] were just kind of the lead on the team,
[10:47] but they weren't the legendary computer
[10:51] scientist. Well, that's it's hard to say
[10:52] and it it's not even clear what a
[10:54] computer scientist is, but you want a
[10:55] story. When I went to Bell Labs for my
[10:58] first internship, so call it the summer
[11:00] of 1967
[11:02] and I was in an office that was sort of
[11:06] a little smaller than the one we're
[11:07] sitting in now, but as a summer intern,
[11:09] for some accidental reason, I had an
[11:11] office of my own. This never happens,
[11:14] but it did happen. And so I'm sitting
[11:16] there on the very first day at about,
[11:18] you know, roughly
[11:20] 11 o'clock in the morning wondering what
[11:22] the hell do I do? And this older guy
[11:24] came along, passed the door, and he
[11:26] said, "Hi, I'm Dick. Let's go to lunch."
[11:29] I said, "Okay."
[11:31] So I went to lunch with Dick. I never
[11:33] did get his name right. And so we had a
[11:35] nice lunch conversation. I don't
[11:36] remember anything about it. And then he
[11:37] went off somewhere else. And I came back
[11:40] and I went the next door to me and
[11:43] looked at the name tag on the door. It
[11:45] was Dick Hamming. Hamming had written
[11:48] the book that I had used previous
[11:50] semester for numerical analysis and of
[11:54] course error correcting codes. And there
[11:56] he was next door. Super nice guy. Um and
[12:02] was he a computer scientist? Borderline.
[12:05] But possibly he did win the third Turing
[12:08] award.
[12:09] uh won it was it that summer or the next
[12:11] summer I'd have to go and look and so
[12:13] there were people like that around but
[12:16] in the very early days the computing
[12:18] stuff was I think it hadn't developed
[12:21] into something with its own academic
[12:23] structure its own reward systems and all
[12:25] those kinds of things
[12:27] >> when I interviewed Leslie Lampport and I
[12:30] forgot the his exact timelines but I
[12:32] remember early in his education computer
[12:35] science wasn't established and he
[12:38] actually said it was not not as
[12:42] respected as math and physics or maybe
[12:44] because it just was a burgeoning that's
[12:46] brand new. The same thing happened here.
[12:49] I think I came here as a grad student in
[12:51] 1964 and I came in electrical
[12:54] engineering. I had thought to work on
[12:55] computing because I had some notion that
[12:57] it was interesting and I thought AI
[13:00] I didn't know a thing. That's
[13:01] unbelievably naive. Um, and I had sought
[13:05] to work with a guy uh named Arthur
[13:08] Samuels who had done some interesting
[13:09] stuff in computer chess playing etc. And
[13:12] I got here discovered I was the wrong
[13:14] guy. Um, but when I got here the
[13:18] electrical engineering department had a
[13:19] bunch of very established, highly
[13:22] respected people who were doing
[13:23] traditional electrical engineering
[13:25] things, information theory,
[13:26] communications, solid state physics,
[13:29] that kind of stuff. and a cohort of
[13:31] young people who had interest in
[13:34] computing. They had just gotten their
[13:36] degrees from someplace and they were
[13:38] very young, wanted to do computing
[13:42] and I don't know whether any of them
[13:43] ever got tenure because the older folks
[13:45] didn't really gro the newer field.
[13:49] John Hopcrush to pick a random example
[13:52] was my technical advisor for a year.
[13:55] Although it was quickly discovered I was
[13:58] not a theoretician.
[13:59] >> [laughter]
[14:00] >> But you know, John went on to win a
[14:02] touring award and was dean of
[14:04] engineering at Cornell. There's all
[14:05] kinds of stuff. Great guy. Uh but he
[14:08] wouldn't have gotten tenure here at that
[14:11] particular time because the the
[14:13] computing science aspect things was too
[14:15] new.
[14:16] >> Bell Labs is kind of famous for very
[14:20] hands-off management and letting the
[14:22] engineers kind of do what they were
[14:24] doing. What is a day in the life like of
[14:27] a engineer working at Bell Labs?
[14:30] >> Well, first thing I don't think any of
[14:32] us would have called ourselves
[14:33] engineers. Uh we were, you know, doing
[14:36] whatever you did, but but I don't think
[14:39] that engineer was the right word because
[14:41] we weren't really engineering.
[14:43] >> It was member of technical staff.
[14:45] >> Member of technical staff, which was a
[14:46] term that applied to everybody
[14:48] essentially. Um, and a typical day would
[14:54] be basically you'd come in at whatever
[14:56] time, which could be anywhere from, you
[14:58] know, 8 in the morning to 2 or 3 in the
[15:01] afternoon maybe,
[15:03] [snorts] and you would sit in your
[15:05] office, private office, um, with the
[15:08] door open, and you would think about
[15:10] whatever it was you were thinking about.
[15:12] Maybe you had been working on some kind
[15:14] of program, or maybe you were trying to
[15:15] prove a theorem. That's not me. Uh, and
[15:19] people would wander by and you would
[15:22] talk to them. They would come in. You'd
[15:23] have discussions on the blackboard
[15:25] perhaps of technical things or maybe
[15:27] just armwaving discussions of something
[15:28] else. You'd walk up and down the very
[15:31] long main corridor to the coffee machine
[15:33] at the other end. You would run into
[15:36] random people. There would be technical
[15:38] talks from time to time, maybe one every
[15:41] week, two, something like that,
[15:42] depending. Uh, sometimes from internal
[15:44] people, sometimes from external people.
[15:47] Um, so in a sense, maybe not too
[15:50] different from what you would find in a
[15:52] university, except there were no
[15:53] students. And so that meant you could do
[15:56] it full-time.
[15:57] The the trade-off was that without the
[16:00] students, you could do more of your own
[16:02] thing and you were doing it with your
[16:04] peers.
[16:06] So, you know, I would argue with
[16:08] somebody, Ken [snorts] Thompson or
[16:10] Dennis Richie or whatever like that who
[16:12] were my peers. I didn't have to work
[16:14] with students. But of course the flip
[16:16] side is that I didn't get any of the
[16:17] benefit that you get with bright young
[16:19] new people talking about it except that
[16:22] as a newcomer there I was supposedly the
[16:24] bright new young person.
[16:26] Uh so mainly the lack of students which
[16:28] I think is a mixed blessing
[16:31] >> in industry there's often deadlines
[16:35] managers and all of that stuff right
[16:38] what what's stopping a researcher from
[16:41] coming in at three leaving at 5 not
[16:44] having any output
[16:46] >> there was no immediate stop to that
[16:48] period could there were no deadlines
[16:50] there were no projects there were no
[16:54] objectives goals whatever set by other
[16:56] The mechanism for deciding whether you
[16:59] were doing anything was that once a year
[17:02] you had to write down on one side of one
[17:05] piece of paper what you had done
[17:07] [snorts] and we called it the I am great
[17:09] report and it just summarized what you'd
[17:12] done. Um and then the first and second
[17:14] level of management would sit in a room
[17:17] with the I am great reports from their
[17:19] people. So this would be maybe 30 at the
[17:22] bottom, half a dozen, one like that
[17:25] little tree and they would discuss the
[17:28] merit of the the contributions of the
[17:31] work that was being done by the people
[17:35] and they would come up with some sort of
[17:36] ordering which says you're better than I
[17:39] am or vice versa. how would we compare
[17:41] to our peers and that would give them a
[17:43] sort of roughly a rank orderering or at
[17:45] least equivalence classes of people and
[17:49] if somebody hadn't done anything for a
[17:50] couple of years that would be noticed
[17:53] but if somebody' gone off on something
[17:54] and it didn't pay off very well or it
[17:56] was still in progress but it looked okay
[17:58] or whatever that was okay that's the
[18:01] long view that I mentioned before it's
[18:03] not like what have you done for us the
[18:05] last week or even quarter what maybe
[18:08] have you done over the last two three
[18:10] ers and it was being assessed by people
[18:13] who were not driven by quarterly
[18:15] numbers. They were the same people as we
[18:18] were except that they had moved into
[18:20] management but they were still
[18:21] technically active and they were very
[18:23] technically knowledgeable and then the
[18:25] process was repeated a couple of levels
[18:27] up until they had any effect or ranking
[18:29] of everybody. So that was kind of the
[18:32] call abstract merit you know you know
[18:34] I'm better than you are. And then there
[18:35] was the concrete merit phase where we've
[18:37] got this much money how much do you get?
[18:38] how much do I get? Uh,
[18:41] >> oh, so there were bonuses or tied to
[18:44] >> It wasn't bonuses or anything like that.
[18:46] It was simply there's a pot of money.
[18:48] This is the raise pool and it will be
[18:50] over all x% and so you will get x minus
[18:53] epsilon. I'll get x plus epsilon or
[18:55] vice.
[18:57] Oh, and that was once a year and
[19:01] that was the whole story.
[19:03] But it was it was very deliberative. The
[19:06] management was colleial.
[19:08] >> [clears throat]
[19:08] >> If you and I were managers and we had
[19:10] our people, it wasn't like my people are
[19:12] better than your people. It's rather,
[19:13] hey, you forgot to mention that, you
[19:15] know, Susie did this really great thing.
[19:17] Let's don't forget Susie kind of thing.
[19:20] So, it was quite colleial and you were
[19:22] be evaluated by people who understood
[19:24] the work and whose goals and aspirations
[19:27] and so on were the same as yours, you
[19:28] know, do good stuff.
[19:30] >> It sounds like you mentioned that their
[19:32] technical is like a big part of this
[19:35] whole system.
[19:36] Why is that important?
[19:38] >> If somebody is doing something in a
[19:41] technical area, they have created a new
[19:43] program, they've proved a new theorem,
[19:44] they developed a new process, whatever.
[19:47] If you are not technical enough to
[19:49] understand what they're talking about,
[19:52] it's hard for you to tell the
[19:54] from the actual useful content, right?
[19:56] So, I could not you personally, but I
[19:59] could blow smoke pretty well for people
[20:01] who were I don't who shall I insult?
[20:04] MBAs. Okay, something like that. That's
[20:06] obviously a slander, but uh but it's
[20:10] easier to blow smoke at somebody who is
[20:12] not sort of knowledgeable in your own
[20:15] field, but the people that you were t
[20:17] who were evaluating your work were
[20:19] exceptionally knowledgeable in the whole
[20:22] field. And so they had a pretty good eye
[20:26] for what was good stuff and what wasn't
[20:29] yet good stuff or would perhaps never be
[20:31] good stuff. these days this um member of
[20:34] technical staff title is it's it's
[20:38] almost has its own brand where it's it's
[20:42] a well it's a nod towards Bell Labs and
[20:44] everything that that represented there
[20:46] but a lot of what it is signaling is
[20:49] that titles don't matter that we're all
[20:52] the same and we're all just focused on
[20:53] the technical work did titles matter or
[20:56] what was the culture at that time
[20:58] >> titles didn't matter um everybody was on
[21:01] a firstname basis. There were no doctor,
[21:04] professor, whatever kind of titles at
[21:06] all. Um, everybody was technically a
[21:10] member of staff, member of technical
[21:13] staff. I and I say everybody, this is of
[21:14] course an oversimplification. there were
[21:16] a variety of supporting people who you
[21:19] know lab technicians associate members
[21:21] of technical staff or whatever but I'm
[21:22] talking about the MTS level and um uh so
[21:26] they would be loosely equivalent to PIs
[21:29] in the modern academic or principal
[21:31] investigator whatever
[21:33] and in computing I never would never
[21:37] have had somebody who helped me with my
[21:39] stuff whereas if I were a physicist I
[21:41] might have some number of people who
[21:43] would help me do experiments look after
[21:45] the you know mechanics of you know
[21:49] depositing stuff on stuff all those
[21:51] kinds of things in a physical world
[21:54] but everybody was technically a member
[21:56] of technical staff in the management but
[21:58] then there were department heads who
[22:00] manage first level management and then
[22:02] there were directors who were second
[22:04] level management and then there was
[22:06] executive director and then there was
[22:07] vice president but it was very flat uh
[22:10] in that sense most people did not want
[22:12] to be promoted because that
[22:15] would be seen as the end of their
[22:17] personal
[22:18] technical career that it would move them
[22:20] away from the kind of work that they
[22:22] really enjoyed doing. So being promoted
[22:24] was something to be avoided, not to be
[22:28] sought. Uh and I think that went
[22:33] for quite a long time. Now things did
[22:35] change, but I'm talking about the golden
[22:37] era of call it the late 60s,7s, early
[22:40] 80s, something like that.
[22:42] Did you and your peers ever think about
[22:45] the notion of career development in some
[22:48] way or it was not even something you
[22:51] cared about?
[22:52] >> Career development for myself as an
[22:54] individual I never thought about at all.
[22:56] I mean it was I was having a good time
[22:57] and I was surrounded by lots of good
[22:59] people. Uh career development for uh the
[23:02] people for example when I was in first
[23:04] level management I was a department head
[23:06] for some years. I don't remember much
[23:08] about how explicit it was, but there was
[23:11] some theory that you should actually be
[23:13] looking after the interests of the
[23:15] people in your department. I think the
[23:18] main way that that would be reflected is
[23:21] understanding the work they were doing,
[23:23] really trying to understand what it was
[23:24] they were doing so that you could
[23:26] represent it fairly at things like merit
[23:28] review. Also, so you could see
[23:30] opportunities to, you know, oh gee, did
[23:32] you know Dave was working on this stuff
[23:36] so that you could sort of cross
[23:37] fertilize across the way um to try and
[23:41] give them feedback sort of to say, you
[23:42] know, are you sure this is going to work
[23:45] or keep an eye on this? Sort of guide
[23:48] them towards future success. Uh but not
[23:51] telling them what to do. There was never
[23:53] any this is what you have to do. there
[23:55] was no no uh there just wasn't any it
[23:59] wasn't guidance at all at most there was
[24:01] a gentle gravitational pull towards
[24:03] stuff that would be useful or
[24:04] interesting.
[24:05] >> So you mentioned you were ahead at some
[24:07] point and you managed some reports you
[24:09] never had a report that was um saying I
[24:12] want to grow in some way or they're kind
[24:14] of hustling you know kind of pushing you
[24:18] some way.
[24:19] >> There were a handful of people I could
[24:20] remember who wanted to be in management.
[24:23] Okay, that was unusual, but there was
[24:25] nothing wrong with it. It's just that
[24:27] being in research management because the
[24:30] structure was so flat
[24:33] that it would take probably quite a
[24:36] while before you would move up. If you
[24:38] really wanted to be in management, you
[24:40] probably wanted to move into a different
[24:42] organization, development organization,
[24:44] where the rules of engagement and so on
[24:47] were much different. And there were
[24:48] several I shouldn't say several but at
[24:50] least a handful of people who were
[24:52] interested in that kind of advancement
[24:54] and they went into development type jobs
[24:58] which are perfectly fine just differed
[25:00] in a lot of ways and there they had the
[25:02] much more traditional responsibilities
[25:05] of management and including looking
[25:07] after their people but I think the
[25:09] research operation was much more a bunch
[25:13] of cats and you can't really hurt them.
[25:15] [laughter]
[25:16] So what's the story behind you becoming
[25:18] a manager in that kind of environment
[25:20] because seems like it's something
[25:22] everyone's avoiding.
[25:24] >> I had no desire to do it. Um and I was
[25:27] blandished a couple of times. Wouldn't
[25:30] you like to be a manager, but it was in
[25:32] some other organization even within
[25:33] research and I always thought the the
[25:35] group that I was in was special.
[25:37] Probably was. Uh and so I had no
[25:40] interest in being manager in some other
[25:43] part of it. And so I basically declined
[25:44] with thanks. Um but then it was would
[25:48] you like to be a manager in your own
[25:50] organization? And I wasn't very
[25:52] enthusiastic but okay. And they got lots
[25:55] of ways they can you know it's
[25:58] inevitable. Why not now or alternately
[26:02] you know if you don't do it now it might
[26:03] never come but [laughter] you're
[26:05] completely contradictory
[26:07] [gasps] or if if you don't do it
[26:09] somebody else not as good is going to do
[26:10] it you know. all of the usual stuff and
[26:12] I finally succumbed I think in about 81.
[26:15] So I'd been there at that point, call it
[26:17] 12 years for real. So that's the first
[26:20] promotion and
[26:22] and it was okay but it wasn't as much
[26:25] fun I think because now I was
[26:26] responsible for you know roughly 10
[26:28] people had to understand their work
[26:31] which was all over the map. Had to be
[26:33] able to talk to other people about it.
[26:35] Had to go to more meetings.
[26:39] So, it was okay, but it was not my
[26:41] favorite part of the job really.
[26:44] >> How did you know your group was so
[26:46] special? Because when I look at it, it
[26:48] it it is in hindsight. I mean, I saw
[26:50] Bejarn was reporting to you and of
[26:53] course there's Dennis Richie nearby and
[26:55] Ken Thompson and you also mentioned
[26:58] other people like Mroy and Hamming. So,
[27:01] how how did you know though at that time
[27:03] that it was such a special group?
[27:06] I think a lot of it was not so much
[27:08] knowing that the work they were doing
[27:10] was going to prove to be prove to be in
[27:12] the future important, but that they were
[27:14] just really clearly smart and and seem
[27:17] to be doing things that were interesting
[27:19] and relevant. Most of us used the work
[27:22] that our peers did. Certainly the all of
[27:25] the things related to Unix, we just used
[27:27] that. That was our computing
[27:28] environment. The languages that were
[27:30] developed, the tools that were developed
[27:32] and so on, we used them. And so you
[27:34] could get a sense of who's doing stuff
[27:36] that actually matters to me. And and so
[27:39] I think that was part of it. Uh
[27:43] extrapolating long-term,
[27:46] you know, effects. We're not very good
[27:48] at that. Or I certainly was and figuring
[27:50] out who were the ones who were going to
[27:51] win touring awards. No,
[27:55] >> not really.
[27:56] >> You worked with so many legendary
[27:59] people. Was there anyone that I guess or
[28:02] any story of someone who kind of
[28:05] impressed you the most or you thought,
[28:06] "Wow, their their technical chops are
[28:08] just untouchable."
[28:10] >> There are several like that. Um Ken
[28:13] Thompson's the obvious one. I think
[28:16] certainly the best programmer I've ever
[28:17] met, unparalleled.
[28:20] And the story is the first version of
[28:23] Unix where he's got this little old PDP7
[28:28] which is an obsolete machine has
[28:29] something like 8k 18 bit words so it's
[28:33] you know tiny little machine um and he's
[28:38] been fooling around with something to
[28:40] drive the disc on it and he's thinking
[28:42] about you know how do you schedule disc
[28:44] operations so that it'll go fast and
[28:45] stuff like that. Um, and his wife takes
[28:48] their young son off to California for
[28:51] three weeks and he thinks I could do
[28:53] something here. And so in three weeks he
[28:55] builds himself an editor, an assembler
[28:57] and an operating system. And there you
[28:58] have it [snorts]
[29:00] [laughter]
[29:00] >> by himself.
[29:01] >> Yeah. Oh yeah, absolutely.
[29:03] >> When I used to write, you go to, you
[29:05] know, Stack Overflow or you kind of like
[29:07] look up how to write the code and then
[29:10] you write it. How how does he do it
[29:14] without all that internet resource?
[29:17] >> Because he's a boatload smarter than you
[29:18] and I put together. [laughter]
[29:21] And this is before any of that stuff
[29:22] existed, right? This was 1969.
[29:25] And uh so he's probably writing the code
[29:28] on in assembly language, bear in mind,
[29:30] not not any high level language. And
[29:32] he's doing it probably on some other
[29:34] machine just because it has some kind of
[29:36] text editor. And then he's making paper
[29:38] tapes that he carries to this tiny
[29:40] little machine and loads them and sees
[29:43] what happens.
[29:44] >> Oh my god.
[29:45] >> Yeah. So, it's going back into the mists
[29:47] of time. But three weeks and he's got a
[29:49] working operating system.
[29:51] >> So, I think that is a good example of
[29:55] somebody who's just offscale good at
[29:57] what they do. And there were a lot of
[29:59] people like that at the labs. Um, you
[30:03] know, I mentioned Doug Mroy a number of
[30:05] times. He was
[30:07] my first internship. He was notionally
[30:09] my boss and he was interested in storage
[30:11] allocators, you know, ML kind of thing
[30:14] and uh so he set me to working on
[30:18] something and I almost instantaneously
[30:19] went somewhere else [laughter]
[30:22] and he didn't care. So I spent the
[30:24] summer doing something unrelated to that
[30:26] and it seemed like it was fine because I
[30:28] got a re come back next summer kind of
[30:30] offer. But he was the kind of guy who
[30:33] was exceptionally good at pretty much
[30:35] anything he wanted to do. I mean, Ken
[30:37] Thompson says Doug's the smartest person
[30:39] he ever met. [laughter] So, this is
[30:44] [snorts] we're multiple levels above me
[30:46] at this point. Um, but Doug was
[30:48] extremely good at uh assessing
[30:52] experimenting with criticizing other
[30:54] people's work in a very constructive
[30:57] way. So he was a second read or the
[30:59] outside reader on my PhD thesis and he
[31:02] greatly improved my writing and the
[31:04] content of the thesis and he continued
[31:06] to do that essentially for his whole
[31:08] life. He's still doing it and he
[31:11] contributed a bunch of useful software
[31:13] of his own Unix sort program Doug Unix
[31:17] diff program compares to files Doug
[31:20] bunch of things of of that sort. Um he
[31:23] did language design and uh development
[31:26] of his own. He wrote one of the very
[31:28] first PL1 compilers. Uh he invented the
[31:32] idea of macros and it's just on and on
[31:34] and on and on. Um
[31:37] and he was also the department head who
[31:40] sort of had Ken Thompson in his
[31:42] department. Now Doug wouldn't tell Ken
[31:44] what to do obviously but appreciated the
[31:48] work and was an incredibly effective
[31:50] technical critic of that kind of work.
[31:53] So, you know, gee, wouldn't it be nice
[31:55] if or you thought about that way or
[31:58] geez, this sucks, whatever, uh, to make
[32:00] stuff good. And that's a role that he
[32:02] played for the entire time that he was
[32:04] at Bell Labs. I I first met him in ' 67,
[32:07] I guess, and he was until he retired
[32:09] probably to mid 90s, something like
[32:11] that.
[32:12] >> This this reminds me when you mentioned
[32:15] department head somewhere in my
[32:16] research, it might have been Hamming.
[32:20] There was someone that you worked with
[32:22] who was a head of the department with no
[32:25] reports.
[32:26] >> That's Hamming.
[32:27] >> Yeah. Yeah. I I never understood that
[32:29] when I first met Dick Hamming and you
[32:31] know he was a department head. Um you
[32:33] could tell because he had carpet on his
[32:34] floor. I guess he showed up in the phone
[32:37] book that way too. But um
[32:40] and I couldn't figure out, you know,
[32:42] because I had this naive view that you
[32:43] know there was status associated with
[32:45] being a department head and it was
[32:46] totally wrong. But um but he had worked
[32:50] very hard to get himself a department
[32:52] head. So he had whatever status or clout
[32:55] or whatever went with it for useful
[32:58] purposes but no people reporting to him
[33:02] and and so I think that worked out very
[33:04] well because in you know in any
[33:06] organization if you're not at the right
[33:07] level you may get ignored and so it was
[33:09] harder presumably for something for
[33:11] people to ignore a department head than
[33:13] an ordinary MTS. [snorts] So he got the
[33:17] clout without any of the work of
[33:19] >> without the dog work. Yeah. Right.
[33:21] Administering. I mean he he'd put in his
[33:23] dues because he he came to the labs I
[33:25] think in 46
[33:27] and did a lot of early stuff with
[33:30] computing. He's one of the very first
[33:31] people to realize that computer act use
[33:34] of computers was going to be a very
[33:37] important part of all kinds of research
[33:39] in the future. and he made this
[33:41] prediction that that at some point more
[33:44] than half of the the research work would
[33:47] be done by computing not but in physical
[33:49] labs and of course they laughed at him
[33:51] [snorts]
[33:53] in my research I somewhere on YouTube
[33:56] there's this video posted by AT&T the
[34:00] corporation itself and it's this I guess
[34:03] a film titled Unix making computers
[34:07] easier to use
[34:08] >> Oh yeah yeah AT&T did a lot of those PR
[34:11] films.
[34:12] >> Yeah. And there's a And you're you're in
[34:14] the video. You're one of the first
[34:15] people speaking and you have your legs
[34:17] up on some desk and you're kind of
[34:20] explaining as what what is that?
[34:23] >> It's like any PR film. It's a trying to
[34:25] convince people who don't know anything
[34:27] about you that you're a great whatever
[34:29] institution that you're contributing to
[34:31] the public good or whatever. And so they
[34:34] hired a professional filmmaker kind of
[34:38] thing. Eric Belove, I think his name
[34:40] was. It was a long time ago. And he came
[34:42] around and and he would do sort of what
[34:44] we're doing. He'd have a conversation
[34:45] about something and try and get whoever
[34:49] he was talking to to elaborate on what
[34:51] they were doing and then he would splice
[34:53] it together into something that was
[34:55] feel-good for AT&T.
[34:58] And at the time this was done, which I
[35:00] would guess is
[35:03] 70 late 70s, early 80s, something like
[35:05] that.
[35:06] uh Unix was kind of just starting to
[35:09] appear on the outside. It was a sort of
[35:11] a visible interesting thing. And so part
[35:14] of the thing is AT&T is using computers
[35:16] to improve people's lives or our
[35:19] business operations or whatever what is
[35:21] Unix. So my job in these this film at
[35:25] least and probably several others was to
[35:27] sort of try to explain to a very
[35:30] non-technical audience what is this
[35:32] thing and what's it good for and why is
[35:35] it new and interesting or something like
[35:37] that.
[35:38] >> I skimmed through the comments on this
[35:40] video. It has a lot of views actually.
[35:42] And um the comments in there, one of the
[35:45] ones that has some of the most up votes
[35:47] is it's saying that everyone in the film
[35:50] is, you know, not to be derogatory, but
[35:52] kind of like computer nerd, you know.
[35:54] >> Well, we were still,
[35:56] >> but but they highlight you as being a
[35:59] very clear communicator and a bit
[36:02] exceptional in your ability to convey
[36:05] the technical stuff you're you're
[36:07] talking about. And so I was curious like
[36:09] if you have any advice on how to
[36:13] communicate technical work but in such a
[36:15] clear way.
[36:17] >> Part of it is probably just putting
[36:19] yourself to some extent into the other
[36:21] person's shoes. They don't know anything
[36:23] about what you're talking about. So how
[36:24] can you explain it with the right
[36:26] combination of metaphors and examples
[36:28] and everything else that gets it across
[36:32] to them?
[36:34] And part of that, of course, it's nice
[36:36] to have feedback. So it's easier to do
[36:37] that if you're in a teaching kind of
[36:39] setting where you can see whether
[36:40] they're getting you or not. And if
[36:42] they're not, you can adapt. It's harder
[36:44] when you're doing a film because you you
[36:46] know the audience is later if at all. Uh
[36:49] but there there were a fair number of
[36:52] those things. We used to have
[36:55] dog and pony show as a image that's
[36:58] probably obsolete at this point, but
[37:00] AT&T or Bell Labs would bring through
[37:02] distinguished people
[37:05] and on a tour of Bell Labs and they
[37:08] would get demos of various thing, you
[37:11] know, the usual stuff, demos of what
[37:13] interesting work was going on at Bell
[37:14] Labs and they would go through variety
[37:16] of places, labs, so on. and Mike Lek and
[37:20] I were on a regular kind of rotation for
[37:24] Unix demos where we would get some
[37:27] exalted being accompanied by some
[37:29] appropriate level of Bell Labs
[37:31] management and others
[37:34] to
[37:36] sit on a couch in a little room and I
[37:38] would show them the wonders of Unix in
[37:40] some way or other. Well, what are the
[37:41] wonders of Unix? I don't know. But one
[37:43] of them was that it's easy to create
[37:45] programs by combining programs. the idea
[37:48] of pipes where I can take the output of
[37:50] this program into the input of this
[37:52] program and maybe string several
[37:54] together and I had a standard demo of
[37:56] that uh which was looking for spelling
[38:01] mistakes in a document because what you
[38:03] could do is here's a document so what we
[38:07] collect the words in the document get
[38:08] them into the lowercase whatever sort
[38:10] them neatly and then compare them to
[38:12] another document which is a dictionary
[38:14] and if you find a word that's in your
[38:16] document but it's not in the dictionary
[38:17] It might be a spelling mistake and it's
[38:19] a one one long pipeline, six or seven
[38:23] programs. So I could do this and people
[38:25] would sort of understand it. This is
[38:27] before WordPress software really came
[38:29] along. Um so I do this demo and people
[38:32] would be impressed. [snorts] The high
[38:34] point of this
[38:37] one day one of those visitors was a guy
[38:39] named William Colby. William Colby was
[38:42] the director of the CIA [snorts]
[38:44] and he was accompanied by a guy who
[38:47] literally had a briefcase chained to his
[38:49] arm [snorts]
[38:51] and Colby was a accompanied by Bill
[38:53] Baker who at that time I think was
[38:55] probably president of Bell Labs but he
[38:57] was also the head of the foreign
[38:59] intelligence advisory board. So he was a
[39:01] serious spook in his own right and so
[39:04] they sat there. Now I had done this
[39:06] spell demo so many times before that I
[39:08] knew it took too long because you know
[39:11] old machines slow etc. So what I did is
[39:13] the night before I ran it into a file
[39:17] and then what I showed Colby was a shell
[39:19] script that said sleep two and then cat
[39:23] previously
[39:24] and so Colby was very impressed with
[39:26] this. I guess
[39:29] it does tell you you don't believe what
[39:30] you see in demos. [laughter]
[39:33] Wh what's in that briefcase? Is it a
[39:35] bomb or a gun?
[39:37] >> It's got to be nuclear codes, right? I
[39:39] mean, I have no idea.
[39:40] >> Interesting.
[39:42] [laughter]
[39:43] >> The gentleman was briefcase was not
[39:45] identified.
[39:47] >> One of the most famous books that you
[39:49] co-authored was the one on the C
[39:50] programming language. And since C kind
[39:53] of came from Bell Labs and you were so
[39:56] close to it, um, you know, why was C so
[40:00] influential in your opinion like now
[40:02] looking back?
[40:03] I think it hit a sweet spot in some
[40:06] sense of efficiency and expressiveness.
[40:11] Um,
[40:12] if you go back to when C was first
[40:14] created, let's just call it 1972ish or
[40:17] something like that, machines were
[40:18] pretty wimpy. They didn't have much
[40:20] memory. The first machine that C ran on
[40:22] had, I think, 24K bytes and that was the
[40:26] whole thing. So, you had to write a
[40:28] compiler. Oh, you had an operating
[40:29] system. You needed a bit space for
[40:31] files. what do you do? Um the disk I
[40:34] think was half a megabyte. Uh so so it's
[40:39] a little tricky. Um so C was
[40:43] simple enough that you could see the
[40:46] translation into the underlying actual
[40:50] instructions of the particular machine
[40:52] the PDB11. At that point um language is
[40:55] simple. You could see the compilation.
[40:57] You could imagine building a compiler
[40:59] for it straightforwardly enough.
[41:01] It wasn't a big language. At the same
[41:03] time, it really was expressive. I mean,
[41:05] you could say what you needed to say
[41:07] very, very effectively in the language.
[41:10] And I think it's hard to find a spot
[41:13] like that. And so, one of the reasons I
[41:15] think C has succeeded as long as it has
[41:18] is that it still has that efficiency and
[41:23] uh
[41:24] oh, I know expressiveness is I think the
[41:27] right word. Certainly there are lots of
[41:29] other languages which for various
[41:30] purposes are better choice at this
[41:32] point. Well, because there are plenty of
[41:35] things that C doesn't do couldn't do at
[41:38] the time because you didn't have enough
[41:39] resources, right? You couldn't do a lot
[41:42] with uh you know fancy runtime stuff.
[41:45] You didn't want to do checking because
[41:47] checking would take code and you come
[41:48] on, you've only got 74k bytes for your
[41:51] program. Now what? So an awful lot of
[41:54] things were uh cut that way. The other
[41:55] thing is the original target for C was
[41:58] to build the operating system and so
[42:00] there's class set of things that you
[42:02] just don't need if you're building an
[42:04] operating system. Um so I think it was
[42:08] for its time a really really really good
[42:11] match and then of course Unix and C was
[42:14] this sort of symbiosis. They went
[42:16] together. So Unix was just so much
[42:18] better than any of the commercial
[42:21] operating systems at the time. all just
[42:24] so much easier to use, so much more
[42:26] productive and so much more fun that
[42:28] people used it in preference and then
[42:30] they would write programs in C and they
[42:32] was all interesting tools and so all of
[42:34] this was kind of a virtuous cycle.
[42:37] >> OpenAI, [snorts] Enthropic and Cursor
[42:39] all used this product to make their
[42:40] lives easier. Work OS is an API platform
[42:43] that adds enterprise features like SSO,
[42:46] skim, and arbback to your app. These are
[42:48] things that you need to sell to other
[42:49] companies but aren't the main focus of
[42:51] what you're building. And now they've
[42:53] added more support for AI agents. For
[42:55] instance, O for agents gives each agent
[42:58] its own identity with short-lived scope
[43:00] tokens instead of a longived API key. So
[43:02] if something goes wrong, you can revoke
[43:04] one session and everything under it
[43:06] dies. Another feature they have is
[43:07] airlock, which is an authorization
[43:09] layer. Every action agent takes is
[43:11] checked against rules that you can write
[43:13] in plain English. So it's not rubber
[43:15] stamping everything and it's not running
[43:17] unsupervised either. And lastly, they
[43:19] have pipes which connects your agents to
[43:21] over 300 third party tools without you
[43:23] ever needing to manage a token. So if
[43:25] you're building SAS or AI agents and
[43:27] selling to enterprises, work OS fills
[43:30] all these gaps in a few lines of code.
[43:32] Check them out at works.com to learn
[43:34] more and get started and I appreciate
[43:36] them for sponsoring my show. Yeah,
[43:39] [snorts] when I learned I guess how to
[43:42] use Unix in college, there's all these
[43:45] these uh utilities like you mentioned
[43:47] diff that Mroy and then there's a
[43:50] variety of other ones. GP and of course
[43:52] there's O I remember I I I learned that
[43:57] a long time ago.
[43:58] >> Oh, good.
[43:58] >> Yeah. [laughter]
[43:59] Um yeah, what's the story behind that
[44:01] and and why did you build it? So this is
[44:05] back in the mid70ish
[44:08] time, 767
[44:10] I guess. Um
[44:13] Al Aho and I had been friends for a long
[44:15] time. He went here at Princeton. He and
[44:17] I were undergrads at Toronto, although
[44:19] he was always a year ahead of me. Um and
[44:22] and he was very interested in regular
[44:24] expressions, you know, patterns of text
[44:26] that you could use to recognize
[44:28] interesting stuff. I had been fooling
[44:31] around pretty unsuccessfully with the
[44:33] idea of some kind of text editor that
[44:36] would let me manipulate numbers as well
[44:38] as text, you know, something like that.
[44:41] And Peter Weinberger, who I don't
[44:43] remember exactly how we met him, um was
[44:47] interested in database kinds of things.
[44:51] And so we sort of talked back and forth
[44:54] and came up with this language which
[44:56] combined some of those interests. the
[44:58] regular expression stuff from Al um the
[45:01] databasey flavor and report generation
[45:04] like RPG uh from Peter and the sort of
[45:07] wouldn't it be nice if strings and
[45:09] numbers were kind of treated were both
[45:12] first class citizens of whatever we were
[45:14] doing. So we thought about it for a
[45:17] while and then if a memory serves we
[45:21] came up with a sort of language design
[45:23] and then Peter went off one weekend and
[45:24] built it.
[45:27] not Peter's extremely good programmer
[45:30] too. Um, but he had the advantage of
[45:33] tools at that point because he could
[45:35] define the grammar with Yak, the
[45:37] compiler compiler that Steve Johnson had
[45:39] built and the lexical part with Lex, the
[45:43] lexical analyzer generator that Mike Le
[45:45] had built. And so from that, building a
[45:49] language was not as much work as it
[45:51] would have been otherwise. There was
[45:52] some just more of it was kind of built
[45:55] for you. Um, and Al had the regular
[45:58] expression code already because that
[46:00] came from Egret. And so,
[46:03] you know, you take this on one very
[46:04] bright good programmer over a long
[46:07] weekend or so and you've got a language.
[46:09] Oh, and then from there we just sort of
[46:12] evolved it slowly and then uh Alan Peter
[46:15] dropped away from actual active
[46:17] maintenance probably 5 10 years later
[46:19] and I sort of inherited it. A lot of
[46:22] these Unix tools that everyone takes for
[46:23] granted, is that usually the story
[46:26] behind them, which is you guys are all
[46:28] using Unix and then you just realize,
[46:31] oh, I I want to be able to pipe this to
[46:33] something that diffs or I want to be
[46:35] able to find something and uh and then
[46:38] it you guys just build it. Is that
[46:40] usually how these come about?
[46:42] >> I think a lot of them come from that.
[46:43] It's not from hypothesizing what
[46:45] somebody else might find useful. It's
[46:47] more like my what do I need? it's kind
[46:49] of bothering me at this point that I
[46:51] could improve if I just had a better
[46:53] tool or a language or something. And and
[46:56] I think that's true on almost all of the
[46:59] little tools uh that you mentioned. It's
[47:03] you know gee
[47:05] I don't want to do this by hand or
[47:07] existing programs aren't quite right.
[47:09] Let me build something new and be very
[47:11] easy. Oh for example make over which
[47:15] Steve Feldman did. You know, somebody
[47:17] told me, "Oh, I was I
[47:20] my program didn't work. I can't figure
[47:22] out why it didn't work." Oh, it's
[47:23] because I forgot to recompile one of the
[47:25] files. And so, could you in some way
[47:28] automate that? And that's another one of
[47:30] these weekend projects that uh Stu did.
[47:34] And then, boy, [snorts]
[47:37] within a few days, he's got a bunch of
[47:39] users. And then all of the mistakes he
[47:40] made in his first design he can't fix.
[47:44] So, and I think all of these have that
[47:47] same problem. Certainly, there are
[47:48] things in awkward or in hindsight. Oh my
[47:50] god, we should have done that better.
[47:53] >> A lot of the the namesakes for these,
[47:56] they either explain themselves like
[47:58] diff. I think it's pretty clear. And
[48:00] then a is the initials of the authors,
[48:03] but GRAP is a really famous tool. But
[48:06] what's the the story behind the namesake
[48:08] of that?
[48:09] >> Oh, yeah. graph. Ken Thompson tells it
[48:11] very well, but the gist of it is that in
[48:14] the text editor, the ED text editor,
[48:18] which was the first real editor on the
[48:20] Unix system, um there is a command
[48:22] called G, which says do the
[48:26] this command on all of the lines that
[48:28] match a particular regular expression.
[48:30] And the syntax is in fact G SE whatever
[48:33] the regular expression is SLP print all
[48:36] the lines that match this pattern. and
[48:39] hence grap.
[48:41] >> We talked a lot about Bell Labs and you
[48:44] know you mentioned kind of the golden
[48:47] years. When you look back on Bell Labs
[48:50] and your time there, what is it that you
[48:52] miss most?
[48:54] >> Well, I miss the people. Although I'm
[48:56] still in contact with a fair number of
[48:58] them one way or another. Um but the
[49:00] people were it was just an amazing
[49:02] collection of really good nice people,
[49:04] bright, fun to work with, lots of good
[49:06] ideas and so on. So you miss that. One
[49:09] thing that probably is not reproducible
[49:11] in a direct sense is the um environment
[49:13] where there just all kinds of new things
[49:15] to do. So it was an era of lowhanging
[49:18] fruit if you like. I suspect there's
[49:21] similar lowhanging fruit, but I'm not in
[49:22] the right orchard at this point. I just
[49:24] don't know enough about it. But you
[49:26] know, maybe some of the AI stuff that's
[49:28] going on is is the moral equivalent at
[49:30] this point. Um so I think those are the
[49:33] things that are perhaps the most things
[49:36] that I miss. Uh, Bell Labs gradually
[49:40] became more of a conventional company as
[49:43] AT&T went through troubled times and
[49:46] split itself and split itself and so all
[49:48] the fish products were smaller and it
[49:50] meant that the Bell Labs, the big
[49:52] cohesive bunch of people working on all
[49:54] kinds of things became smaller and more
[49:56] fragmented and didn't have as much money
[49:58] and therefore were forced to do the
[49:59] kinds of things you don't want to do
[50:01] like raise money. So that part I don't
[50:03] miss at all. In one of the classes that
[50:06] you taught, there's a video somewhere
[50:09] buried deep in YouTube where you are um
[50:13] trimming your beard in the lecture.
[50:16] >> Do you remember that? And what what's
[50:17] the reason for um you know grooming
[50:20] during the lecture?
[50:20] >> I remember that one. That is actually
[50:22] you should ask David. He was in that
[50:24] class. Um that was at Harvard. That was
[50:27] the first lecture of CS50 the year I
[50:30] taught it at the beginning. So they'd be
[50:32] September of 1996 I think. Um I had
[50:37] never taught a big class before. Um the
[50:40] class had been taught by Margot Seltzer
[50:42] who at the time was in computer science
[50:44] there and she was taking a sbatical and
[50:46] she asked if I would be interested in
[50:47] teaching her a course and I thought only
[50:49] chance I'll ever get to teach at
[50:50] Harvard. Why not?
[50:53] But Margot had a stickick that she did
[50:55] at the beginning of her first lecture
[50:57] which was trying to explain to people
[50:59] why it's hard to tell a computer what to
[51:02] do. And so she would get the audience in
[51:05] her class to direct her in making a
[51:08] peanut butter and jelly sandwich. And
[51:10] you know, it'd be very easy to get the
[51:11] jelly on the desk and the peanut butter
[51:13] on your head and you know, stuff if the
[51:14] instructions weren't clear. But I'm not
[51:17] a peanut butter and jelly kind of
[51:18] person. And I thought, what's the
[51:20] equivalent? And then it occurred to me I
[51:22] have this ratty beard.
[51:24] So, I brought in a a collection of
[51:28] equipment suitable for trimming a beard,
[51:31] ranging from a pair of scissors to
[51:33] electric hedge trimmers. And I got the
[51:36] audience to try and guide me through
[51:38] trimming my beard with this stuff.
[51:41] And I don't remember, I think actually
[51:44] the hedge trimmers were plugged in, but
[51:45] it was want to be very careful here.
[51:49] >> So, you mentioned that was your first
[51:51] big class.
[51:52] >> Yes. 457.
[51:55] >> Was public speaking nerve-wracking at
[51:57] that time for such a large group?
[52:01] No, I I think originally when I was like
[52:03] a grad student or something, public
[52:05] speaking was very challenging, but I
[52:09] when one of the things I did first at
[52:11] Bell Labs and one of those I think
[52:14] [snorts] maybe even intern years, I
[52:17] don't remember now, was um Vic Fatsky
[52:20] who was across the hall from me said,
[52:21] "We've got a bunch of physics guys who
[52:23] need to learn forran. Would you mind
[52:24] teaching them?" And so [snorts] I did
[52:26] that. And so the the teaching experience
[52:29] got me over this fear of public speaking
[52:33] totally completely. Uh and so I had I
[52:37] had done a bit of adjunct teaching uh
[52:40] while I was at Bell Labs earlier before
[52:42] the Harvard gig that was by far the
[52:44] biggest like at least more than an order
[52:46] of magnitude the biggest but at that
[52:48] point it's not the size of the audience
[52:51] so much it becomes it's a theater
[52:53] performance and
[52:56] David M can tell you that more
[52:57] accurately because he's really good at
[52:59] it.
[53:01] So if um someone who is a student who's
[53:04] scared of public speaking asks you for
[53:06] advice, what would you tell them?
[53:09] >> I think doing it getting into an
[53:12] environment where you have to talk to
[53:14] people and in at least small group to
[53:17] begin with and then maybe bigger one is
[53:19] okay. Um and I think there's no no
[53:23] better way than actually just doing it,
[53:26] getting out there and forcing. So, so
[53:28] I'm past the stage where I worry about
[53:30] that sort of thing. I guess conference
[53:32] presentations are sort of like that too,
[53:34] but but teaching's better because it's a
[53:37] more intimate setting for the most
[53:39] passing over 400 people, but you know,
[53:41] it's it's a more intimate setting. And
[53:43] so, um, you got a better way to judge
[53:45] whether you're content
[53:48] or whether they're understanding you or
[53:50] not. And if you think of them as friends
[53:52] or something like that and then you blur
[53:53] a little your vision so you're not
[53:55] really looking directly. It looks like
[53:57] you're looking at them but you're not.
[53:59] Or you focus on one person in the
[54:01] audience who seems to be resonating. All
[54:03] of these things I think help.
[54:05] Um but after a while it just becomes
[54:08] practice and then you don't don't worry
[54:10] about it. I know you still lecture here
[54:13] at Princeton from time to time and it
[54:16] seems like more recently the education
[54:20] may be changing because of some of this
[54:22] LLM AI stuff. I mean unprecedented
[54:25] access to answers I guess. Do you
[54:28] believe that LMS are a net negative or a
[54:32] net positive when you look at education?
[54:36] >> I think it's too early to tell. I can
[54:38] see plenty of elements of both sides of
[54:40] that.
[54:41] Um, one concrete example that I have
[54:45] heard reported by all kinds of people
[54:47] around here is that students don't come
[54:50] to office hours.
[54:53] They're presumably getting whatever it
[54:55] is from their favorite large language
[54:57] model and so they don't come in and talk
[55:00] to faculty or the preceptor or grad
[55:03] students or whatever it is. They just
[55:04] don't do that very much. Um, and I think
[55:08] that one's a net loss.
[55:10] the bandwidth when you're talking to
[55:12] somebody in person is enormously higher
[55:14] than when you're talking to Claude or
[55:15] whatever. Um, and the other thing is
[55:19] that the human contact that you get from
[55:21] this is useful in all kinds of ways. Not
[55:25] the least of which is that if you come
[55:26] in and talk to some faculty member, that
[55:28] person now know who's you are and they
[55:30] can say, "Oh, did you know here's an
[55:32] opportunity? Here's a somebody looking
[55:34] for a job, whatever." So, they're
[55:36] missing the kind.
[55:38] it's not it's not transactional that
[55:40] they're missing that human connection
[55:43] that helps
[55:45] in the future. So So I'm sorry to see
[55:47] the the office hours go away. Um
[55:51] I think a weird
[55:56] I don't know why you call it an upside
[55:57] or a downside of this in computer
[56:00] science in particular. Enrollments are
[56:02] down. So, we have many fewer computer
[56:04] science majors than we did a few years
[56:06] ago and that means the classes are
[56:08] smaller. Not entirely because many of
[56:10] those people just went to other
[56:11] departments, but they're still taking
[56:13] our courses, but they're somewhat
[56:14] smaller and that means that there's more
[56:16] contact with the students and I think
[56:18] that's good. So,
[56:21] >> what percent down would you say? our
[56:24] numbers are I don't know where they're
[56:26] rep I think they're more extreme for
[56:28] some unknown reason but I think our
[56:33] the class that just graduated in uh this
[56:36] the summer spring of 2026 was a little
[56:41] over 200 computer science majors. The
[56:45] class that will graduate two years later
[56:47] is probably going to be less than half
[56:49] that.
[56:50] >> Less than half.
[56:51] >> Yeah.
[56:52] >> Wow.
[56:52] >> Maybe even down to a third. We don't
[56:54] know because there's a staggered way in
[56:55] which majors appear but but I would
[56:59] guess that if it was 200 it'll be sort
[57:01] of 80ish 90 pure guess work but quite a
[57:05] bit more. Those people have gone in here
[57:09] to electrical and computer engineering
[57:11] and mechanical and aerospace engineering
[57:13] because those I think are more concrete
[57:16] hardware oriented less likely to be
[57:19] replaced by large language models.
[57:21] [snorts] So the kids are voting with
[57:22] their feet. I think uh to some extent
[57:26] that's totally understandable. I think
[57:28] they may be overreacting, but I don't
[57:31] know. And if you just read the popular
[57:34] press, my god, we don't need programmers
[57:36] anymore.
[57:38] I think that's fortunately
[57:39] oversimplified, but but I don't it's not
[57:43] my problem in the sense that I have a
[57:45] job and they quite rightly are worried
[57:47] about what they're going to do when they
[57:48] get out of here.
[57:50] >> All right. So the the total number of
[57:52] students that go to Princeton is roughly
[57:54] constant.
[57:55] >> Oh, it's con it's totally constant.
[57:56] >> Okay. But the proportion that goes to
[57:58] the computer
[57:58] >> different different fields is different.
[58:01] And I don't know I I know those
[58:04] particular numbers for where did where
[58:07] does it look like computer science
[58:09] people went over the last you know
[58:12] voting with their feet right now and it
[58:14] looks like mostly to electrical computer
[58:16] engineer mechanical aerospace for the
[58:18] robotics aspect.
[58:20] I saw you're an extra on the film A
[58:23] Beautiful Mind. It's a great movie. And
[58:26] before the interview, I was trying I was
[58:28] like kind of combing through the the
[58:30] movie trying to find you, you know. How
[58:32] did that come about? And what's it like
[58:34] to be a part of such a big movie?
[58:38] [snorts]
[58:39] >> You know, that that was enormous fun.
[58:42] They did a casting call uh for that
[58:44] because parts big parts of it were going
[58:46] to be shot at Princeton. Um, and this
[58:50] was just shortly after my wife and I had
[58:52] moved to Princeton, so I don't remember
[58:54] the date, but call it 2001ish.
[58:57] Um, so they had a casting call and so a
[59:00] bunch of people showed up in one of the
[59:02] big classrooms and we heard the story of
[59:04] what was going to happen and then um,
[59:07] some guy wandered around and said, "You
[59:10] and he didn't pick my wife, which I
[59:12] thought was nuts, but he pointed at me."
[59:15] Okay, so this was the casting call. And
[59:18] then later on I got uh invitation please
[59:22] come and we're going to do some shooting
[59:24] of the Nobel Prize ceremony.
[59:27] So you'll find me there. I can tell you
[59:28] where to find me. U the reason you don't
[59:30] recognize me is first nobody is wearing
[59:32] glasses because they would reflect. And
[59:35] secondly I am wearing black tie
[59:38] something which I have never worn in my
[59:40] life because [clears throat] this is a
[59:41] Nobel Prize ceremony. Um, and it was
[59:46] shot in the Newark Performing Arts
[59:48] Center, so a place I had never been
[59:51] before. And it took about 22 hours to do
[59:55] that. But because you got there at sort
[59:58] of 5 in the morning, you had to be
[59:59] dressed properly. Um, and then there
[60:02] were shooting and shooting and shooting
[60:03] and shooting and lots of dead spots
[60:05] while I, you know, rearranged the
[60:06] cameras and so on. Um, but it was really
[60:10] interesting and I got paid. Not equity
[60:12] rates, but I got paid. I got something.
[60:14] I would have been better off to flip
[60:15] burgers at McDonald's for the [laughter]
[60:18] [snorts] uh and then the movie came out
[60:20] and and it was fine. But the wonderful
[60:22] thing is that I got an airish bacon
[60:24] number of five.
[60:25] >> Eridish bacon. So, okay. What those
[60:28] numbers represent how far you are from
[60:31] those people works
[60:33] >> in in in their related works. So, my my
[60:35] airish number is three because I can go
[60:37] through several people a couple of paths
[60:39] to in steps, three steps. But my Bacon
[60:42] number is two because I was in this film
[60:45] with somebody who was in a film with was
[60:48] Kevin Bacon.
[60:50] So that [snorts] anyway that's the the
[60:51] the gist of it. I actually met John Nash
[60:54] a number of times after that. Um
[60:57] >> the not the actor, the real
[60:59] >> the real John Nash. Yeah. Yeah. He was
[61:01] >> you know he was kind of let's call it
[61:04] introverted or something like that but
[61:05] perfectly fine. The scary story for me,
[61:09] I was giving a talk, I don't remember
[61:12] how it came about, but I was giving a
[61:13] talk to an internal group in the math
[61:15] department about something that I had
[61:18] worked on. I'd forgotten what it was.
[61:20] And I was, you know, into this. I had
[61:22] been going 10 minutes or something. And
[61:24] I was on a roll and I'm not scared of
[61:25] audiences or anything. I was having a
[61:27] good time. And John Nash walked in
[61:32] and I could just feel everything
[61:33] tightening up inside. [laughter]
[61:34] And then he asked some question. I don't
[61:36] remember what the question was or
[61:37] anything like that, but [sighs] I got
[61:40] over it.
[61:42] But but that that's one of the few times
[61:44] where public speaking is kind of a bit
[61:46] of a threat. Another interesting factoid
[61:50] that I wasn't sure if this is true, but
[61:53] so in the the git repo for the Go
[61:57] programming language, actually the first
[62:00] commit in it is from you in 1972
[62:04] supposedly,
[62:06] but the you know the programming
[62:08] language started in 2008. So
[62:10] >> yeah, right. I have no idea what this
[62:12] is.
[62:13] >> Okay. You've never seen
[62:14] >> this is news to me.
[62:16] >> Okay. Yeah, it's supposedly I mean I
[62:19] found it says first commit to the go get
[62:23] ret.
[62:23] >> Oh, is it a hello world example? That's
[62:25] the B program.
[62:26] >> Yeah. Yeah. Yeah. It's it's in B for
[62:28] some reason,
[62:29] >> right?
[62:30] >> So, uh
[62:32] >> and this is followed up by commit 1974
[62:34] to convert it to C and then another one
[62:37] to convert to NC. So, maybe Robert
[62:41] copied your hello world repo and used it
[62:44] to start going. I never used git at that
[62:46] point. I don't think I started using git
[62:48] until maybe 10 years ago.
[62:50] >> Interesting.
[62:52] So then what did you use was there the
[62:54] notion of version control back then
[62:56] because somehow
[62:57] >> version control came along in the
[62:59] mid70s.
[63:01] There was something done by the
[63:04] programmers work people I think called
[63:06] SECS the source code control system.
[63:10] uh and that was widely used inside the
[63:13] labs and I think outside and then there
[63:14] was RCS by Robert Titchy which was a
[63:19] variant of the same thing revision
[63:21] control system and then there was
[63:24] CVS was it concurrent version system or
[63:28] something like that and then some other
[63:29] version of it and then get and and
[63:33] others scattered around. So, it's an old
[63:35] idea, but in 1972, it did not exist. I
[63:38] mean, Unix didn't exist in 1972. That B
[63:40] program ran on something else. [snorts]
[63:43] >> Interesting. Okay. Yeah. I guess it'll
[63:45] just remain a mystery. Maybe maybe
[63:47] Robert can uh answer or something if I
[63:50] ever interview him. In your memoir,
[63:55] there's a thank you to Grace Emlin. Mhm.
[63:59] >> And then I dug a little more and I also
[64:01] found this um Bell Labs alumni tracker
[64:05] and it kind of shows where all the
[64:07] alumni go and Grace Emlin it said uh
[64:11] relocated witness protection program and
[64:14] so curious what what that is about.
[64:18] There was this period of time,
[64:22] forgotten the dates, when Bell Labs
[64:24] decided that employees had to have they
[64:28] had to wear their badges so that if you
[64:30] were walking through the hall, people
[64:32] would know that you were an employee as
[64:33] opposed to a tourist of some sort or
[64:35] other. Um, and people were not very
[64:38] enthused about wearing badges. And so
[64:40] there was a bunch of kind of quiet
[64:44] insurrection about it. And one of the
[64:47] bits of insurrection was the creation of
[64:49] badges that were fakes. And so, uh,
[64:53] Grace Emlan was a creation of
[65:00] I think it was probably Fred Gramp who
[65:03] did it. There's this Gremlin thing. And
[65:05] so, Grmlin Grace. Um, and we managed to
[65:09] get Grace into a variety of official
[65:11] records for the company for a while. and
[65:13] and she uh this little gremlike thing,
[65:18] you know, this high sat in the Unix room
[65:20] with her badge on, but there were other
[65:23] people who had weird badge. I had a
[65:24] badge with Mickey Mouse on it. And so I
[65:27] probably still have it in my desk, but I
[65:29] will try to get it. Um that I used to
[65:32] wear all the time. I mean, it was I
[65:34] don't wanted to. Nobody looked at the
[65:36] badges. They just see a blur and there
[65:38] was a badge, so it was okay. So I wore
[65:39] this badge all over the place. I wore it
[65:41] when I met Bill Gates at one point. I
[65:44] don't think he noticed either.
[65:47] [snorts] And so, you know, people didn't
[65:49] take kindly to bureaucratic stuff, even
[65:52] though probably badges were a fine idea.
[65:56] >> Was the badging system digital at that
[66:00] point?
[66:00] >> No, that was just paper. Pieces of
[66:02] paper. Oh,
[66:03] >> okay. [snorts]
[66:03] >> Or they were pieces of plastic, but you
[66:05] could [laughter] put your own paper in
[66:07] front of it. another thing. So I found
[66:10] somewhere on the internet in some very
[66:12] old repository
[66:14] there was a a secrets file that was
[66:17] committed to the the repo and everything
[66:21] in there is encrypted but it was
[66:23] encrypted by the old dees security
[66:27] standard. So it's possible to brute
[66:29] force unencrypted with uh modern day and
[66:33] so you and all your colleagues's
[66:36] passwords are actually [laughter]
[66:38] >> so I saw yours is I mean I'm assuming
[66:42] it's okay. Yeah, it's just slash period
[66:45] comma slash period comma.
[66:46] >> Really easy to type quickly. Yeah. No,
[66:48] it's funny. I hadn't seen that. I got
[66:50] mail from Eric Schmidt saying, "Gee, did
[66:52] you see this?" [laughter]
[66:54] Sent to several of us. Um, and so it was
[66:56] intriguing to see what the passwords
[66:58] were. I I I guess you're probably right.
[67:00] It probably was either dees or some
[67:03] World War II machine like a Haggelan
[67:04] machine or whatever that the crypt
[67:06] program was based on. In our defense,
[67:09] this was at a time when the machines
[67:11] weren't
[67:12] and the passwords were kind of why would
[67:14] you need them anyway sort of thing. Uh,
[67:17] and so, you know, we didn't pay much
[67:19] attention to them. Um, and I guess the
[67:22] other thing is the password file, this
[67:25] was I think a tape that had was from
[67:28] Berkeley and so I don't know somebody
[67:30] must have copied the password file from
[67:32] the research Unix things at Bell Labs
[67:35] over to some Berkeley system. Don't know
[67:37] how it got there.
[67:39] >> Coming to the end, um, yeah, I know you
[67:42] you wrote a ton of books in your career,
[67:45] very prolific. I mean, there's the Cbook
[67:48] that was just one of many, though.
[67:51] What's your motivation for writing all
[67:53] these books?
[67:55] >> I find it fun. I think it goes back to
[67:57] something you asked about earlier.
[67:59] Trying to explain stuff to people who
[68:01] are not experts in it. In some way, I
[68:04] find that attempt to communicate
[68:06] rewarding, worthwhile. Um, it's a way to
[68:10] have influence at a distance perhaps.
[68:12] So, teaching is kind of retail. You're
[68:14] in the same room with a bunch of people.
[68:16] Writing a book is wholesale if you like.
[68:20] you're you're not you won't meet most of
[68:22] the people who wait might look at a book
[68:25] but with luck they will also learn
[68:26] something from it. Um
[68:30] partly it's a way to learn the stuff
[68:31] yourself and
[68:34] I guess partly it's just that once
[68:36] you've done one
[68:38] you do more. I remember a conversation
[68:40] with Don Kuth eons ago where uh he said
[68:44] that there are people who have written
[68:46] no books, there are people who have
[68:47] written one book and there are people
[68:48] who have written many books and so I
[68:50] guess I'm in that third category sort
[68:52] of.
[68:52] >> Yeah. I for me it's kind of fun and so
[68:54] I'm still doing it. This is your chance
[68:56] to do a commercial announcement.
[68:58] [laughter]
[68:59] >> Yeah. What's your latest book actually?
[69:01] >> Yeah. So I I I did a book um over the
[69:04] last year or so, a history book of
[69:06] important ideas in computing and will
[69:08] appear from MIT Press in January, end of
[69:12] [snorts] commercial announcement.
[69:14] >> Is is that the memoir? Oh, no, this
[69:15] hasn't come out yet.
[69:16] >> Yeah, this hasn't come out yet. Over
[69:17] there underneath your camera is a the
[69:19] cover of it. Uh
[69:21] >> oh, shifts.
[69:22] >> Yeah, right.
[69:23] >> Okay.
[69:24] >> It's it's available on Amazon, but it
[69:27] won't appear until January or something
[69:28] like that. But the idea is that there's
[69:31] a bunch of interesting things that have
[69:32] happened in computing where something
[69:34] there was a change in a different
[69:36] context. You'd call it a paradigm shift
[69:38] like the Thomas Kern idea, but it's not
[69:39] really quite but you know the shift from
[69:41] analog to digital big different. I mean
[69:44] all the camera stuff you're doing here
[69:45] would not be feasible with film, right?
[69:49] Uh and so there's the stored program
[69:51] computer the idea that you can build one
[69:53] general p device that will kind of do
[69:56] anything you want uh just by giving it
[69:58] different instructions and so that's a
[70:00] big deal uh there's all the integrated
[70:03] circuitry stuff that the evolution
[70:05] started with the transistor and to IC's
[70:09] today all of that stuff again all what
[70:11] you're doing here wouldn't be possible
[70:13] all our computers wouldn't be um
[70:16] programming languages you know if we
[70:18] were still writing
[70:19] assembly language, it would be pretty
[70:21] bad. But the evolution of programming
[70:23] language is making it ever easier to
[70:26] tell computers what we want to do. And
[70:28] so go on like that. Pick another. And
[70:30] then the the the final uh thing that's a
[70:32] big big paradigm shift that's different
[70:35] I think from most of the others is that
[70:38] we're in the middle of it and it's
[70:39] incredibly visible and that's the AI
[70:42] large language model stuff which is
[70:44] changing incredibly rapidly and is
[70:47] affecting everybody and everybody's
[70:49] noticing it which is different from most
[70:51] of the other things that we've talked
[70:52] about. So um took my wife who is not a
[70:57] computer person is interested in
[71:00] learning more about what's going on with
[71:01] artificial intelligence large language
[71:03] models explain this what's that mean
[71:05] what what's the future going to be um
[71:07] and so that paradigm shift I think is
[71:10] really really really uncertain and we
[71:12] are very much in the middle of it and
[71:13] everybody knows about it so [snorts]
[71:15] anyway now I've given you the synopsis
[71:17] of the book go buy it
[71:18] >> yeah [laughter]
[71:20] >> the um you know with with this this AI I
[71:24] and you know all these LMS one of the
[71:26] big things that we've seen is that they
[71:28] can write all the code actually like a
[71:30] lot of my peers genuinely
[71:33] could say 100% of the code in the last
[71:36] so [snorts] many months was written by
[71:40] uh an LLM and so a lot of people who
[71:43] really love computing or love writing
[71:46] code it's actually kind of sad for them
[71:49] to see you know these things become
[71:52] obsolete like typing things out and
[71:54] stuff. I was curious in your
[71:57] career in computing there must have been
[71:59] points where something became obsolete
[72:01] maybe like the punch cards or I don't
[72:03] know something like that. And I guess
[72:05] how did you feel at that time?
[72:07] >> Yeah. Well, I don't miss punch cards in
[72:09] the slightest. [laughter]
[72:11] No way. I I was thinking, you know, my
[72:14] my thesis was done on my PhD thesis was
[72:17] done on punch cards and that was three
[72:19] boxes of cards and I realized that that
[72:20] was 30 pounds of stuff I had to carry
[72:22] around for my thesis.
[72:25] So that's so there are certain things
[72:27] like that I don't miss. Um there are
[72:29] other things that you miss the kind of
[72:32] call it the intellectual challenge or
[72:34] the puzzle solving or the whatever where
[72:36] you write a piece of code. So right at
[72:38] the moment I'm teaching class that
[72:40] involves C programming. So it's back to
[72:43] early days and you know I haven't
[72:46] written much C for a longish time and
[72:48] it's kind of fun to get back into it and
[72:50] sort of rethink and relearn you know oh
[72:53] that's what pointers are all about kind
[72:55] of thing. Um so I suspect most people
[72:58] don't miss that sort of thing because
[72:59] the memory management aspects are a
[73:02] pain. On the other hand, the challenge
[73:05] and the fun of figuring it out and
[73:07] getting it to work and so on is there.
[73:10] Now, the same fun and challenge and
[73:11] getting it to work is going to be true
[73:13] if you're writing in Python. Is it there
[73:16] if you prompt your favorite
[73:19] claude or whatever to generate it for
[73:22] you? I don't think so. I don't think
[73:24] that at all. And and even once the
[73:27] program is generated for you, you still
[73:29] have to see whether it works and whether
[73:31] it's the most effective way to do what
[73:33] you want and is it really doing what you
[73:35] want or should you have wanted something
[73:36] different and all of those sorts of
[73:38] things. And that's in in an environment
[73:40] where you know what you're doing. I've
[73:43] been using uh mostly claude but uh
[73:47] others as well to generate SQL because
[73:51] I'm not an ex SQL expert and I have a a
[73:54] colleague over at the Institute for
[73:56] Advanced Studies who has a database.
[73:58] She's not a programmer at all but she
[74:00] wants to query her database effectively.
[74:02] So I need something to generate SQL from
[74:06] natural language queries. So I want to
[74:08] say give me all of the whatevers that
[74:10] have this property and get the large
[74:13] language model to generate the SQL and
[74:15] then run it through the database. How do
[74:18] I know whether it gave me the right
[74:19] query? Because I'm not an SQL expert and
[74:22] we if we already knew the answer, we
[74:24] wouldn't need it. And so I'm wrestling
[74:27] with that. And my observation is
[74:32] 90% of the time it generates a perfectly
[74:34] fine query and 10% of the time it
[74:36] doesn't. gives you a totally wrong
[74:38] answer and I don't know which is which.
[74:40] It sounds like what you're saying is you
[74:42] need some domain expertise otherwise you
[74:44] can't be the judge of if it's
[74:46] >> you need domain expertise probably it's
[74:48] the same domain expertise you always
[74:50] needed um you need ways of validating
[74:53] what you do because you can't be
[74:55] sufficiently expert that you can test a
[74:57] big program all by yourself so you need
[74:58] something AI again to help you with
[75:01] generating the test but then you need
[75:02] something to evaluate whether the tests
[75:05] were properly generated and there's this
[75:07] infinite regress of you know check the
[75:11] checker who checked the checker kind of
[75:13] thing. Um now I'm oversimplifying and
[75:16] I'm not a high-powered user and I know
[75:18] plenty of people who as you described
[75:20] her are you know essentially everything
[75:22] they used to do they have outsourced to
[75:25] something like a large language model
[75:28] and I don't know what they're giving up
[75:30] by doing that in one sense they're
[75:32] getting a lot out of it they're probably
[75:34] 10 times as productive as they used to
[75:36] be in terms of code to get some
[75:38] functionality
[75:40] and at the same time they're probably
[75:41] losing 10% % of their brain cells are
[75:46] failing to exercise them properly. And I
[75:48] I don't I just don't know it. It's early
[75:52] and things whatever we say today in a
[75:55] week or a month will not probably be
[75:57] correct anymore. The place where this
[76:00] shows up right around here at least is
[76:02] kids worrying about what's going to
[76:04] happen when I get out of here. I wanted
[76:06] to be a software engineer.
[76:08] Does that job still exist? And the
[76:10] answer is maybe. But it's different than
[76:13] it would have been two or three years
[76:15] ago. And by the time they graduate in a
[76:17] year, it' probably be different yet
[76:18] again. And
[76:21] question is how do we on the faculty
[76:24] side of things, let's say, help them
[76:26] manage this? What do we try to teach
[76:28] them? How do we get them to have the
[76:32] right habits of thought or whatever so
[76:34] that they are able to go, you know,
[76:38] thrive in this brave new world? And the
[76:41] short answer is I have no idea either.
[76:43] >> And uh I don't think anywhere does.
[76:47] >> In the world you describe, which is
[76:49] today's world, the models are not
[76:51] perfect. There's a lot of subtleties
[76:53] where they get things wrong. But in a
[76:56] world where they are perfect and they're
[76:59] kind of doing everything, what just like
[77:02] out of curiosity, what happens to a
[77:04] computer science major? Well, I mean,
[77:06] first you you have a premise there which
[77:08] is that these things will become perfect
[77:10] and I suspect they won't become perfect
[77:12] although they may become a lot better
[77:13] than they are right now. So there's
[77:15] probably still going to be need for
[77:16] somebody to assess their perfection. Um
[77:20] I think the nature of what people do
[77:22] with them will change in the same way we
[77:24] don't have people writing assembly
[77:26] language very much anymore. We trust our
[77:28] compilers and in fact we don't write C
[77:30] very much. if you're at higher level
[77:31] languages and so this may be another
[77:35] step up the call it the abstraction
[77:37] chain or something like that but you're
[77:39] still going to need people to guide it
[77:40] and you know what's the right sensible
[77:43] direction to go the other thing is that
[77:45] people will be able to build more
[77:47] interesting things because of this so I
[77:50] have a student from a couple of years
[77:52] ago graduated a couple of years ago who
[77:54] is doing a very very successful
[77:57] interesting company using artificial
[78:00] intelligence large language models to do
[78:02] translation of natural languages mostly
[78:05] for user interator based kinds of
[78:06] things. Um and I think his company is
[78:09] going to be very successful and it's
[78:12] interesting work and as the large
[78:15] language models improve it just means
[78:17] that he can do a better job at what he
[78:20] is already doing and offering to his
[78:23] customers. So I think that kind of thing
[78:24] will probably continue to happen.
[78:27] >> When when C came out were people
[78:29] mourning assembly language.
[78:32] >> I think it would be before that. I think
[78:34] it was when forrren came along. If you
[78:37] look at what John Bakus said when he was
[78:40] and his group at IBM were working on
[78:42] forran this would be roughly 56
[78:46] 57 that kind of era I guess. Um
[78:52] he was very afraid that people would not
[78:56] accept this new tool because it would
[78:58] not generate code that was as good as
[79:01] people could generate that the assembly
[79:03] language came out or the program
[79:05] wouldn't be as efficient. And so in the
[79:08] design of forran he quite consciously
[79:10] stayed away from elegance and and so on
[79:14] and aimed towards efficiency of the
[79:16] translation and and so it was a genuine
[79:18] concern and at some point along the way
[79:21] their program their compiler started
[79:23] finding optimizations that people didn't
[79:26] and that's the point where he figured
[79:27] maybe this is going to fly now after
[79:30] that I suspect people did mourn you know
[79:33] the skill and the whatever that goes
[79:35] into assembly language age program, but
[79:37] for most people, nah, they just wanted
[79:40] to get the results. And forrren was a
[79:41] boatload better than assembly language
[79:45] in multiple directions. It was easier to
[79:47] learn. If you were a physicist or a
[79:49] chemist, you could learn forran where
[79:51] you never learn, you know, I know 7090
[79:53] assembly language. And furthermore, if
[79:55] you got it working once, you could put
[79:56] it on multiple different machines.
[79:59] when you look across your whole career
[80:01] because you you've worked in a bunch of
[80:04] different programming languages and
[80:06] you've taught a bunch of different ones.
[80:08] Are there any that stick out to you as
[80:10] your favorite or your least favorite?
[80:14] [clears throat] I if I think about what
[80:16] I do on a day-to-day basis, if I write a
[80:17] program, it tends to be a small one and
[80:19] it's an o
[80:22] kind of silly but okay. At least I know
[80:24] it. Um, if [snorts] I were to write
[80:26] bigger ones, I would almost surely write
[80:28] them in Python because for many things
[80:30] that's the right compromise. Uh, it's
[80:33] certainly efficient enough for anything
[80:35] I do. Um, and it's totally expressive
[80:37] for the kinds of things I might want to
[80:39] do. I will occasionally go back to C
[80:42] because I've got some older program and
[80:43] maybe I want to do something with it or
[80:45] as I've said, I'm teaching it at this
[80:46] point. So, so those are kind of the
[80:49] languages that I wind up using. Not very
[80:51] many. Um, are there languages I wouldn't
[80:53] use? So, who shall I insult today?
[80:56] [laughter]
[80:58] I used to in my class, I haven't done
[81:00] this for a long time, but I used to
[81:02] basically write the same program in as
[81:05] many languages as I could find. Um, it
[81:08] was a simple program. You would take
[81:10] text input lines of arbitrary lengths
[81:13] and put them out so that the lines were
[81:15] all at most 60 characters or something.
[81:18] So, it's a simple-minded version of the
[81:20] reflow that you would see in a in a
[81:22] browser. And I would write it in every
[81:24] language I could lay my hands on. I had
[81:26] two dozen or more of them and I'd show
[81:29] them in class. And the question is which
[81:30] ones ran faster and which ones were in
[81:32] some sense small or easy to understand
[81:34] or whatever. And lock was pretty fast
[81:37] and it was the smallest always. It was
[81:39] about 15 lines of code to do this job.
[81:42] And C was always the fastest but it was
[81:45] harder because you had to worry about
[81:46] memory management a bit and it was
[81:48] clunky to do strings. Uh, and the other
[81:51] scripting languages like Pearl and
[81:53] Python and PHP and Yian, they were
[81:56] variously sort of okay. Pearl was always
[81:59] the faster one. Um, and some of the high
[82:02] powered languages that were supposed to
[82:03] be better were actually slower. Java was
[82:05] slower than the scripting languages.
[82:07] [snorts] Kind of weird. C++ wasn't as
[82:10] fast as I thought it would be. Um, and
[82:12] at the far end of it was Haskell. I and
[82:16] it took me weeks to write the Haskell
[82:18] program whereas Lua a language I had
[82:20] never touched took me about half an hour
[82:23] you know look at the manual oh I see
[82:25] done
[82:27] whereas Haskell took forever and then I
[82:29] showed it to some Haskell expert he said
[82:30] oh but you have to import this character
[82:32] library that does this and you're and
[82:34] then it ran faster
[82:36] >> what made Haskell take so long
[82:38] >> it's a different way of thinking and I
[82:41] just didn't gro it I really didn't and
[82:44] and I think part of it was the the
[82:47] problem is you're taking input in one
[82:50] form and async not asynchronously but
[82:53] not at the same cycle. You're trying to
[82:55] produce output. So your lines are
[82:56] varying lengths and you want to produce
[82:58] lines at the same length and that
[82:59] mismatch of input and output kind of
[83:02] frequency didn't fit naturally with
[83:06] Haskell as I understood it. Now this is
[83:09] not a knock on Haskell. I mean there are
[83:10] people who love it but I'm not one of
[83:12] them.
[83:14] I saw somewhere on the internet that uh
[83:17] somewhat recently in the vast the last
[83:20] few years you added uh Unicode to O the
[83:24] the repo of O that you're kind of
[83:27] contributing to and it made me think
[83:29] what motivates you to continue to write
[83:32] code.
[83:33] >> Well, it's fun. It's this intellectual
[83:35] challenge that we talked about and I
[83:37] think part of it was that for O in
[83:40] particular I wanted to actually be able
[83:42] to process Unicode because an awful lot
[83:44] of text in the world is in Unicode at
[83:46] this point where by unic code I mean
[83:48] UTF8. So I would um I wanted O to work
[83:53] properly on that kind of stuff and it
[83:55] didn't. So that was part of the change.
[83:58] The other thing I did at the same time
[83:59] was to make it work with CSV files
[84:01] because I had data that was in CSV files
[84:04] and it lock was very clunky for
[84:07] processing that and so added a mechanism
[84:11] so you could say hey do CSV properly and
[84:14] the input mechanism I think both of
[84:16] those were triggered probably by working
[84:18] on a second edition of the O book and
[84:21] that was done in you know just a couple
[84:23] of years ago and it this day and age it
[84:25] would be really embarrassing if you
[84:26] couldn't handle unic
[84:28] For young people, a lot of times they're
[84:31] they're trying to discover,
[84:34] I guess, their passion or the the thing
[84:36] they want to work on. It sounds like you
[84:38] found it pretty quickly in programming
[84:40] and you're naturally enjoying just the
[84:43] act of it. If you had a student that
[84:45] comes to you or a young person and they
[84:47] ask you, "How do I find that thing I
[84:50] should be working on that I should be
[84:51] passionate about?" What would you say?
[84:54] >> It's a good question. I think probably
[84:56] what you tell them is to go do as many
[84:58] different things as you can in the hope
[85:00] that something will resonate. I mean,
[85:01] how do you find the perfect partner for
[85:03] your life or whatever? You don't sit in
[85:05] your room and think about it. You go to
[85:07] parties or whatever or maybe you use
[85:09] some app like Tinder or what I don't
[85:12] know. Uh
[85:14] but but you do things that get you out
[85:17] in a place where you might discover the
[85:19] sort of thing that you're hoping to
[85:20] find. It's an imperfect process
[85:22] obviously. Uh but I think if you don't
[85:25] do things, if you don't try different
[85:27] things, then you may not stumble into
[85:30] it. Um long time ago, I think it was
[85:34] Dick Hamming said to me that, you know,
[85:37] it was Nancy Reagan who said just say
[85:39] no. This was the don't do drugs kind of
[85:42] thing. And Hamming said just say yes.
[85:46] not to drugs presumably
[85:48] but but the idea that if somebody comes
[85:51] along with something and you think I
[85:52] don't know let me try it and applied
[85:55] with some common sense that seems like a
[85:58] reasonable way to handle a lot of
[86:00] different things it's hard to know and
[86:02] what works for one person isn't
[86:04] necessarily going to work at all for
[86:05] anybody else and so you know giving
[86:08] people career advice or life advice you
[86:12] want to be careful if you get it from me
[86:15] >> and And yeah, last question for you is
[86:18] um you know with all the experience that
[86:20] you have now and going through your
[86:22] career and everything we discussed, if
[86:24] you could go back in time and give
[86:26] yourself advice knowing everything you
[86:29] know now,
[86:30] >> what would you say?
[86:31] >> I think if I look at it, a lot of what I
[86:35] have done, you've seen a Golton board.
[86:37] It's this thing where you drop a marble,
[86:38] there's there's an array of nails and
[86:41] you drop a marble in at the top and it
[86:43] comes out somewhere at the bottom. And
[86:44] if you repeat it enough, you get a
[86:46] normal distribution of distribution of
[86:48] marbles across depending on which way it
[86:50] bounds. And so I'm like a a ball dropped
[86:53] into a golen board and you know and I
[86:57] come out somewhere at the bottom. But
[86:58] the decisions which nail when I hit a
[87:00] nail, which way do I go? I have no idea.
[87:03] And a lot of it is serendipity. However,
[87:06] one one I think genuinely useful
[87:08] observation uh a lot of this stuff comes
[87:10] from talking with Dick Hamming. Um but
[87:12] but it was pester who said chance favors
[87:15] the prepared mind. So the more things
[87:17] you have thought about, you've wondered
[87:19] about, done a bit with, met people on
[87:21] whatever, the more likely is some one of
[87:24] those will actually lead you in the
[87:26] right direction
[87:27] >> on that board. You're saying prepared
[87:30] mind kind of bias those outcomes a
[87:32] little
[87:33] >> towards a potentially better outcome.
[87:35] Yeah, I think so.
[87:37] >> Well, yeah, that's all my questions.
[87:39] Thank you so much for your time. Really
[87:40] appreciate it.
[87:40] >> My pleasure. Hey, thank you for watching
[87:43] this podcast. If you liked it and you
[87:44] want to see the show grow, please
[87:46] support with a comment or a like. Also,
[87:49] if you have any recommendations for
[87:51] people you want me to bring on, please
[87:53] drop a comment. Guests like Barbara
[87:55] Liskoff, Mike Stonereaker, Mark Brooker,
[87:58] these were all people that I brought on
[88:00] because someone left a comment. On
[88:02] another note, aside from the podcast,
[88:04] I'm working on building the ergonomic
[88:06] keyboard that I wish existed. Here's a
[88:08] glance at the prototype. It's a split
[88:10] keyboard, so there's two sides. This
[88:13] isn't the case. But yeah, we launched on
[88:15] Kickstarter and we hit our goal within
[88:17] eight hours of launching. I really
[88:18] appreciate it if you were one of the
[88:20] people who grabbed one of the early
[88:21] units. Um, we're now working on the long
[88:24] journey of building the tooling now. And
[88:26] so, if you still want to pick one up,
[88:27] I've left the late pledges open on
[88:29] Kickstarter, so you can grab one there.
[88:32] I'll put a link in the description.
[88:34] Thank you again for watching the podcast
[88:36] and I'll see you in the next