About C
C is a small, fast, low-level language that sits underneath operating systems,
databases, embedded devices, and many of the tools developers use every day.
Learning it teaches you how computers actually work. This course starts with
Introduction to C (what it's used for, and how it compares to
other languages) and Installation & Setup (compilers, editors,
and running your first program).
Next comes Syntax & Basics: variables, types, and operators,
followed by Arrays & Strings and Control Flow &
Loops. From there, Functions & Scope covers writing
reusable code, prototypes, and recursion, while Pointers & Memory
Management covers the part of C that sets it apart: addresses, pointers,
and manual memory with malloc and free.
Structs, Unions & Enums covers building your own data types.
Files, I/O & Error Handling covers reading and writing files
and checking for failures, and Preprocessor, Headers & Build
Tools covers organizing larger programs and compiling them with make.
Finally, Debugging, Testing & Concurrency covers finding bugs
with gdb and valgrind, writing simple tests, and running code in parallel with
POSIX threads: the natural next step once single-threaded programs feel routine.
Content
11 modules
01
Introduction to C
What C is used for, why it still matters decades later, and how it compares to higher-level languages.
Use CasesCompiled LanguageC vs Other Languages
02
Installation & Setup
Installing a compiler, choosing an editor, and compiling and running your first program from the terminal.
GCC & ClangCompilingHello World
03
Syntax & Basics
Variables, core data types, operators, and input and output with printf and scanf.
VariablesData Typesprintf & scanf
04
Arrays & Strings
Storing collections of values in arrays and working with strings as null-terminated character arrays.
Arrays2D ArraysStrings
05
Control Flow & Loops
Directing a program's logic with conditionals, switch statements, and for, while, and do-while loops.
if/elseswitchfor & while
06
Functions & Scope
Writing reusable code with functions, parameters and return values, prototypes, scope, and recursion.
PrototypesScopeRecursion
07
Pointers & Memory Management
Memory addresses, pointers, pointer arithmetic, and managing heap memory with malloc and free.
Pointersmalloc & freePointer Arithmetic
08
Structs, Unions & Enums
Defining your own data types to group related data, with typedef to keep the code readable.
structunionenum & typedef
09
Files, I/O & Error Handling
Reading and writing files, checking return values, and handling failures with errno and exit codes.
fopen & fclosefgets & fprintferrno
10
Preprocessor, Headers & Build Tools
Splitting code across header and source files, using macros, and building projects with make.
#include & #defineHeader Filesmake
11
Debugging, Testing & Concurrency
Finding bugs with gdb and valgrind, writing simple tests, and running code in parallel with POSIX threads.
gdbvalgrindpthreads
What You Can Do After This Course
By the end of the curriculum you'll have worked through 5 hands-on projects and
covered the core of what a developer role expects from someone who "knows C."
Concretely, you'll be able to:
Write clean, idiomatic C: comfortable with syntax, types, and the conventions that keep C code readable.
Work with arrays and strings: handle collections of data and character arrays without off-by-one surprises.
Understand memory: use pointers confidently and manage heap memory with malloc and free.
Design with structs: group related data into your own types and pass them around cleanly.
Handle files and failures: read and write data safely and check every call that can go wrong.
Structure larger programs: split code into headers and source files and build it with make.
Debug and scale your code: track down bugs with gdb and valgrind, and run work in parallel with threads.