On November 3, 1971, the first edition of the Unix Programmer’s Manual arrived on desks at Bell Labs in Murray Hill, New Jersey. It described an operating system running on a PDP-11/20 minicomputer — a machine with 24 KB of memory. The manual listed Dennis Ritchie and Ken Thompson as authors. At the time, fewer than a dozen people used Unix. Within two decades, their work would underpin virtually every computing system on Earth, from supercomputers to smartphones.
The story of Unix and C is not just about two programs. It is the story of a design philosophy that reshaped how humans think about software. Thompson built the operating system. Ritchie built the language to make it portable. Together, they created the foundation on which modern computing still stands.
Early Life and Path to Technology
Kenneth Lane Thompson was born on February 4, 1943, in New Orleans, Louisiana. He grew up fascinated by electronics, tinkering with circuits and ham radios as a teenager. He studied electrical engineering and computer science at the University of California, Berkeley, earning his master’s degree in 1966. At Berkeley, he worked on the Multics project — a massive, ambitious time-sharing operating system developed jointly by MIT, General Electric, and Bell Labs.
Dennis MacAlistair Ritchie was born on September 9, 1941, in Bronxville, New York. His father, Alistair Ritchie, was a physicist at Bell Labs who co-authored a foundational text on switching circuits. Dennis studied physics and applied mathematics at Harvard, completing his PhD thesis on subrecursive hierarchies of functions — a topic in theoretical computer science. He joined Bell Labs in 1967, following his father into the same research campus.
Both men arrived at Bell Labs during its golden era. The lab had already produced the transistor, information theory, and the laser. It was a place where researchers had extraordinary freedom to pursue problems that interested them. That freedom would prove critical to what came next.
The Breakthrough: Creating Unix
The Technical Innovation
Bell Labs had been a partner in the Multics project since 1964. Multics aimed to create a robust, multi-user operating system. It worked — eventually — but the project was expensive, slow, and increasingly complex. In March 1969, Bell Labs withdrew from Multics. Thompson, who had been working on the project, suddenly had no operating system to hack on.
Thompson had been writing a space travel game — a simulation of the solar system where you could fly between planets. He needed an operating system to run it. Using a PDP-7 minicomputer that was gathering dust in a corner of the lab, he wrote one. In roughly three weeks during the summer of 1969, Thompson created the first version of what would become Unix. He wrote a file system, a process mechanism, a command interpreter (shell), and a few utilities — all in PDP-7 assembly language.
Ritchie joined the effort almost immediately. The name “Unix” came from Brian Kernighan, another Bell Labs researcher. It was a pun on Multics: where Multics was “multiplexed” and complex, Unix was “uniplexed” and simple. The joke captured the design philosophy perfectly.
Early Unix introduced several concepts that remain fundamental to computing. The hierarchical file system — directories containing files and other directories — was not new, but Unix’s implementation was clean and consistent. Everything was a file: devices, processes, even the system’s own internal data structures could be accessed through the file system. This uniformity made the system remarkably simple to learn and program.
The pipe mechanism, suggested by Doug McIlroy in 1973, became Unix’s most distinctive feature. Pipes let you connect the output of one program directly to the input of another, building complex data processing from simple components:
# Unix philosophy in action: pipes compose simple tools
cat access.log | grep "404" | awk '{print $7}' | sort | uniq -c | sort -rn | head -20
# Find the 20 most common URLs returning 404 errors
# Six programs. One line. Each does one thing.
# Another example: find large files modified in the last 7 days
find /var/log -type f -mtime -7 -exec ls -la {} \; | awk '{print $5, $9}' | sort -rn | head -10
# Combines find, ls, awk, sort, and head — no single tool could do this aloneIn 1971, Unix was ported to the PDP-11, a more powerful machine. By 1973, it had been rewritten in C — making it the first operating system written in a high-level language. This was the decision that changed everything. Assembly-language programs are locked to one type of hardware. A C-based operating system could be recompiled for any machine with a C compiler. Unix became portable.
Why It Mattered
Before Unix, every computer manufacturer had its own proprietary operating system. IBM mainframes ran OS/360. DEC minicomputers ran VMS. Each system was incompatible with the others. Programmers had to relearn everything when they switched hardware.
Unix broke this pattern. Because it was written in C, it could run on different hardware with relatively minor modifications. AT&T (Bell Labs’ parent company) licensed Unix to universities for a nominal fee, and the system spread rapidly through academia during the 1970s. The University of California, Berkeley, developed its own version — BSD (Berkeley Software Distribution) — which added TCP/IP networking, virtual memory, and the vi editor.
By the early 1980s, Unix variants ran on everything from personal workstations to supercomputers. The system had created something new in computing: a common platform. Programmers trained on Unix at university could use Unix at work. Software written for one Unix system could be ported to another. This portability was revolutionary. It created the conditions for the open-source movement, the internet, and modern web development.
Beyond Unix: The C Programming Language
While Unix was Thompson’s initial creation, the C programming language was primarily Ritchie’s work. Thompson had created an earlier language called B (derived from BCPL) for system programming on the PDP-7. But B was typeless — it treated all data as machine words. That worked on the PDP-7 but was inadequate for the PDP-11, which had byte-addressable memory and hardware support for floating-point arithmetic.
Between 1971 and 1973, Ritchie evolved B into C. He added a type system (int, char, float, pointers), structures for grouping related data, and a preprocessor for conditional compilation. The result was a language that sat precisely between assembly language and higher-level languages like FORTRAN or COBOL. C gave programmers direct access to memory through pointers, bit manipulation, and hardware registers — while also providing functions, local variables, and structured control flow.
/* Ritchie's classic "Hello, world" from K&R C (1978) */
#include <stdio.h>
main()
{
printf("hello, world");
}
/* This six-line program became the universal first example
in programming education. The K&R book sold millions of
copies and defined how a generation learned to code. */In 1978, Ritchie and Brian Kernighan published The C Programming Language, commonly known as “K&R.” The book was 228 pages — slim by any standard — and it served as both tutorial and reference. Its clear, concise style set the tone for technical writing in computer science. Before K&R, programming books were typically dense academic texts. After K&R, they were practical, example-driven, and readable.
/* C's power: direct memory manipulation */
/* A simple string copy — shows why C is both powerful and dangerous */
void strcpy(char *dest, const char *src)
{
while (*dest++ = *src++)
;
}
/* This single line of code copies an entire string.
The pointer arithmetic is elegant but demands discipline.
Buffer overflows from careless use of functions like this
have caused billions of dollars in security vulnerabilities. */C’s influence on subsequent programming languages is difficult to overstate. C++ (1979), Objective-C (1984), Java (1995), C# (2000), JavaScript (1995), PHP (1995), Go (2009), Rust (2010), and Swift (2014) all inherit syntax, semantics, or design principles from C. When a programmer writes curly braces to delimit blocks, uses semicolons to end statements, or declares variables with type annotations — those conventions trace back to Ritchie’s design decisions in the early 1970s.
Other Contributions: Plan 9, UTF-8, and Go
Ritchie and Thompson did not stop after Unix and C. In the mid-1980s, they began work on Plan 9 from Bell Labs — a distributed operating system designed as the successor to Unix. Plan 9 extended the “everything is a file” concept into a networked environment: remote resources appeared as local files through a protocol called 9P. While Plan 9 never achieved widespread adoption, its ideas influenced later systems. The Linux /proc filesystem, FUSE (Filesystem in Userspace), and aspects of Docker’s union file system all owe conceptual debts to Plan 9.
Thompson, together with Rob Pike, invented UTF-8 encoding in September 1992. UTF-8 solved a critical problem: how to encode the world’s writing systems in a format compatible with existing ASCII-based software. Their design was elegant — ASCII characters remained single bytes, while other characters used multi-byte sequences. UTF-8 is now the dominant text encoding on the web, used by over 98% of all web pages. Every time a browser renders Chinese, Arabic, emoji, or any non-Latin text, it uses Thompson and Pike’s encoding.
Philosophy and Engineering Approach
Key Principles
Thompson and Ritchie did not write manifestos. They wrote code and let it speak. But the Unix philosophy — articulated most clearly by Doug McIlroy, their colleague at Bell Labs — captured their design values in a set of principles that remain influential:
- Do one thing well. Each program should perform a single function. Don’t build a monolith that does everything poorly; build a focused tool that does one thing excellently.
- Programs should work together. Design programs to connect with other programs. Output should be clean text that another program can parse. This is the principle behind Unix pipes — and behind modern APIs and microservices.
- Text is the universal interface. Data should flow as text streams. Text is readable by humans and parseable by programs. Binary formats lock data inside specific tools.
- Build prototypes early. Get something working quickly. Ship the third version of the third system — don’t spend years designing the perfect system on paper.
- Prefer simplicity. When in doubt, leave it out. A simple system that works is better than a complex one that might.
These principles directly shaped how Linus Torvalds built Linux and Git. They influenced the design of the World Wide Web by Tim Berners-Lee. They echo in modern practices like containerization with Docker, where each container runs a single service. The twelve-factor app methodology, microservices architecture, and even the functional programming revival all owe a debt to the Unix philosophy.
Thompson and Ritchie also practiced extreme minimalism. Unix’s kernel was small enough to understand in its entirety. The C language specification fit in a thin book. They believed that a programmer should be able to hold the entire system in their head. This stands in stark contrast to modern frameworks and platforms that require weeks of study just to understand their configuration files.
Legacy and Modern Relevance
The list of systems derived from Unix reads like an inventory of modern computing:
- Linux — Linus Torvalds created it in 1991 as a Unix clone. As of 2025, Linux runs on 96.3% of the top one million web servers, all 500 of the world’s fastest supercomputers, and billions of Android devices.
- macOS — Apple’s operating system is built on Darwin, which derives from BSD Unix. Every Mac and MacBook runs Unix under the hood.
- iOS and Android — iOS inherits from macOS (and therefore Unix). Android runs on the Linux kernel. Every smartphone in the world runs a Unix derivative.
- BSD variants — FreeBSD powers Netflix’s content delivery (serving terabytes per second). OpenBSD is renowned for its security. NetBSD runs on virtually every hardware platform ever made.
- Cloud infrastructure — AWS, Google Cloud, and Azure run Linux servers. Docker containers are Linux processes. Kubernetes orchestrates Linux containers.
C remains the third most popular programming language in 2025 according to the TIOBE index, over fifty years after Ritchie created it. The Linux kernel, Git, PostgreSQL, Redis, Nginx, the Python interpreter, and the CPython runtime are all written in C. When web developers deploy applications to production servers, every layer of the stack — from the operating system to the web server to the database — likely runs C code that follows patterns Ritchie established.
Thompson, after decades at Bell Labs, joined Google in 2006. There, he co-created the Go programming language alongside Rob Pike and Robert Griesemer. Go embodies many Unix principles: simplicity, fast compilation, built-in concurrency, and a small standard library. It has become the language of choice for cloud infrastructure — Docker, Kubernetes, and Terraform are all written in Go.
Ritchie passed away on October 12, 2011, at his home in Berkeley Heights, New Jersey. He was 70 years old. His death came just one week after Steve Jobs’ death. Jobs received global media coverage and public mourning. Ritchie’s death was noted primarily within the technology community. The irony was not lost on programmers: the iPhone that millions used to read about Jobs’ death ran on an operating system (iOS, derived from Unix) written in a language (Objective-C, derived from C) that existed because of Ritchie’s work.
Key Facts
- Dennis Ritchie: Born September 9, 1941, Bronxville, New York. Died October 12, 2011.
- Ken Thompson: Born February 4, 1943, New Orleans, Louisiana.
- Known for: Unix operating system, C programming language, B language, UTF-8 encoding (Thompson), Go language (Thompson), Plan 9 from Bell Labs.
- Key work: Unix (1969), C language (1972), The C Programming Language book (1978), Plan 9 (1992), UTF-8 (1992), Go (2009).
- Awards: Turing Award (1983, shared), National Medal of Technology (1999), Japan Prize (2011, Ritchie & Thompson), IEEE Richard W. Hamming Medal (1990).
- Thompson today: Co-creator of Go at Google. Continues to work on systems programming and language design.
Frequently Asked Questions
Who are Dennis Ritchie and Ken Thompson?
Dennis Ritchie and Ken Thompson are computer scientists who worked at Bell Labs in the late 1960s and 1970s. Thompson created the Unix operating system, and Ritchie created the C programming language. Together, they built the technological foundation that underlies nearly all modern computing systems.
What did Ritchie and Thompson create?
Their two major creations are Unix (1969) and C (1972). Unix is the ancestor of Linux, macOS, iOS, and Android. C is the ancestor of C++, Java, JavaScript, C#, Go, Rust, Swift, and many other languages. They also co-authored the influential book The C Programming Language (1978) with Brian Kernighan. Thompson later co-invented UTF-8 text encoding and the Go programming language.
Why are Ritchie and Thompson important to computer science?
Nearly every device with a processor runs software that descends from their work. Unix’s design philosophy — small tools, text interfaces, composability — shaped version control systems like Git, modern web frameworks, containerization, and cloud computing. C provided the language in which operating systems, databases, and compilers are still written. They received the Turing Award in 1983 for these contributions.
What is Ken Thompson doing today?
Thompson has been at Google since 2006, where he co-created the Go programming language. Go is widely used for building cloud infrastructure, web services, and command-line tools. Docker, Kubernetes, and many other modern DevOps tools are written in Go.
