C Roadmap
Open a topic for notes and resources. Mark it done when you are ready to move on.
C
✓
Pointer Arithmetic
✓
Pointer to Pointer (Double Indirection)
✓
Foundations
✓
Function Pointers & Callbacks
✓
Restrict Keyword (C99)
✓
Core Concepts
✓
Void Pointers (Generic Pointers)
✓
Complex Pointer Declarations
✓
Dangling Pointers & Safe Patterns
✓
Static, Stack & Heap Allocation
✓
Intermediate Skills
✓
Malloc Internals (glibc)
✓
Calloc, Realloc & Aligned Allocation
✓
Advanced Topics
✓
Memory Pools & Custom Allocators
✓
Memory Corruption Detection
✓
Stack Allocation & VLA (C99)
✓
Memory-Mapped Files (mmap)
✓
Expert Level
✓
Reference Counting in C
✓
Token Pasting (##) & Stringification (#)
✓
Mastery
✓
Variadic Macros & __VA_ARGS__
✓
X-Macros & Code Generation
✓
Header Guards & #pragma once
✓
#line & #error Directives
✓
Ecosystem
✓
Conditional Compilation Patterns
✓
Macro Pitfalls: Multiple Evaluation
✓
Architecture
✓
Translation Phases
✓
Lexical Analysis & Tokens
✓
Parsing & AST Generation
✓
Code Generation & Optimization
✓
Optimization
✓
Linker Relocation & Symbol Resolution
✓
Inline Functions vs Macros
✓
Deployment
✓
Calling Convention (cdecl, stdcall)
✓
POSIX Threads (pthreads)
✓
Mutex & Condition Variables
✓
Thread-Local Storage
✓
Phase 11
✓
C11 Atomics & Memory Order
✓
Lock-Free Data Structures
✓
Phase 12
✓
Signal Handling & Async-Safety
✓
OpenMP Parallel Directives
✓
Compiler Optimization Flags (-O1, -O2, -O3)
✓
Profile-Guided Optimization
✓
Phase 13
✓
Loop Unrolling & Vectorization
✓
Cache-Friendly Data Layout
✓
Phase 14
✓
Branch Prediction & Likely/Unlikely
✓
Inline Assembly Intrinsics
✓
Link-Time Optimization (LTO)
✓
System V AMD64 ABI
✓
Phase 15
✓
Windows x64 Calling Convention
✓
Stack Frame Layout
✓
Phase 16
✓
Return Value Handling
✓
Structure Passing
✓
TLS & Thread-Local Storage ABI
✓
Name Mangling & C Linkage
✓
Phase 17
✓
Volatile & Memory-Mapped I/O
✓
Interrupt Service Routines
✓
Phase 18
✓
Bit Manipulation Techniques
✓
Fixed-Point Arithmetic
✓
Watchdog Timers
✓
Low-Power Modes
✓
Phase 19
✓
Bootloader Implementation
✓
Berkeley Sockets API
✓
Phase 20
✓
TCP Server Implementation
✓
Non-blocking I/O with epoll
✓
UDP Multicast
✓
DNS Resolution (getaddrinfo)
✓
Phase 21
✓
Raw Sockets & Packet Injection
✓
SSL/TLS with OpenSSL
✓
Phase 22
✓
Static vs Shared Libraries
✓
Library Search Paths
✓
Symbol Visibility & dllexport
✓
Linking Order & Undefined Symbols
✓
Phase 23
✓
Shared Library Versioning
✓
Weak Symbols & Interposition
✓
Phase 24
✓
Plugin Systems with dlopen
✓
Unit Testing with CUnit/Check
✓
Mocking in C
✓
Fuzzing with libFuzzer
✓
Phase 25
✓
Assertion-Based Testing
✓
Test Coverage Analysis (gcov)
✓
Phase 26
✓
Continuous Integration for C
✓
Valgrind for Memory Testing
✓
Buffer Overflow Attacks
✓
Stack Canaries
✓
Phase 27
✓
Address Space Layout Randomization
✓
Format String Vulnerabilities
✓
Phase 28
✓
Integer Overflow & Wraparound
✓
Secure Coding Guidelines (CERT)
✓
Static Analysis with Coverity
✓
Recursive Descent Parsing
✓
Phase 29
✓
Lex/Yacc & Flex/Bison
✓
Regular Expressions in C
✓
Phase 30
✓
JSON Parser Implementation
✓
INI File Parser
✓
CSV Parsing Edge Cases
✓
Binary Protocol Parsing
✓
Phase 31
✓
File I/O System Calls
✓
Process Management (fork, exec)
✓
Phase 32
✓
Inter-Process Communication (pipe, FIFO)
✓
Signal Handling
✓
Memory-Mapped Files
✓
Resource Limits (setrlimit)
✓
Phase 33
✓
Daemon Process Creation
Text version of this roadmap
1. Foundations
- Pointer Arithmetic
- Pointer to Pointer (Double Indirection)
- Function Pointers & Callbacks
2. Core Concepts
- Restrict Keyword (C99)
- Void Pointers (Generic Pointers)
- Complex Pointer Declarations
3. Intermediate Skills
- Dangling Pointers & Safe Patterns: Various advanced pointers patterns emerge when working with dangling pointers & safe patterns in C. These patterns provide reusable solutions to common programming challenges.
- Static, Stack & Heap Allocation
- Malloc Internals (glibc): The internal architecture of malloc internals (glibc) in C reveals how the runtime handles Memory Management. This knowledge enables more informed design decisions and debugging.
4. Advanced Topics
- Calloc, Realloc & Aligned Allocation
- Memory Pools & Custom Allocators
- Memory Corruption Detection
5. Expert Level
- Stack Allocation & VLA (C99)
- Memory-Mapped Files (mmap)
- Reference Counting in C
6. Mastery
- Token Pasting (##) & Stringification (#)
- Variadic Macros & __VA_ARGS__
- X-Macros & Code Generation
7. Ecosystem
- Header Guards & #pragma once
- #line & #error Directives
- Conditional Compilation Patterns: Various preprocessor magic patterns emerge when working with conditional compilation patterns in C. These patterns provide reusable solutions to common programming challenges.
8. Architecture
- Macro Pitfalls: Multiple Evaluation
- Translation Phases
- Lexical Analysis & Tokens
9. Optimization
- Parsing & AST Generation
- Code Generation & Optimization
- Linker Relocation & Symbol Resolution
10. Deployment
- Inline Functions vs Macros
- Calling Convention (cdecl, stdcall)
- POSIX Threads (pthreads)
11. Phase 11
- Mutex & Condition Variables
- Thread-Local Storage
- C11 Atomics & Memory Order
12. Phase 12
- Lock-Free Data Structures
- Signal Handling & Async-Safety
- OpenMP Parallel Directives
13. Phase 13
- Compiler Optimization Flags (-O1, -O2, -O3)
- Profile-Guided Optimization
- Loop Unrolling & Vectorization
14. Phase 14
- Cache-Friendly Data Layout
- Branch Prediction & Likely/Unlikely
- Inline Assembly Intrinsics
15. Phase 15
- Link-Time Optimization (LTO)
- System V AMD64 ABI
- Windows x64 Calling Convention
16. Phase 16
- Stack Frame Layout
- Return Value Handling
- Structure Passing
17. Phase 17
- TLS & Thread-Local Storage ABI
- Name Mangling & C Linkage
- Volatile & Memory-Mapped I/O
18. Phase 18
- Interrupt Service Routines
- Bit Manipulation Techniques
- Fixed-Point Arithmetic
19. Phase 19
- Watchdog Timers
- Low-Power Modes
- Bootloader Implementation: The bootloader implementation pattern in C provides a structured approach to handling Embedded C. Understanding the implementation details helps write more robust and maintainable code.
20. Phase 20
- Berkeley Sockets API
- TCP Server Implementation: The tcp server implementation pattern in C provides a structured approach to handling Networking & Sockets. Understanding the implementation details helps write more robust and maintainable code.
- Non-blocking I/O with epoll
21. Phase 21
- UDP Multicast
- DNS Resolution (getaddrinfo)
- Raw Sockets & Packet Injection
22. Phase 22
- SSL/TLS with OpenSSL
- Static vs Shared Libraries
- Library Search Paths
23. Phase 23
- Symbol Visibility & dllexport
- Linking Order & Undefined Symbols
- Shared Library Versioning
24. Phase 24
- Weak Symbols & Interposition
- Plugin Systems with dlopen
- Unit Testing with CUnit/Check
25. Phase 25
- Mocking in C
- Fuzzing with libFuzzer
- Assertion-Based Testing
26. Phase 26
- Test Coverage Analysis (gcov)
- Continuous Integration for C
- Valgrind for Memory Testing
27. Phase 27
- Buffer Overflow Attacks
- Stack Canaries
- Address Space Layout Randomization
28. Phase 28
- Format String Vulnerabilities
- Integer Overflow & Wraparound
- Secure Coding Guidelines (CERT)
29. Phase 29
- Static Analysis with Coverity
- Recursive Descent Parsing
- Lex/Yacc & Flex/Bison
30. Phase 30
- Regular Expressions in C
- JSON Parser Implementation: The json parser implementation pattern in C provides a structured approach to handling Parsing Techniques. Understanding the implementation details helps write more robust and maintainable code.
- INI File Parser
31. Phase 31
- CSV Parsing Edge Cases
- Binary Protocol Parsing
- File I/O System Calls
32. Phase 32
- Process Management (fork, exec)
- Inter-Process Communication (pipe, FIFO)
- Signal Handling
33. Phase 33
- Memory-Mapped Files
- Resource Limits (setrlimit)
- Daemon Process Creation