C Roadmap

Open a topic for notes and resources. Mark it done when you are ready to move on.

33 stages · 132 topics 0% done
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