code-patterns

Code patterns & craft

Code is read far more than it is written. Learn the craft that keeps a codebase changeable — naming, SOLID, code smells, and safe refactoring — plus the judgment to know when an abstraction earns its keep.

15 units·50 lessons·~16 h

Start track →

What good code is

Code is read and changed far more than it is written, so the dominant cost of software is the cost of change. 'Good code' is not an aesthetic — it is code whose next change is cheap. This unit installs that lens.

01 The cost of change 18 min 02 The maintainability triad 20 min 03 Clean, not clever 18 min

Names & intention

A name compresses intent. Good names reveal what and why, not how — and the difficulty of naming something is design feedback about whether it does one thing.

01 Naming is a design act 18 min 02 Intention-revealing names 18 min 03 Consistency and scope 18 min

Functions & cohesion

A function should do one thing at one level of abstraction, separate commands from queries, and keep its arguments and side effects few and visible. Cohesion is the goal; small is a side effect.

01 Small functions, one job 19 min 02 One level of abstraction 19 min 03 Command/query separation 19 min 04 Arguments and side effects 19 min

Comments & contracts

Comments rot because they aren't executed; prefer code that documents itself and push invariants into types and tests, which can't lie. The few comments worth keeping explain why, not what.

01 When comments lie 18 min 02 Self-documenting code 19 min 03 Types and tests as documentation 20 min

SRP: single responsibility

A module should have one reason to change — be answerable to one actor — not literally do one thing. Group code by who requests changes; both god-class and class-explosion are SRP failures.

01 One reason to change 19 min 02 Actors and axes of change 19 min 03 Splitting without shattering 19 min

Open/Closed & Liskov

Add behaviour by adding code, not editing tested code (OCP) — but only along the variation axis you can predict. Subtypes must honour their supertype's contract so substitution never surprises a caller (LSP).

01 Open for extension, closed for modification 19 min 02 Polymorphism over conditionals 19 min 03 Liskov substitution 19 min 04 Designing and honoring contracts 20 min

ISP & Dependency Inversion

Keep interfaces narrow so no client depends on methods it doesn't use (ISP), and make high-level policy depend on abstractions it owns rather than on low-level detail (DIP). Ports, adapters, and DI are the mechanics.

01 Interface segregation 19 min 02 Dependency inversion 20 min 03 Ports and adapters 20 min 04 Dependency injection in TypeScript 20 min

Coupling & cohesion, deep

Coupling has a measurable taxonomy (connascence): refactor toward weaker, more local coupling. The Law of Demeter and feature-based module boundaries confine the blast radius of change.

01 Connascence 20 min 02 The Law of Demeter 19 min 03 Drawing module boundaries 20 min

Smells: bloaters

Bloater smells — long methods, large classes, primitive obsession, data clumps — are cohesion decay you fix by extraction and value objects. Divergent change and shotgun surgery are the SRP smells you read off the git history.

01 Long method, large class 19 min 02 Primitive obsession & data clumps 19 min 03 Divergent change & shotgun surgery 20 min

Smells: couplers & dispensables

Coupler and dispensable smells — feature envy, message chains, middle men, dead code, speculative generality, type switches — bind or bloat code. Move behaviour to its data, delete the unused, and replace growing switches with polymorphism.

01 Feature envy & inappropriate intimacy 20 min 02 Message chains & middle man 20 min 03 Dead code & speculative generality 18 min 04 Type switches & refused bequest 19 min

Refactoring: the safety net

You can't refactor safely without a net. Characterization tests pin current behaviour, seams get stubborn code under test, and the catalogue of small moves is applied one tiny step at a time under green.

01 Characterization tests 20 min 02 Seams 19 min 03 Core moves under green 19 min

Refactoring: larger moves

Larger refactorings — extract class, replace conditional with polymorphism, introduce parameter object — restructure design under green tests; patterns are destinations you refactor toward when the code demands them, not templates imposed up front.

01 Extract class 20 min 02 Replace conditional with polymorphism 20 min 03 Introduce parameter object 19 min 04 Refactoring toward patterns 20 min

Heuristics & tradeoffs

DRY, KISS, and YAGNI are heuristics that conflict, and judgment is choosing which dominates. The rule of three resists premature abstraction, because duplication is far cheaper than the wrong abstraction.

01 DRY, KISS, YAGNI in tension 20 min 02 The rule of three 19 min 03 The wrong abstraction 19 min

Anti-patterns & technical debt

God objects and anemic domains are structural anti-patterns to balance against; technical debt is real but financeable — make it visible, take it prudently, and pay it down via the boy-scout rule in code you already touch.

01 God object & anemic domain model 20 min 02 The technical debt quadrant 19 min 03 Legacy code & the boy-scout rule 20 min

Capstone: refactor a messy module

Put it together on a realistic messy module: inventory the smells, refactor incrementally under characterization tests, and measure that the next change got cheaper — closing the loop back to the cost-of-change lens.

01 Capstone I: the smell inventory 20 min 02 Capstone II: the incremental refactor 21 min 03 Capstone III: measure before and after 20 min

Next track

React patterns, senior

You can already build with React — now learn the patterns seniors reach for: composition, state architecture, the server/client boundary, Suspense, and the anti-patterns to refactor away, so components stay simple as they scale.