computing_study_roadmap.md

Computing Study Roadmap by drewdomi

A rigorous, systems-focused approach to mastering computer science fundamentals

🎯 Philosophy

This roadmap is designed for "serious" learners who want to understand how computers actually works. We start with C because it forces you to understand memory management, system calls, and low-level operations.

Estimated Timeline: 18-24 months (intensive study) Prerequisites: Basic programming knowledge, comfort with command line

Note: All dates are illustrative only.

---

📚 Core Learning Path

Phase 1: Programming Mastery (8-12 weeks)

1.1 Advanced C Programming (4-6 weeks)

Goal: Master C and understand how programs actually execute

Primary Resource: "The C Programming Language" (K&R) + "Expert C Programming" (Peter van der Linden)

Deep Dive Topics:

• Memory layout: stack, heap, data, text segments
• Pointer arithmetic and multi-level pointers
• Function pointers and callbacks
• Dynamic memory allocation strategies
• Undefined behavior and implementation-defined behavior
• Preprocessor macros and conditional compilation
• Inline assembly integration

Projects:

• Write a memory allocator (malloc/free implementation)
• Build a C preprocessor
• Implement a hash table with collision handling
• Create a simple garbage collector

1.2 System Calls and OS Interface (4-6 weeks)

Goal: Understand the boundary between user space and kernel space

Primary Resource: "Advanced Programming in the UNIX Environment" (Stevens)

Deep Dive Topics:

• Process creation: fork(), exec(), wait()
• Inter-process communication: pipes, shared memory, message queues
• Signal handling and asynchronous programming
• File I/O: buffered vs unbuffered, file descriptors
• Memory mapping (mmap) and virtual memory
• Thread programming with pthreads
• Network programming with sockets

Projects:

• Build a shell with job control
• Implement a multi-threaded web server
• Create a process monitor/debugger
• Write a simple database storage engine

---

Phase 2: Computer Architecture Deep Dive (6-8 weeks)

2.1 Assembly Language and Machine Organization

Goal: Understand what the compiler generates and how CPUs execute code

Primary Resource: "Computer Systems: A Programmer's Perspective" (Bryant/O'Hallaron) - Full book

Deep Dive Topics:

• x86-64 assembly programming
• Instruction encoding and machine code
• CPU pipeline and hazards
• Branch prediction and speculative execution
• Cache hierarchies and memory performance
• Virtual memory and page tables
• Exception handling and system calls at the hardware level

Projects:

• Write assembly routines for performance-critical algorithms
• Build a simple CPU emulator
• Implement cache simulation
• Create a disassembler

2.2 Compiler Construction (4-6 weeks)

Goal: Understand how high-level code becomes machine code

Primary Resource: "Crafting Interpreters" + "Engineering a Compiler"

Deep Dive Topics:

• Lexical analysis and parsing
• Abstract syntax trees and intermediate representations
• Code generation and optimization
• Register allocation
• Linking and loading
• Runtime systems

Projects:

• Build a C compiler (subset of C)
• Implement optimization passes
• Create a linker
• Write a runtime profiler

---

Phase 3: Operating Systems Internals (8-10 weeks)

3.1 Kernel Programming and OS Design

Goal: Understand how operating systems manage resources

Primary Resource: "Operating System Concepts" (Silberschatz) + Linux kernel source

Deep Dive Topics:

• Process scheduling algorithms and implementation
• Memory management: paging, segmentation, virtual memory
• File system implementation (ext4, B+ trees)
• Device drivers and interrupt handling
• Synchronization primitives: mutexes, semaphores, RCU
• System call implementation
• Kernel modules and loadable drivers

Projects:

• Write a simple operating system kernel
• Implement a file system
• Build a device driver
• Create a kernel module for process monitoring

3.2 Concurrency and Parallelism

Goal: Master multi-threaded and parallel programming

Deep Dive Topics:

• Lock-free data structures
• Memory models and ordering guarantees
• NUMA awareness and cache-friendly algorithms
• Parallel algorithms design
• GPU programming basics (CUDA/OpenCL)

Projects:

• Implement lock-free queue and stack
• Build a thread pool with work stealing
• Create parallel sorting algorithms
• Write SIMD-optimized routines

---

Phase 4: Data Structures and Algorithms (Advanced) (6-8 weeks)

4.1 Advanced Data Structures

Goal: Implement complex data structures from scratch in C

Primary Resource: "Introduction to Algorithms" (CLRS) + "Advanced Data Structures" (Brass)

Deep Dive Topics:

• Self-balancing trees: AVL, Red-Black, Splay
• B-trees and B+ trees for disk storage
• Tries and compressed tries
• Skip lists and probabilistic data structures
• Bloom filters and Count-Min sketches
• Persistent data structures

Projects:

• Database index implementation (B+ tree)
• Full-text search engine
• Memory-efficient graph representations
• Cache-oblivious algorithms

4.2 Algorithm Analysis and Design

Goal: Design efficient algorithms and analyze their complexity

Deep Dive Topics:

• Advanced graph algorithms: network flows, matching
• String algorithms: KMP, Rabin-Karp, suffix arrays
• Computational geometry basics
• Approximation algorithms
• Randomized algorithms
• Cache-aware algorithm design

Projects:

• Implement a graph database
• Build a computational geometry library
• Create a string matching library
• Write performance-critical algorithms

---

Phase 5: Network Programming and Distributed Systems (6-8 weeks)

5.1 Network Programming

Goal: Build high-performance networked applications

Primary Resource: "UNIX Network Programming" (Stevens) + "High Performance Browser Networking"

Deep Dive Topics:

• TCP/IP stack implementation details
• High-performance I/O: epoll, kqueue, io_uring
• Protocol design and implementation
• Network security and cryptography
• Load balancing and connection pooling

Projects:

• High-performance HTTP server
• Custom protocol implementation
• Network proxy/load balancer
• Packet analyzer

5.2 Distributed Systems Fundamentals

Goal: Understand how distributed systems work

Primary Resource: "Designing Data-Intensive Applications" (Kleppmann)

Deep Dive Topics:

• Consensus algorithms: Raft, PBFT
• Distributed storage systems
• Consistency models and CAP theorem
• Fault tolerance and replication
• Distributed debugging and monitoring

Projects:

• Distributed key-value store
• Raft consensus implementation
• Distributed file system
• Message queue system

---

Phase 6: Performance Engineering (4-6 weeks)

6.1 Performance Analysis and Optimization

Goal: Master performance analysis and optimization techniques

Deep Dive Topics:

• CPU profiling: perf, Intel VTune
• Memory profiling: Valgrind, AddressSanitizer
• Micro-benchmarking methodology
• Cache optimization techniques
• SIMD programming
• Profile-guided optimization

Projects:

• Performance analysis toolkit
• Optimized math libraries
• Memory pool allocators
• High-frequency trading system components

---

🛠️ Essential Tools Mastery

Development Environment:

• Editor: Vim/Neovim with custom configuration
• Debugger: GDB with advanced features
• Build Systems: Make, CMake, Ninja
• Static Analysis: Clang Static Analyzer, Cppcheck
• Dynamic Analysis: Valgrind, AddressSanitizer, ThreadSanitizer

Performance Tools:

• Profilers: perf, Intel VTune, gperftools
• Tracing: strace, ltrace, BPF/eBPF
• Monitoring: htop, iotop, netstat, tcpdump

Version Control:

• Advanced Git: rebasing, bisect, hooks, submodules

---

📊 Milestone Projects (Build These)

Quarter 1: Core Systems

1. Memory Allocator: Custom malloc/free with debugging features
2. Shell: Full-featured shell with job control and scripting
3. HTTP Server: High-performance concurrent web server

Quarter 2: Low-Level Systems

4. Simple OS: Bootable kernel with basic process management
5. C Compiler: Subset C compiler with optimization passes
6. Database Engine: B+ tree based storage engine

Quarter 3: Advanced Systems

7. Distributed Key-Value Store: With Raft consensus
8. Network Stack: User-space TCP/IP implementation
9. File System: FUSE-based file system with advanced features

Quarter 4: Performance Systems

10. High-Frequency Trading Engine: Ultra-low latency system
11. Game Engine Core: 3D graphics and physics engine
12. Container Runtime: Docker-like container system

---

📈 Assessment Criteria

Technical Depth:

• Can you implement complex algorithms from scratch?
• Do you understand time/space complexity trade-offs?
• Can you debug systems-level issues?
• Can you optimize code for performance?

Systems Understanding:

• Can you explain how a program executes from source to binary?
• Do you understand memory hierarchies and their impact?
• Can you design fault-tolerant distributed systems?
• Can you write secure, concurrent code?

Problem Solving:

• Can you design systems to handle millions of requests?
• Can you debug race conditions and deadlocks?
• Can you optimize algorithms for specific hardware?
• Can you design protocols and data formats?

---

🚫 What We're NOT Skipping

Unlike the beginner roadmap, we include:

• Assembly programming - Essential for optimization
• OS kernel development - Understanding system boundaries
• Compiler construction - How code becomes executable
• Advanced algorithms - Complex problem solving
• Performance engineering - Writing fast code
• Distributed systems theory - Modern system design

---

📚 Core Reading List

Essential Books:

1. "The C Programming Language" - Kernighan & Ritchie
2. "Computer Systems: A Programmer's Perspective" - Bryant & O'Hallaron
3. "Advanced Programming in the UNIX Environment" - Stevens
4. "Operating System Concepts" - Silberschatz
5. "Introduction to Algorithms" - Cormen, Leiserson, Rivest, Stein
6. "Designing Data-Intensive Applications" - Kleppmann

Advanced Reading:

7. "Computer Architecture: A Quantitative Approach" - Hennessy & Patterson
8. "Modern Operating Systems" - Tanenbaum
9. "Distributed Systems" - van Steen & Tanenbaum
10. "High Performance Computing" - various authors

---

💪 Study Methodology

Daily Practice:

• Code Daily: Write C code every single day
• Read Source: Study high-quality C codebases (Linux, Redis, SQLite)
• Debug Everything: Use debuggers, not printf debugging
• Profile Constantly: Measure performance, don't guess

Weekly Goals:

• Complete one major coding challenge
• Read one research paper
• Contribute to an open-source C project
• Write technical blog posts about your learnings

Monthly Assessments:

• Build one significant project
• Present system design to peers
• Participate in code reviews
• Benchmark and optimize previous projects

---

🎯 Career Outcomes

After completing this roadmap, you'll be qualified for:

• Systems Engineer at tech companies
• Kernel Developer for OS vendors
• Performance Engineer for high-frequency trading
• Infrastructure Engineer at scale-up companies
• Embedded Systems Developer
• Database Engine Developer
• Compiler Engineer

---

This is not a beginner's path. It's designed to create deep, systems-level understanding that will set you apart as a software engineer. Expect to struggle, debug for hours, and occasionally question your sanity. That's the point.

Remember: Every great systems programmer has implemented a malloc, written a shell, and debugged a segfault at 3 AM. Welcome to the club. 🔥