Course Plan

1Aim

C is used in operating systems, embedded software, compilers, databases, and every performance-sensitive layer beneath higher-level languages. It gives direct control over memory representation and execution, and it gives no protection against getting that control wrong.

The aim of this course is therefore not only to teach the language — that is the first fourteen weeks — but the discipline that makes writing C in production tractable: warnings treated as defects, sanitizers run by default, every return value checked, ownership stated in every interface, and the difference between what happens to work and what is actually guaranteed.

Each topic assumes only what earlier topics have established. Nothing is used before it is explained, and the chain of dependencies is deliberate: pointers arrive before strings, memory layout before recursion, structures before the standard library that uses them.

2Prerequisites

No prior programming experience is assumed. What is assumed:

• Comfort creating, saving, and organizing files, and basic terminal navigation.
• Arithmetic, and the ability to break a task into ordered steps.
• A computer running Linux, macOS, or Windows with WSL.

Two preparatory documents are available: prerequisites for preparation and key figures who shaped the field.

3Learning outcomes

4Tooling

Everything used in the course is free and cross-platform. Nothing requires physical hardware.

A single command line is used throughout and introduced in week 2:

gcc -std=c17 -Wall -Wextra -g -fsanitize=address,undefined -o prog prog.c

5How each week is structured

Every week's notes follow the same shape, so the material can be navigated without re-reading:

1. What you can do by the end — five concrete capabilities.
2. The concepts — several numbered sections, with diagrams where a picture carries the idea.
3. A worked example — a complete, compilable program with the commands to build and run it, and experiments that break it deliberately to show the failure mode.
4. Common mistakes — a table of what goes wrong, what the symptom looks like, and the fix.
5. Check yourself — five questions with answers hidden until you have tried them.
6. Where this leads — the connection to the following week.

The worked examples are the spine of the course. They are not exercises to be submitted; they are the artifact the notes build, and they are meant to be typed, compiled, and broken.

6The chain of examples

The examples are deliberately connected, so that each week extends something already understood rather than starting over:

week 11  a swap function that cannot work
week 13  the same function, fixed with pointers

week 19  a growable array on the heap
week 20  the same array, seeded with five memory defects
week 28  the same array as a module with a hidden implementation
week 29  the same module as a static and a shared library
week 30  the same container, made generic over any type
week 45  the same library, versioned and installable
week 46  the same library, called from Python, Rust and C++

week 23  a validating input parser
week 48  the same parser, attacked by a fuzzer

week 40  a TCP server, one forked process per connection
week 47  the same server, rewritten as a single-threaded event loop

week 49  a bare-metal image printing over a UART
week 50  the same UART, as a driver written against the register map
week 51  the same driver, interrupt-driven
week 55  the same driver, behind a HAL and unit-tested on the host

7Outline

Basic — the language core

Intermediate — memory, data, and structure

Advanced — tooling, systems, and scale

Professional — practice, distribution, and embedded

8Scope

Two boundaries are worth stating explicitly.

The course targets C17 by default, with C23 features identified where they differ. C89 and C99 are covered historically in week 2 because a great deal of existing code is written in them.

The hosted material assumes a POSIX environment — Linux, macOS, or WSL. Weeks 39, 40, 41 and 47 use POSIX interfaces that are not part of standard C; this is stated wherever it applies. Weeks 49 to 55 are freestanding and assume no operating system at all.

Not covered: C++ (a different language with different idioms), graphical interfaces, and language-specific build ecosystems beyond Make and CMake.

9References

Week 24 covers how to read a manual page and the text of the standard, which is the skill these references exist to support.