Clean Code & Refactoring learning path: everything to study, topic by topic

Core philosophy of clean code: code should be readable by humans first, computers second. Covers the Boy Scout Rule, expressiveness over cleverness, and the cost of messy code over time.

Choosing names that reveal intent, avoid disinformation, and make distinctions meaningful. Covers naming variables, functions, classes, and avoiding encodings like Hungarian notation.

Understanding and reducing the mental burden of reading code. Covers cyclomatic complexity, nesting depth, cognitive load theory applied to code, and techniques for flattening control flow.

Identifying symptoms of deeper design problems: long methods, large classes, duplicate code, dead code, feature envy, data clumps, primitive obsession, and divergent change. Understanding what each smell signals.

Principles for writing small, focused functions: do one thing, one level of abstraction per function, minimal arguments, no side effects, and Command-Query Separation.

Writing clean error handling: prefer exceptions over error codes, provide context with exceptions, define exception classes by caller needs, avoid returning null, and the fail-fast principle.

Clean object-oriented design: Law of Demeter, data encapsulation, avoiding train wrecks, distinguishing data transfer objects from active records, and the difference between objects and data structures.

Clean use of data structures: avoiding hybrid objects, keeping boundaries between system layers, wrapping third-party code, and using adapters to isolate external dependencies.

Philosophy of comments: good code explains itself, comments compensate for failure to express in code. Types of good comments (legal, informative, intent, warning, TODO) versus bad comments (noise, misleading, journal, mumbling).

Consistent formatting as team communication: vertical openness between concepts, vertical density for related code, ordering of functions, horizontal alignment, indentation, and the value of enforced style guides.

F.I.R.S.T. principles of clean tests: Fast, Independent, Repeatable, Self-Validating, Timely. One assert per test, single concept per test, and readable test structure with Arrange-Act-Assert.

The TDD cycle: Red-Green-Refactor. Three laws of TDD, the impact on design quality, test doubles (mocks, stubs, fakes), and when TDD pays off versus when it adds overhead.

Evaluating and improving test suites: test coverage vs test effectiveness, mutation testing, brittle tests, over-mocking, test pyramid, and distinguishing unit, integration, and end-to-end tests.

Definition and discipline of refactoring: changing internal structure without changing external behavior. The two-hat principle, when to refactor vs rewrite, and maintaining a safety net of tests before refactoring.

The most common refactoring operations: Extract Method, Extract Variable, Inline Method, Extract Class, and Move Method. Mechanics, when to apply each, and common pitfalls.

Refactoring complex conditional logic: Decompose Conditional, Consolidate Conditional Expression, Replace Nested Conditional with Guard Clauses, and Replace Conditional with Polymorphism.

Advanced refactoring patterns from Fowler's catalog: Replace Temp with Query, Introduce Parameter Object, Replace Data Value with Object, Separate Query from Modifier, and Replace Magic Number with Symbolic Constant.

Applying all five SOLID principles in real codebases: identifying violations, refactoring to compliance, and understanding when rigid SOLID adherence creates over-engineering.

Three foundational heuristics: Don't Repeat Yourself (avoiding knowledge duplication), You Aren't Gonna Need It (avoiding speculative generality), and Keep It Simple Stupid (favoring the simplest solution that works).

Managing dependencies for testability and maintainability: dependency injection, Inversion of Control, stable dependencies principle, and avoiding circular dependencies.

Understanding coupling types (content, common, control, stamp, data) and cohesion levels (coincidental, logical, temporal, communicational, functional). Striving for high cohesion and low coupling in module design.

Feathers' techniques for safely modifying legacy code: seams, characterization tests, sprout method/class, wrap method/class, and the golden master technique for untestable code.

Strategies for refactoring at system scale: strangler fig pattern, branch by abstraction, parallel change (expand-contract), and managing refactoring risk in production systems with continuous deployment.

Effective code reviews for code quality: what to look for, constructive feedback techniques, review checklist design, size limits for reviewable PRs, and automation versus human review judgment.

Types of technical debt (deliberate/inadvertent, reckless/prudent), debt quadrant model, quantifying debt impact, communicating debt to non-technical stakeholders, and debt repayment strategies.

Robert Martin's Clean Architecture: dependency rule, concentric layers (entities, use cases, interface adapters, frameworks), ports-and-adapters, and how clean architecture enables testability at scale.

Quantitative measures of code quality: cyclomatic complexity, Lines of Code, code churn, change failure rate, instability/abstractness, and the pitfalls of optimizing for any single metric.