History, Standards, and the Compilation Model

1Where C came from

In 1969 the Bell Labs researchers Ken Thompson and Dennis Ritchie were building an operating system on a spare minicomputer. That system became Unix, and it was written, as all operating systems then were, in assembly language. Assembly is fast and precise, but it is tied to one processor: rewriting Unix for a different machine would have meant rewriting it entirely.

Thompson had already written a small language called B, itself a stripped-down version of BCPL, which came from Cambridge. B had one significant limitation: every value was a single machine word. It had no notion of a byte, a character, or a floating-point number. When the lab acquired a PDP-11 — a machine with byte addressing — B no longer fit the hardware.

Ritchie's response, between 1971 and 1973, was to add a type system to B. Values now had sizes: char, int, float, double. Structures arrived. The result was called C, and in 1973 Unix was rewritten in it. That was the decisive moment: an operating system in a portable language could be moved to a new machine by writing a new compiler rather than a new operating system.

2From a book to a standard

For its first decade, C had no formal definition. What it had instead was a book: The C Programming Language by Brian Kernighan and Dennis Ritchie, published in 1978. Programmers call that dialect K&R C. The book described the language accurately, but a book is not a specification: where it was silent or ambiguous, compiler vendors each decided for themselves, and C began to fragment.

ANSI convened a committee in 1983 to settle the question. The result, published in 1989, is ANSI C, adopted internationally the following year as ISO C. Everyone calls it C89 or C90; they are the same language. This standard introduced the function prototype — declaring a function's parameter types so the compiler can check calls against them — which is the single largest safety improvement in C's history.

Since then the language has been revised roughly once a decade by working group WG14. Revisions are conservative: C is a language where a twenty-year-old source file is expected to still compile.

What each revision added

A practical consequence: most of the "modern C" conveniences you will read about online — declaring a loop variable inside the for, using // for a comment — are C99 features. They are twenty-five years old and universally available, but they are not in C89, and some embedded toolchains still default to C89.

3The four translation phases

When you run gcc -o hello hello.c, GCC is acting as a driver: it runs four separate programs in sequence and quietly deletes the intermediate files. Here is what each one does, and how to stop after it.

Phase 1 — the preprocessor

The preprocessor is a text manipulator. It knows nothing about C. It obeys the lines beginning with #: it pastes in the contents of included files, substitutes macros, and strips comments. Its output is still C source — just much longer.

gcc -E hello.c -o hello.i
wc -l hello.i

Expect several hundred to a few thousand lines from a program you wrote five of. Everything after the last # directive is your code; everything before it came from stdio.h and the headers it includes in turn. Scroll to the bottom and you will find your main unchanged.

Phase 2 — the compiler proper

This is the stage people mean by "compiling": preprocessed C in, assembly language out. All the type checking, all the optimization, and all the interesting diagnostics happen here.

gcc -S hello.c -o hello.s
cat hello.s

You are not expected to read assembly yet. Look at it anyway. Find the string Hello, world sitting in a data section, and find the call instruction that invokes printf. Recognizing that your program became this is worth more than understanding every line. Week 34 comes back and reads it properly.

Phase 3 — the assembler

The assembler turns assembly text into a binary object file containing real machine instructions.

gcc -c hello.c -o hello.o
file hello.o
nm hello.o

nm lists the symbols in the object file. You will see T main — a symbol this file defines in the text section — and U printf, a symbol this file uses but does not define. That single letter U is the reason the next phase exists.

Phase 4 — the linker

The linker collects object files and libraries, resolves every undefined symbol against a definition somewhere, and writes one executable.

gcc hello.o -o hello
./hello

This is where printf gets connected to the real implementation inside the C standard library. It is also where the undefined reference error from week 1 came from: the linker searched everywhere it was told to look and found no definition.

4Worked example: the same file, two standards

Save this as era.c. It deliberately uses features from different decades.

#include <stdio.h>

int main(void)
{
    /* A C89-era comment. */
    int total = 0;

    for (int i = 0; i < 5; i++) {   /* declaration inside for: C99 */
        total += i;
    }

    printf("total = %d\n", total);
    return 0;
}

Compile it as C89:

gcc -std=c89 -Wall -Wextra -o era era.c

era.c: In function 'main':
era.c:8:5: error: 'for' loop initial declarations are only allowed in C99 or C11 mode
    8 |     for (int i = 0; i < 5; i++) {
      |     ^~~
era.c:8:5: note: use option '-std=c99', '-std=c11' or '-std=gnu99' to compile your code

Now as C23:

gcc -std=c23 -Wall -Wextra -o era era.c
./era

total = 10

The file did not change. The language changed. This is worth sitting with: "valid C" is not a single fixed thing, and the question "does this compile?" is incomplete until you say which standard you meant.

Now walk it through the phases

gcc -std=c23 -E era.c -o era.i     && wc -l era.i
gcc -std=c23 -S era.c -o era.s     && grep -c . era.s
gcc -std=c23 -c era.c -o era.o     && nm era.o
gcc era.o -o era                   && ./era

Two things to notice. First, the comment you wrote is gone by the time you look at era.i — the preprocessor removed it, which is why comments cost nothing at run time. Second, the loop may have vanished from era.s entirely if you add -O2: the compiler can compute 0+1+2+3+4 at compile time and emit the constant 10. Try it.

gcc -std=c23 -O2 -S era.c -o era-opt.s
grep -n '10\|\$10' era-opt.s

5Choosing your flags

Settle on a command line now and use it for the rest of the course:

gcc -std=c17 -Wall -Wextra -g -o prog prog.c

6Common mistakes

8Where this leads

You now know what the build does and which language you are writing. Week 3 turns to the program itself: the anatomy of main, what its return value is for, how to write code that another person can read, and how to put your work under version control so that week 43's lesson on navigating someone else's codebase starts from a habit you already have.