C Programming Language History

What is or is
not implemented in the kernel represents both a great responsibility and a great
power. It is a soap-box platform on 'the way things should be done.' Even so,
if 'the way' is too radical, no one will follow it. Every important decision was
weighed carefully. Throughout, simplicity has been substituted for efficiency.
Complex algorithms are used only if their complexity can be localized.

The development of Unix in the C language made it uniquely
portable and improvable.

The first version of Unix was written in the
low-level PDP-7 assembler language. Soon after, a language called TMG was
created for the PDP-7 by R. M. McClure. Using TMG to develop a FORTRAN
compiler, Ken
Thompson instead ended up developing a compiler for a new high-level
language he called B, based on the earlier BCPL language developed by Martin
Richard. Where it might take several pages of detailed PDP-7 assembly code
to accomplish a given task, the same functionality could typically be expressed
in a higher level language like B in just a few lines. B was thereafter used
for further development of the Unix system, which made the work much faster
and more
convenient.

When
the PDP-11 computer arrived at Bell Labs, Dennis
Ritchie built on B to create a new language called C which inherited Thompson's
taste for concise syntax, and had a powerful mix of high-level functionality
and the detailed features required to program an operating system. Most of the
components of Unix were eventually rewritten in C, culminating with the kernel
itself in 1973. Because of its convenience and power, C went on to become the
most popular
programming language in the world over the next quarter century.

This
development of Unix in C had two important consequences:

Portability.
It made it much easier to port Unix to newly developed computers, because
it eliminated the need to translate the entire operating system to the
new assemble language
by hand:

First, write a C-to-assembly language compiler for
the new machine.

Then use the new compiler to automatically translate the Unix C language
source
code into the new machine's assembly language.

Finally, write only a small amount of new code where absolutely required
by hardware differences
with the new machine.

Improvability.
It made Unix easy to customize and improve by any programmer that could
learn the
high-level C programming language. Many did learn C, and went on to experiment
with modifications to the operating system, producing many useful new extensions
and enhancements.