Dennis Ritchie (standing) and Ken Thompson at a PDP-11
in 1972. (Photo: Courtesy of Bell Labs)
The tributes to Dennis Ritchie won’t match the river of praise that spilled out
over the web after the death of Steve Jobs. But they should.
And then some.
“When Steve Jobs died last week, there was a huge outcry, and that was very
moving and justified. But Dennis had a bigger effect, and the public doesn’t
even know who he is,” says Rob Pike, the
programming legend
and
current Googler
who spent 20 years working across the hall from Ritchie at the famed
Bell Labs.
On Wednesday evening, with a
post
to Google+, Pike announced that Ritchie had died at his home in New Jersey
over the weekend after a long illness, and though the response from hardcore
techies was immense, the
collective
eulogy from the
web
at large doesn’t quite do justice to Ritchie’s sweeping influence on the
modern world. Dennis Ritchie is the father of the C programming language, and
with fellow Bell Labs researcher Ken Thompson, he used C to build UNIX, the
operating system that so much of the world is built on — including the Apple
empire overseen by Steve Jobs.
“Pretty much everything on the web uses those two things: C and UNIX,” Pike
tells Wired. “The browsers are written in C. The UNIX kernel — that pretty much
the entire Internet runs on — is written in C. Web servers are written in C, and
if they’re not, they’re written in Java or C++, which are C derivatives, or
Python or Ruby, which are implemented in C. And all of the network hardware
running these programs I can almost guarantee were written in C.
“It’s really hard to overstate how much of the modern information economy is
built on the work Dennis did.”
Even Windows was once written in C, he adds, and UNIX underpins both Mac OS
X, Apple’s desktop operating system, and iOS, which runs the iPhone and the
iPad. “Jobs was the king of the visible, and Ritchie is the king of what is
largely invisible,” says Martin Rinard, professor of electrical engineering and
computer science at MIT and a member of the Computer Science and Artificial
Intelligence Laboratory.
“Jobs’ genius is that he builds these products that people really like to use
because he has taste and can build things that people really find compelling.
Ritchie built things that technologists were able to use to build core
infrastructure that people don’t necessarily see much anymore, but they use
everyday.”
From B to C
Dennis Ritchie built C because he and Ken Thompson needed a better way to
build UNIX. The original UNIX kernel was written in assembly language, but they
soon decided they needed a “higher level” language, something that would give
them more control over all the data that spanned the OS. Around 1970, they tried
building a second version with Fortran, but this didn’t quite cut it, and
Ritchie proposed a new language based on a Thompson creation known as B.
Depending on which legend you believe, B was named either for Thompson’s wife
Bonnie or
BCPL, a language
developed at Cambridge in the mid-60s. Whatever the case, B begat C.
B was an interpreted language — meaning it was executed by an intermediate
piece of software running atop a CPU — but C was a compiled language. It was
translated into machine code, and then directly executed on the CPU. But in
those days, C was considered a high-level language. It would give Ritchie and
Thompson the flexibility they needed, but at the same time, it would be
fast.
That first version of the language wasn’t all that different from C as we
know it today — though it was a tad simpler. It offered full data structures and
“types” for defining variables, and this is what Richie and Thompson used to
build their new UNIX kernel. “They built C to write a program,” says Pike, who
would join Bell Labs 10 years later. “And the program they wanted to write was
the UNIX kernel.”
Ritchie’s running joke was that C had “the power of assembly language and the
convenience of … assembly language.” In other words, he acknowledged that C was
a less-than-gorgeous creation that still ran very close to the hardware. Today,
it’s considered a low-level language, not high. But Ritchie’s joke didn’t quite
do justice to the new language. In offering true data structures, it operated at
a level that was just high enough.
“When you’re writing a large program — and that’s what UNIX was — you have to
manage the interactions between all sorts of different components: all the
users, the file system, the disks, the program execution, and in order to manage
that effectively, you need to have a good representation of the information
you’re working with. That’s what we call data structures,” Pike says.
“To write a kernel without a data structure and have it be as consist and
graceful as UNIX would have been a much, much harder challenge. They needed a
way to group all that data together, and they didn’t have that with
Fortran.”
At the time, it was an unusual way to write an operating system, and this is
what allowed Ritchie and Thompson to eventually imagine porting the OS to other
platforms, which they did in the late 70s. “That opened the floodgates for UNIX
running everywhere,” Pike says. “It was all made possible by C.”
Apple, Microsoft, and Beyond
At the same time, C forged its own way in the world, moving from Bell Labs to
the world’s universities and to Microsoft, the breakout software company of the
1980s. “The development of the C programming language was a huge step forward
and was the right middle ground … C struck exactly the right balance, to let you
write at a high level and be much more productive, but when you needed to, you
could control exactly what happened,” says Bill Dally, chief scientist of NVIDIA
and Bell Professor of Engineering at Stanford. “[It] set the tone for the way
that programming was done for several decades.”
As Pike points out, the data structures that Richie built into C eventually
gave rise to the object-oriented paradigm used by modern languages such as C++
and Java.
The revolution began in 1973, when Ritchie published his research paper on
the language, and five years later, he and colleague Brian Kernighan released
the definitive C book:
The C Programming Language. Kernighan had
written the early tutorials for the language, and at some point, he “twisted
Dennis’ arm” into writing a book with him.
Pike read the book while still an undergraduate at the University of Toronto,
picking it up one afternoon while heading home for a sick day. “That reference
manual is a model of clarity and readability compared to latter manuals. It is
justifiably a classic,” he says. “I read it while sick in bed, and it made me
forget that I was sick.”
Like many university students, Pike had already started using the language.
It had spread across college campuses because Bell Labs started giving away the
UNIX source code. Among so many other things, the operating system gave rise to
the modern open source movement. Pike isn’t overstating it when says the
influence of Ritchie’s work can’t be overstated, and though Ritchie received the
Turing Award in 1983 and the National Medal of Technology in 1998, he still
hasn’t gotten his due.
As Kernighan and Pike describe him, Ritchie was an unusually private person.
“I worked across the hall from him for more than 20 years, and yet I feel like a
don’t knew him all that well,” Pike says. But this doesn’t quite explain his low
profile. Steve Jobs was a private person, but his insistence on privacy only
fueled the cult of personality that surrounded him.
Ritchie lived in a very different time and worked in a very different
environment than someone like Jobs. It only makes sense that he wouldn’t get his
due. But those who matter understand the mark he left. “There’s that line from
Newton about standing on the shoulders of giants,” says Kernighan. “We’re all
standing on Dennis’ shoulders.”
Additional reporting by Jon Stokes.
