The Story of C: From a Back Room at Bell Labs to Your Phone

It is 1969, in a back room at Bell Labs in New Jersey. A small team has got hold of a PDP-7, a minicomputer nobody else wanted. They are building an operating system on it. They call it Unix. It works.

It is also chained to that one machine. It is written in assembly language, and assembly differs on every processor. Move to a new computer and you start again from nothing.

Languages are shaped by the problem their creators were stuck on. That was the problem. C is the answer, and almost every odd corner of C makes sense once you know it.

The assembly problem

Assembly language is an almost word-for-word text version of the instructions a processor understands. It is fast and exact. It is also tied to one family of chips.

So an operating system written in assembly cannot move. Every new machine means rewriting tens of thousands of lines, by hand, correctly. Bell Labs wanted a language close enough to the hardware to write a kernel. It also had to be general enough to move Unix to a new machine.

No language at the time did both. The high-level languages of the day hid the machine. Assembly did not hide it, and did not travel.

From BCPL to B to C

The chain starts in Cambridge. Martin Richards wrote BCPL in 1967, by cutting down an earlier language called CPL. CPL had itself grown out of ALGOL 60. Ken Thompson then cut BCPL down further into a language he called B, around 1969.

B had one serious limitation. Every piece of data was a plain machine word. B could not say "this is one character, that is a whole number". It had no way to describe a record with three parts.

Dennis Ritchie fixed that at Bell Labs around 1972. He added a type system, which is a language knowing what kind of thing each piece of data is. He kept everything else small. The result was C, so named because it came after B. Programmers are not always poets.

1973: Unix is rewritten in C

This is the moment that mattered. In 1973 the Unix kernel itself was rewritten in C. An operating system is the software tied most tightly to the hardware. It was now written in a language that could move between machines.

That had not been done at this scale before, and it settled the argument. Within a decade, C was how systems got written. Every operating system you will use this year still carries that decision.

The standards, and what each one gave you

C was not frozen in 1972. It was standardised, and then revised roughly every decade. You will meet the results of every row below in this track.

The next four programs are the same idea written in four eras. All four still compile today. Read them as a timeline, not as code to memorise.

#include <stdio.h>

/* K&R style: the parameter types come after the name. */
int add(a, b)
int a;
int b;
{
    return a + b;
}

int main()
{
    printf("%d\n", add(2, 3));
    return 0;
}

5

#include <stdio.h>

/* C89: a prototype, and every variable declared at the top of the block. */
int add(int a, int b);

int main(void)
{
    int i;
    int total;

    total = 0;
    for (i = 1; i <= 5; i++) {
        total = total + i;
    }
    printf("%d\n", add(total, 0));
    return 0;
}

int add(int a, int b)
{
    return a + b;
}

15

#include <stdbool.h>
#include <stdio.h>

int main(void)
{
    // C99 added this comment style.
    long long big = 9000000000LL;
    bool ready = true;

    int total = 0;                  // declare where you need it
    for (int i = 1; i <= 5; i++) {  // and inside the for
        total += i;
    }

    printf("%d %lld %d\n", total, big, ready);
    return 0;
}

15 9000000000 1

#include <stdio.h>

/* C11 added a check the compiler runs, not the program. */
_Static_assert(sizeof(int) >= 4, "this code needs int to be at least 4 bytes");

int main(void)
{
    printf("int is %zu bytes here\n", sizeof(int));
    return 0;
}

int is 4 bytes here

C's children

C did not only survive. It set the shape that most popular languages still use.

Three of them are worth naming precisely, because "borrowed from C" is vague.

• C++ (1985) borrowed almost everything, on purpose. It started as "C with Classes" and kept C's types, operators, pointers and standard library. Most valid C is still valid C++, which is why this track leads straight into the C++ one.
• Java (1995) borrowed the syntax and threw away the pointers. Braces, semicolons, if, while, for, and the same operators all came across. Manual memory management did not.
• JavaScript (1995) borrowed only the look. The braces, the semicolons and the for loop are C's. Everything underneath, including its type rules, came from elsewhere. The name was a marketing decision, not a family tie to Java.

int add(a, b)
int a;
int b;
{ return a + b; }

def add(a, b):
    return a + b

func add(a int, b int) int {
    return a + b
}

int add(int a, int b) {
    return a + b;
}

function add(a, b) {
    return a + b;
}

int add(int a, int b)
{
    return a + b;
}

Next you will follow one small file from text to a running program. There are four separate stages, and nobody usually shows you any of them.