Full-Book CS and Software Engineering Degree
This is the extended, book-complete successor to the 96-week roadmap.
The existing roadmap remains the faster guide-first path. This path makes a different promise:
If a book is admitted to your active curriculum lane, read it from beginning to end, complete its meaningful exercises, and use it to build or explain something.
"Complete" includes the preface, main chapters, appendices that teach new material, and the author's exercises. It does not require reading indexes, bibliographies, repeated front matter, or mechanically duplicating every drill in a reference-sized text.
This is not a 96-week plan. A realistic first pass is 240-320 weeks at 12-15 focused hours per week. The range is intentional: proof-heavy mathematics, CLRS, systems texts, and large reference books must be paced by demonstrated mastery rather than calendar pressure.
Why a Separate Path Exists
The original curriculum deliberately says that the guide teaches first and books are selective support. That is a sound design for a compact path, but it directly conflicts with a whole-book goal. This version changes the unit of planning:
| Compact path | Full-book path |
|---|---|
| Concept cluster | Book part or complete short book |
| Selected chapters | Sequential cover-to-cover reading |
| 96 fixed weeks | Mastery-paced 240-320 week envelope |
| Guide is the teacher | Book is the narrative spine; guide is the coach |
| Many books may support a module | One active technical book, with at most one parallel practice book |
| Module completion | Reading, exercises, retrieval, artifact, and oral/written defense |
The path is still active and project-driven. Reading a last page is not evidence of understanding.
Curriculum Baseline
The curriculum is checked against three kinds of external evidence:
- CS2023, the current ACM/IEEE-CS/AAAI computer-science curriculum guidance, including its knowledge areas and its emphasis on competencies and connections across areas.
- ABET's 2025-2026 computing criteria, especially algorithms, theory, programming languages, architecture, information management, networking, operating systems, parallel/distributed computing, security/privacy, professional responsibility, communication, and an integrating major project.
- SWEBOK and SE2014 for the engineering lifecycle beyond computer-science theory.
The sequence also borrows two useful self-study ideas: OSSU separates required core, advanced electives, and a final project; Teach Yourself Computer Science uses one strong book and one strong lecture sequence per major subject. This plan differs by requiring full completion of every book selected into a lane.
Four Library Lanes
The folders are a source library, not a single reading queue.
Lane A: Core degree books
These are required and read in full. They create the coherent undergraduate-to-professional spine.
Lane B: Paired practice books
These are also read in full, but only when scheduled beside the matching core book. They supply problems, implementations, or a second explanatory style. Never run more than one core book and one practice book concurrently.
Lane C: Advanced concentrations
Choose one concentration after the common core. Every admitted book in that concentration is read in full. Other concentration books remain outside the active curriculum; they are not silently "optional but expected."
Lane D: Papers and references
The reading/ collection and most of Resources/ belong here. Papers are read in full when a research question, seminar, or project calls for them. Standards and documentation are consulted by task. A reference work is promoted into Lane A-C only through a written curriculum change.
This keeps the commitment finite while preserving the larger library.
Sequence
The ranges below are planning envelopes, not deadlines. A week assumes roughly 12-15 hours split among reading, problems, implementation, retrieval, and writing.
Stage 0 — Learning, tools, and orientation (12-16 weeks)
Read in order:
- Atomic Habits
- The Missing Semester of Your CS Education
- The Linux Command Line
- Pro Git
- Computer Science Distilled
- Grokking Algorithms
Build: a reproducible workstation bootstrap, Git sandbox, shell notebook, and small algorithms repository.
Gate: reproduce the environment from a clean machine or VM; explain Git objects and common recovery workflows; solve unfamiliar introductory problems without copying a pattern.
Stage 1 — Mathematical foundations (36-52 weeks)
Read in order, with exercises throughout:
- Mathematics for Computer Science
- Discrete Mathematics and Its Applications
- Introduction to Probability
- Linear Algebra and Its Applications
- Elementary Number Theory
- How to Solve It by Computers as the paired problem-solving text
Build: proof notebook, graph/probability simulations, and a small numerical-computing library.
Gate: timed closed-book proof and modeling exam, error taxonomy, and oral defense of three corrected solutions.
Stage 2 — Algorithms and data structures (32-44 weeks)
Read in order:
- The Algorithm Design Manual
- Introduction to Algorithms (CLRS)
- Algorithms by Sedgewick and Wayne
- Competitive Programming as the practice text
Build: tested data-structure library, benchmark suite, algorithm-selection casebook, and a graph-oriented application.
Gate: derive complexity bounds, prove correctness, implement representative structures without reference, and defend choices using measured data.
Stage 3 — Programs, languages, and software design (32-44 weeks)
Read in order:
- Structure and Interpretation of Computer Programs
- Object-Oriented Analysis, Design and Implementation
- Refactoring
- Design Patterns: Elements of Reusable Object-Oriented Software
- Head First Design Patterns
- Good Code, Bad Code
- Clean Code, read critically rather than as unquestionable law
Build: interpreter, legacy-system rescue, pattern comparison portfolio, and a medium-sized application maintained across the entire stage.
Gate: show behavior-preserving refactors, characterize tradeoffs, reject at least one inappropriate pattern, and complete a design review.
Stage 4 — Machine and systems programming (28-40 weeks)
Read in order:
- Code: The Hidden Language of Computer Hardware and Software
- The C Programming Language
- Computer Organization and Design
- Computer Systems: A Programmer's Perspective
Build: C utilities, allocator, cache experiments, assembly investigations, debugger transcripts, and a simple emulator or CPU-related build.
Gate: explain a program from source to machine execution; diagnose memory and performance failures with evidence.
Stage 5 — Operating systems and networking (32-44 weeks)
Read in order:
- Operating Systems: Three Easy Pieces
- Operating System Concepts
- Computer Networking: A Top-Down Approach
- UNIX Network Programming, Volume 1
Build: shell/process tools, synchronization labs, file-system experiment, packet analyses, and a concurrent network service.
Gate: failure-injection practical covering processes, virtual memory, synchronization, I/O, TCP/UDP, and socket lifecycle behavior.
Stage 6 — Data and distributed systems (32-44 weeks)
Read in order:
- Database System Concepts
- Database Internals
- Designing Data-Intensive Applications
- Distributed Systems: Concepts and Design
Build: storage-engine components, query-plan studies, replicated service, consistency test harness, and failure-mode report.
Gate: defend data models, indexes, isolation, replication, partitioning, and consistency choices against concrete workloads and failures.
Stage 7 — Architecture and domain design (28-38 weeks)
Read in order:
- Just Enough Software Architecture
- Fundamentals of Software Architecture
- Clean Architecture, read as one argued position
- Learning Domain-Driven Design
- API Design Patterns
Build: evolving modular monolith, domain model, context map, API lifecycle policy, quality-attribute scenarios, and ADR portfolio.
Gate: architecture review with competing options, risk analysis, evolutionary plan, and evidence that boundaries survive change.
Stage 8 — Production systems and engineering organizations (28-40 weeks)
Read in order:
- Designing Event-Driven Systems
- Microservice Architecture
- Designing Distributed Systems
- Design Patterns for Cloud Native Applications
- Building Secure and Reliable Systems
- Software Engineering at Google
- GitHub Actions in Action
Use Google's SRE books as an additional full-book pair when the local library contains or legally links them.
Build: deployed service, CI/CD pipeline, observability stack, SLOs, threat model, incident exercise, rollback, and postmortem.
Gate: operational-readiness review and live failure drill.
Stage 9 — System design and technical leadership (12-18 weeks)
Read in order:
- System Design Interview by Alex Xu
- System Design Primer
These books teach communication patterns and breadth; earlier systems texts remain the technical authority.
Build: six timed designs, two long-form design documents, cost model, capacity plan, and critique comparing interview simplifications with production realities.
Gate: two independent reviewers can follow, challenge, and reproduce the reasoning.
Stage 10 — Concentration and capstone (24-40 weeks)
Choose exactly one concentration at first: AI/ML, security, compilers/programming languages, graphics, robotics, web/platform, or advanced distributed systems. Promote a finite set of books and papers from Books/, reading/, and Resources/ into Lane C, then read all of them in full.
The capstone must integrate requirements, design, implementation, verification, delivery, operations, security/privacy, professional communication, and an explicit ethical-impact review.
Gate: public-safe portfolio, reproducible build/deploy path, runbook, threat model, measured evaluation, written retrospective, and oral defense.
The Whole-Book Study Loop
Use the same loop for every book.
- Survey: inspect the table of contents, preface, dependencies, exercises, and companion material.
- Contract: record the edition, start date, expected weekly load, exercise policy, and planned artifact.
- Read sequentially: do not cherry-pick the interesting chapters.
- Retrieve: close the book and reconstruct the argument, algorithm, model, or diagram.
- Practice: solve exercises before consulting answers; tag every error.
- Build: connect each major part to code, a proof set, an experiment, or a design decision.
- Synthesize: write a part-level map showing how its chapters fit together.
- Defend: finish with a closed-book check and a written or oral defense.
- Revisit: schedule retrieval at approximately 1 week, 1 month, and 3 months.
Repeated retrieval improves delayed recall more reliably than repeated study alone (Karpicke and Roediger, 2008); classroom research also supports distributing practice over time rather than massing it (distributed-practice meta-analysis). That evidence supports whole-book reading only when retrieval and application remain in the loop.
Completion Evidence
A book is complete only when its ledger contains:
- edition and stable source identifier
- start and finish dates
- chapter/part checklist
- exercise log and sampling rule
- misconception and error log
- one synthesis map per major part
- durable artifact or experiment
- closed-book assessment result
- review dates and unresolved questions
Completion percentage is never calculated from pages alone.
Rules That Keep the Plan Survivable
- One active technical spine book at a time.
- At most one paired practice book and one light professional book in parallel.
- Do not start a new book while the prior book's gate is unresolved.
- Every sixth week is consolidation: finish exercises, repair artifacts, and retrieve earlier material.
- Every stage ends with a 1-2 week buffer and cumulative defense.
- A new source must replace another source or extend the published duration; it cannot enter invisibly.
- Papers answer project questions. They do not become a guilt-driven background queue.
- Use legally obtained copies and link to official/free editions where available; do not publish extracted copyrighted book text.
Known Coverage Gaps in the Current Library
The existing library is strongest in algorithms, systems, databases, distributed systems, and architecture. Before calling the new path degree-equivalent, explicitly strengthen:
- programming-language foundations, compilers, and type systems
- security and privacy as a continuous core, not only a late specialization
- society, ethics, law, accessibility, and professional responsibility
- human-computer interaction
- parallel computing beyond concurrency basics
- requirements engineering, maintenance, configuration management, and engineering economics
- scientific method and empirical software engineering
CS2023 treats AI, HCI, security, and society/ethics/profession as first-class knowledge areas, while ABET requires security/privacy, societal impacts, communication, teamwork, and a major integrating project. These gaps should be filled deliberately from reading/ and Resources/; the presence of thousands of files is not evidence of curricular coverage.
Start Here
- Finish the Getting Started setup.
- Create a book ledger using the whole-book contract above.
- Start Stage 0 with Atomic Habits and the Missing Semester labs.
- Keep the existing curriculum pages as coaching, exercises, and assessment support.
- Do not generate the remaining 240-320 weeks in advance. Publish a stage only after its books, exercise policy, artifacts, and gates have been audited.