“C is quirky, flawed, and an enormous success.”
The Story
In the early 1970s, Dennis Ritchie created a programming language at Bell Labs that gave programmers something unprecedented: direct, unfettered access to memory, wrapped in a syntax clean enough to write an entire operating system in. That language was C. That operating system was Unix, co-created with Ken Thompson.
C was not the first programming language. It wasn't the most elegant, the most safe, or the most theoretically sound. What it was, was useful. It was close enough to the machine to write operating systems, device drivers, and embedded firmware, but abstract enough that a programmer could reason about data structures and control flow without drowning in assembly. It compiled to fast, small binaries. It ran on everything.
Ritchie and Thompson rewrote Unix in C in 1973 — making it the first operating system written in a high-level language. This single decision meant Unix could be ported to new hardware by recompiling rather than rewriting. It was a portability revolution. Unix spread through universities, through Bell Labs licensees, and eventually into the lineage of every major operating system: Linux, macOS, iOS, Android, and the BSDs all descend from Unix concepts, and most are written in C or its direct descendants.
Ritchie died on October 12, 2011 — the same week as Steve Jobs. The contrast in public attention was stark. Jobs built the products that people touched. Ritchie built the substrate those products ran on. As one commenter wrote at the time: "Dennis Ritchie's work made everything Steve Jobs did possible."
Why They're in the Hall
Ritchie is a Pioneer and Builder whose design decisions are, quite literally, the source material for entire domains within TechnicalDepth.
C gave programmers direct memory access. Pointers. Manual allocation and deallocation. No bounds checking. No garbage collection. This was a deliberate trade-off: maximum performance and control, at the cost of safety. The programmer was trusted to manage memory correctly.
That trust is the origin of buffer overflows, use-after-free vulnerabilities, null pointer dereferences, and every memory safety flaw documented in the exhibits. These aren't bugs in Ritchie's design. They're consequences of a trade-off he made explicitly, for reasons that were sound in 1972 and remain sound in contexts where performance and hardware control matter more than safety guarantees.
The entire memory domain in TechnicalDepth traces to this decision. When Rust's borrow checker prevents a use-after-free at compile time, it's solving a problem that C chose not to solve. When a buffer overflow in a C program leads to a remote code execution vulnerability, the root cause isn't bad code — it's the contract C offers: "I will let you do anything to memory. It is your responsibility to do it correctly."
Ritchie knew. "C is quirky, flawed, and an enormous success." He didn't claim it was perfect. He claimed it was useful. Fifty years later, the evidence is overwhelming on both counts.