Beej's Guide to C — Learning Roadmap

0 / 0 done
0
Chapters Done
0
Projects Done
0%
Complete
~16
Weeks Left
Phase 1 — Core C · Weeks 1–8
0%
Weeks 1–2
Syntax Basics
▼
Ch 2 — Hello, World!
2 sessions · First program, compilation, how C differs from Python
Ch 3 — Variables and Statements big chapter
3 sessions · Types, operators, control flow
Ch 4 — Functions
1 session · No default args, no keyword args — simpler than Python
Mini-project: CLI Calculator
Write a simple calculator from scratch — stdin input, basic arithmetic ops
Weeks 3–4
Pointers — The Hard Part
▼
Ch 5 — Pointers—Cower In Fear! most important
2 sessions · Python refs are pointers with a wrapper — see them raw
Ch 6 — Arrays
2 sessions · Fixed-size, stack-allocated contiguous memory
Ch 7 — Strings
1 session · Not objects — just char arrays ending in \0
Warning: Pointers will feel weird. Don't move on until they click. Budget extra time here.
Weeks 5–6
Memory & I/O
▼
Ch 8 — Structs
1 session · C's version of a class (data only, no methods)
Ch 9 — File Input/Output
2 sessions · printf, scanf, file I/O
Ch 10 — typedef: Making New Types
1 session · Type aliases — makes struct usage cleaner
Ch 11 — Pointers II: Arithmetic
2 sessions · Pointer arithmetic, arrays as pointers
Ch 12 — Manual Memory Allocation critical
2 sessions · What Python's garbage collector hides from you
Weeks 7–8
Consolidation
▼
Ch 13 — Scope
1 session · Stack vs heap becomes concrete here
Remaining sessions: Re-implement pointer and malloc examples from memory. Don't look at the book.
Mini-project: Dynamic Array or Linked List
Implement using malloc/free from scratch — cements everything in Phase 1
Phase 2 — Depth · Weeks 9–14 · CS:APP prep starts here
0%
Weeks 9–10
Types + Build System
▼
Ch 14 — Types II: Way More Types! CS:APP
2 sessions · Integer sizes, signedness, overflow — CS:APP hammers these
Ch 15 — Types III: Conversions CS:APP
2 sessions · Casting, implicit conversions
Ch 16 — Types IV: Qualifiers and Specifiers CS:APP
2 sessions · const, volatile, static, extern
Ch 17 — Multifile Projects CS:APP
1 session · How compilation + linking actually works
Weeks 11–12
Preprocessor + Advanced Structs
▼
Ch 19 — The C Preprocessor longest chapter
3 sessions · #define, macros, #include, conditional compilation
Ch 20 — structs II: More Fun with structs
2 sessions · Nested structs, struct pointers, flexible arrays
Ch 21 — Characters and Strings II
1 session · String manipulation functions from <string.h>
Ch 22 — Enumerated Types: enum
1 session · Named constants, cleaner than #define magic numbers
Weeks 13–14
CS:APP-Critical Topics
▼
Ch 23 — Pointers III: Pointers to Pointers and More CS:APP
2 sessions · char **argv, double indirection
Ch 24 — Bitwise Operations CS:APP
1 session · Short chapter — CS:APP uses these constantly
Ch 37 — Fixed Width Integer Types CS:APP
1 session · int32_t, uint64_t — exact sizes matter in systems code
Mini-project: Bitmask / Flags System
Implement a simple permission or flag system using bitwise ops
Phase 3 — Selective Advanced · Weeks 15–16 · pick by interest
0%
Weeks 15–16
Advanced Topics
▼
Ch 28 — Exiting a Program
1 session · atexit(), exit codes, process cleanup
Ch 29 — Signal Handling
1 session · SIGINT, SIGSEGV — systems programming flavour
Ch 31 — goto
1 session · Controversial but worth understanding why it exists
Ch 39 — Multithreading
3 sessions · Relevant for desktop app work (Qt also has threading)
Skip entirely — reference only if needed
Ch 18 · The Outside Environment Ch 25 · Variadic Functions Ch 26 · Locale and Internationalization Ch 27 · Unicode, Wide Characters Ch 30 · Variable-Length Arrays Ch 36 · Complex Numbers Ch 40 · Atomics

After BGC — What's Next

BGC → CS:APP → C++ (Qt for cross-platform desktop). Solid C makes CS:APP much easier to follow. CS:APP makes the C++ memory model intuitive. That's a strong 12–18 month arc from Python to systems-capable.

Computer Systems: A Programmer's Perspective (CS:APP)