Reference and Selective Reading

You do not need to read Clean Code front-to-back for this module. Use the concept and practice pages first. Open these chunks only when you want the book's framing, a stronger example, or more case-study detail behind a concept.

Scope Note

This reference page maps only the Clean Code material that supports the current Semester 0 module.

It does not try to exhaust every page, appendix, or Java-specific implementation detail. The goal here is durable judgment about clean code, not total source reproduction.

Read Only If Stuck

Optional Deep Dive

Source-Role Clarity

Primary teaching source: the concept and practice pages in this module
Selective reference: the linked Clean Code chunks that reinforce the main path
Exercise source: the drills and practice pages in this module
Official docs: not required here because this module is principle-heavy rather than tool-heavy
Optional deep dive: case-study detail, long examples, and broader smell catalogs

Concept-to-Source Map

Concept page	Best source if stuck	Why this source
Clean Code Is a Change Strategy	Chapter 1: Bad Code to The Grand Redesign in the Sky and Chapter 1: Attitude to The Art of Clean Code	Best first explanation of why code quality is really about cost and professionalism
Names Carry Design Intent	Chapter 2: Introduction to Make Meaningful Distinctions and Chapter 2: Interfaces and Implementations to Use Problem Domain Names	Best for intent-revealing names and domain vocabulary
Comments Are a Last Resort	Chapter 4: Comments Do Not Make Up for Bad Code to Explanation of Intent	Best for understanding when comments help and when they hide deeper problems
Formatting Shapes How Code Is Read	Chapter 5: The Purpose of Formatting to Vertical Density	Best first framing for formatting as communication
Functions Should Do One Thing	Chapter 3: Small! to Blocks and Indenting and Chapter 3: Do One Thing to The Stepdown Rule	Best for size, abstraction level, and stepdown flow
Arguments and Side Effects Must Be Honest	Chapter 3: Switch Statements to Function Arguments and Chapter 3: Have No Side Effects to The Error.java Dependency Magnet	Best for signature pressure and hidden mutation
Errors and Boundaries Should Not Obscure Intent	Chapter 7: Use Exceptions Rather Than Return Codes to Use Unchecked Exceptions and Chapter 8: Exploring and Learning Boundaries to Using Code That Does Not Yet Exist	Best for separating main logic from failure and library noise
Tests Enable Design Change	Chapter 9: Keeping Tests Clean to Tests Enable the -ilities	Best for the central argument that tests protect change
Tests Should Read Like Explanations	Chapter 9: Clean Tests to Domain-Specific Testing Language and F.I.R.S.T. to Chapter 10: Classes	Best for clean test structure and behavioral clarity
Simple Design Emerges Through Cleanup	Chapter 12: No Duplication to Bibliography	Best for simple design as a result of steady cleanup
Objects Hide Decisions, Data Structures Expose Them	Chapter 6: Data/Object Anti-Symmetry to Hybrids	Best for the object/data distinction and hybrid warning
Small Classes Organize for Change	Chapter 10: Class Organization to Classes Should Be Small! and Chapter 10: Organizing for Change to Bibliography	Best for SRP, cohesion, and class size by responsibility
Systems Need Seams, Not Giant Blobs	Chapter 11: How Would You Build a City? to Dependency Injection	Best beginner-level bridge from local cleanliness to system structure
Refactoring Is Successive Refinement	Chapter 14: Args Implementation to How Did I Do This? and First, Make It Work	Best for the incremental cleanup mindset
Heuristics Sharpen Review Judgment	Chapter 17: C1 to G4 plus the rest of Chapter 17	Best for review-ready smell categories and practical scan rules

Direct Chunk Shortcuts By Need

If you need help with...	Best chunk
why bad code compounds cost	Chapter 1: Bad Code to The Grand Redesign in the Sky
better names for domain concepts	Chapter 2: Interfaces and Implementations to Use Problem Domain Names
deciding whether a comment should survive	Chapter 4: Comments Do Not Make Up for Bad Code to Explanation of Intent
making a function smaller and more readable	Chapter 3: Do One Thing to The Stepdown Rule
side effects and signature problems	Chapter 3: Have No Side Effects to The Error.java Dependency Magnet
cleaning up error handling	Chapter 7: Use Exceptions Rather Than Return Codes to Use Unchecked Exceptions
designing better tests	Chapter 9: Clean Tests to Domain-Specific Testing Language
class responsibility and cohesion	Chapter 10: The Single Responsibility Principle to Cohesion
incremental refactoring	First, Make It Work
code-review smell detection	Chapter 17: G5 to G11

Deliberately Deferred Source Areas

These are real parts of the book, but they are intentionally outside the main Semester 0 path:

Deferred area	Source chunk	Why it is deferred
long JUnit internals case study	Conclusion to The JUnit Framework (Part 1) to The JUnit Framework (Part 3)	useful for deeper framework reading, but not required for the clean-code principles in this module
full SerialDate appendix-scale refactor detail	Appendix B: org.jfree.date.SerialDate (Part 1) onward	too detailed for the first pass through refactoring judgment
concurrency chapter and appendix	Chapter 13: Why Concurrency? to Single Responsibility Principle and Appendix A	concurrency deserves its own later treatment rather than being squeezed into Semester 0 clean-code habits
full appendix C heuristic cross-reference tables	Appendix C: Cross References of Heuristics onward	reference-heavy, helpful later, but too dense for the main path

If you want more depth on those later, treat this table as a forward map rather than a missing-content list.

Scope Note​

Read Only If Stuck​

Optional Deep Dive​

Source-Role Clarity​

Concept-to-Source Map​

Direct Chunk Shortcuts By Need​

Deliberately Deferred Source Areas​