Book-Reader-Assist/library/FOCUS Architecture/Front-Matter/Front-Matter-source-text.md

FOCUS Architecture — Front-Matter: Front matter

• Source: /library/FOCUS Architecture/source-file.pdf
• PDF pages: 1–12
• Pages without text: 1

---

FOCUS: Architecture for People Who Ship Software J.C. Ködel

FOCUS: Architecture for People Who Ship Software

1. About the Author
2. The F12 test
3. The price of too many layers
4. The price of too few layers
5. Four pieces
6. Why now
7. Who looks for the rule now
8. Rosie’s Coffee Shop
9. Quick reference
10. Map of the trilogy
11. What each volume answers
12. Where this book fits
13. The Day One Line Change Broke Three Screens
14. The screen that started out reasonable
15. Coupling
16. Cohesion, the other side of the coin
17. The axis of change
18. Pitfalls
19. Quick reference
20. Exercises

1. AI Writes Fast. So What?
2. The twelve-minute coupon
3. The GitClear yardstick
4. Why the generator fails this way
5. Three guardrails against the same bug
6. So is AI the problem?
7. Pitfalls
8. Quick reference
9. Exercises
10. Simplicity Is a Decision: KISS and YAGNI
11. The engine nobody asked for
12. The four costs
13. Where the acronyms came from
14. The six lines the menu asks for
15. What YAGNI doesn’t cut
16. And when the need finally arrives?
17. Pitfalls
18. Quick reference
19. Exercises
20. DRY Isn’t About Code
21. Extraction by reflex
22. What Hunt and Thomas actually wrote
23. The inverse case: the card reader fee
24. Timing tools
25. The same knowledge outside the code
26. The critique: DRY as a coupling factory
27. Pitfalls

1. Quick reference
2. Exercises
3. SOLID Without Dogma
4. One tab, four bosses
5. Slice by actor, not by verb
6. Read the code through the OCP and LSP lenses
7. Narrow the contract and flip the arrow
8. What each principle charges whoever is looking
9. The cost of carrying what doesn’t matter
10. How many things you hold at once
11. The critique SOLID earned
12. Pitfalls
13. Quick reference
14. Exercises
15. Pure Functions and Immutability
16. Two totals for the same tab
17. Purity is what a function doesn’t do
18. Swap the call for the returned value
19. Freeze the data: immutability across ten languages
20. Functional core, imperative shell
21. Pitfalls
22. Quick reference
23. Exercises
24. Errors Are Values
25. The payment that only said “Something went wrong”
26. Expected error is not a defect

1. The failure becomes part of the return type
2. Three steps, two rails
3. Go’s counterpoint
4. Exceptions only at the boundary
5. Pitfalls
6. Quick reference
7. Exercises
8. Explicit Dependencies: DI and the Composition Root
9. The payment that fetched its own dependencies
10. Dependencies move up to the constructor
11. If nobody calls the locator, who builds the graph?
12. Pure DI before any container
13. The Python counterpoint: discipline instead of syntax
14. DI for the boundary, data for the rest
15. Pitfalls
16. Quick reference
17. Exercises
18. FOCUS in One Page
19. The handler that did everything
20. The path of a tap
21. The four pieces in the same gesture
22. The same slice in your language
23. Why just four
24. The recipe the orchestrator follows
25. Pitfalls
26. Quick reference
27. Exercises

1. Features, Not Layers
2. The change that touched four folders
3. The axis of change
4. The coffee shop in slices
5. Why it isn’t four folders
6. The whole slice at once
7. What the imports give away
8. The same slice in ten languages
9. shared/ is born empty
10. Pitfalls
11. Quick reference
12. Exercises
13. The View: Dumb by Design
14. The screen that calculates
15. The state that arrives ready
16. The same screen, now dumb
17. Does this belong in the View?
18. The critique: bloated state
19. Pitfalls
20. Quick reference
21. Exercises
22. The Orchestrator: Event In, State Out
23. Where the one-way flow came from
24. The anti-solution: the orchestrator that decides
25. Events and states as sealed classes
26. The complete orchestrator
27. Go’s counterpoint: no unions, no billing

1. The flow test: event on top, states below
2. Transient context and persistent context
3. The criticism: boilerplate and rules in the reducer
4. Pitfalls
5. Quick reference
6. Exercises
7. Use Cases: Where the Rules Live
8. The anti-solution: the same rule in three places
9. The rule as a pure function: the signature first
10. The same rule, ten languages
11. Orchestrator fetches, use case decides
12. The use case as a retrieval unit
13. Testing without a single test double
14. The critique: “where’s the use case’s interface?”
15. Pitfalls
16. Quick reference
17. Exercises
18. Repositories: The Exception Boundary
19. The anti-solution: the copied catch in every screen
20. The repository’s contract comes before its body
21. The single translation: one catch, and only one
22. The lookup feeding the orchestrator
23. The same boundary in ten languages
24. Where reading can stop
25. Contracts that age slowly
26. The critique: the generic repository and “the ORM already does this”

1. Preview of the fake: the interface you’ll thank in chapter 17
2. Pitfalls
3. Quick reference
4. Exercises
5. Commands and Queries: CQS Without Ceremony
6. The anti-solution: paying and asking in the same gesture
7. CQS: Meyer’s rule
8. The split, in all ten languages
9. The canonical table’s two tracks
10. From CQS to CQRS, and where FOCUS stops
11. Classify the eight operations
12. Pitfalls
13. Quick reference
14. Exercises
15. Test Each Piece the Way It Asks to Be Tested
16. The anti-solution: the suite that asserts the how
17. Use case: a pure test, no double at all
18. Repository: the fake you already have
19. Orchestrator: flow test
20. View and integration: where each one pays its own cost
21. The two critiques
22. Pitfalls
23. Quick reference
24. Exercises
25. What to Do When the Language Doesn’t Help
26. The slice on the board

1. Types first: four families and one warning
2. The three anchors, family by family
3. When the language doesn’t help
4. The critiques, with a ruler instead of rhetoric
5. The equivalence table: porting to the 11th language
6. Pitfalls
7. Quick reference
8. Exercises
9. Anti-Patterns: How to Wreck FOCUS
10. The shape of the card
11. Card 1: business rule in the orchestrator
12. Card 2: use case that hits the database
13. Card 3: generic repository
14. Card 4: layer by ceremony
15. Card 5: domain try/catch
16. Card 6: premature shared/
17. What Go won’t let you do
18. Pitfalls
19. Quick reference
20. Exercises
21. Migrate Legacy Code Without Stopping the Factory
22. The fig that strangles
23. Choose the first slice: frequency times pain
24. Step 1: fence the behavior with a characterization test
25. Step 2: extract the rule into a pure use case
26. Step 3: wrap the legacy in an adapter
27. Step 4: wire the new view to the orchestrator

1. When NOT to migrate
2. Both worlds on the same counter
3. Pitfalls
4. Quick reference
5. Exercises
6. FOCUS + AI: The Duo That Scales
7. The one-sentence request
8. Each piece against a number
9. The spec says what, the architecture says where
10. Anatomy of the architectural prompt
11. The same feature under the prompt
12. Slice-guided review
13. Two criticisms I take seriously
14. Pitfalls
15. Quick reference
16. Exercises
17. Architecture for humans and for models
18. The pattern nobody designed on purpose
19. The name for this
20. The question left over
21. Build Rosie’s App
22. The focus-coffee repository
23. Menu: the read-only slice
24. Tab: the slice with a lifecycle
25. Payment: the slice of errors
26. Loyalty: the rule, and the first shared/

1. Porting roadmap
2. The critique: “book examples always work”
3. Pitfalls
4. Quick reference
5. Exercises
6. Ship Increments Without Chaos
7. FOCUS in a hallway conversation
8. Who benefits (and it’s a single reason)
9. The ruler against drift
10. Quick reference
11. Exercises