Goal
Make good design a reflex rather than an aspiration: code driven by tests, improved by safe refactoring, structured so the domain stays independent of its plumbing. This is the path where the architect's judgment is actually formed — every pattern here is learned by writing the code, feeling the friction it removes (or adds), and forming an opinion with evidence. It runs on katas deliberately: small enough to repeat, sharp enough to change how you work.
Prerequisites
- Foundations module 3 (algorithms) and at least one deep language from Language craft to practice in.
Modules
1. Test-driven
- Read: TDD and BDD.
- Do: the TDD note's kata ladder — classic katas red/green/refactored until the rhythm is unconscious; one feature driven outside-in with Given/When/Then.
- Proof: a screencast-able kata run where the test always moves first and commits are minutes apart.
2. Refactoring & clean code
- Read: Refactoring techniques and Clean code.
- Do: Gilded Rose — legacy rescue.
- Proof: golden master pinned before touching anything; conjured items shipped on the cleaned design; every transformation traceable to a named refactoring.
3. Patterns, read critically
- Read: Design patterns.
- Do: the note's drills — spot patterns in a real codebase; refactor one pattern-shaped mess away from its pattern.
- Proof: you can argue which GoF patterns your language dissolved, with examples.
4. Ports & adapters
- Read: Hexagonal architecture and Coupling & cohesion — the forces the pattern manages.
- Do: Birthday Greetings — hexagonal extraction.
- Proof: the domain compiles with no infrastructure imports; the adapter swap per the subject proves the boundary holds.
5. Domain-driven
- Read: DDD.
- Do: the note's practice — model a familiar domain's bounded contexts and ubiquitous language; event-storm a process you know end to end.
- Proof: a context map another engineer can navigate without you in the room.
6. CQRS & event sourcing, priced honestly
- Read: CQRS & event sourcing.
- Do: Event-sourced bank account.
- Proof: the subject's consistency requirements met, plus a paragraph on when you would not use event sourcing — the exercise's real deliverable.
7. Testing as strategy
- Read: Testing strategies.
- Do: apply deliberately on the module-4/6 builds — contract tests at the ports, a property-based suite where inputs are generatable.
- Proof: a test suite whose shape you can justify layer by layer — what each level catches and what it deliberately doesn't.
Related
- The path to excellence — the master path; Stage 2's core.
- Language craft — the languages this discipline is practiced in.
- Full-stack web — its capstone is this path at product scale.
- Architect & lead — where design judgment becomes design leadership.
- Theme drawn on: Applicative Architecture.