Completing Object Orientation

Dedication

Prelude — Uneducation, diskarte, and patterns

Prologue — Why I wrote this book

1. How I found MVC and DCI
2. What this book covers
3. How to use this book

Part I — History

Chapter 1 — Smalltalk, PARC, and Thing–Model–View–Editor → MVC

1. Roadmap
2. 1. Design before code
3. 2. Smalltalk, PARC, and MVC (1978–79)
4. 3. What MVC leaves open
5. Takeaways

Chapter 2 — Roles before DCI: OOram, then Data–Context–Interaction

1. Roadmap
2. 1. OOram: roles after MVC
3. 2. DCI: Data, Context, Interaction
4. 3. Coplien’s bridges—and the Rails path
5. Takeaways

Part II — Foundations

Chapter 3 — Mental models: what the system is vs what it does

1. Roadmap
2. 1. Class-oriented vs object-oriented
3. 2. Dual mental models
4. 3. Runnable contrast
5. Takeaways

Chapter 4 — Basic collaboration patterns that matter

1. Roadmap
2. 1. Four patterns that foreshadow roles
3. 2. Composition over inheritance
4. 3. The honest limit
5. Takeaways

Chapter 5 — Use cases, algorithms, and roles

1. Roadmap
2. 1. Theatre and cue scripts
3. 2. Money Transfer as a Context
4. 3. UML binders vs readable code
5. Takeaways

Part III — The MVC family

Chapter 6 — Original MVC in practice

1. Roadmap
2. 1. MVC bridges to the user’s data model
3. 2. A tiny MVC loop
4. 3. What MVC refuses to own
5. Takeaways

Chapter 7 — How “MVC” mutated on the web

1. Roadmap
2. 1. Why the word drifted
3. 2. Fat controller, fat model
4. 3. Service object → Context
5. Takeaways

Chapter 8 — Action–Domain–Responder (ADR)

1. Roadmap
2. 1. Why ADR
3. 2. Transfer in ADR shape
4. 3. Rails and the DCI handoff
5. Takeaways

Chapter 9 — MVP (Potel / Taligent, 1996)

1. Roadmap
2. 1. Passive View
3. 2. Transfer Presenter (UI only)
4. 3. Keep Presenters at the glass
5. Takeaways

Chapter 10 — MVVM (Gossman / Microsoft, 2005)

1. Roadmap
2. 1. ViewModel
3. 2. TransferViewModel
4. 3. Roles stay out of the VM
5. Takeaways

Chapter 11 — Coordinators and MVVM-C

1. Roadmap
2. 1. Navigation leaves the ViewModel
3. 2. Flow vs Interaction
4. 3. Checklist
5. Takeaways

Chapter 12 — MVI and The Elm Architecture (TEA)

1. Roadmap
2. 1. One-way UI
3. 2. Transfer form as UI state
4. 3. Sister pattern, not a rival
5. Takeaways

Chapter 13 — VIPER and Clean-inspired mobile splits

1. Roadmap
2. 1. Five parts
3. 2. Transfer in VIPER shape
4. 3. Decision notes
5. Takeaways

Chapter 14 — Choosing in the MV* family

1. Roadmap
2. 1. Selection matrix
3. 2. One Context, three shells
4. 3. Toward Part IV
5. Takeaways

Part IV — Complex application architectures

Chapter 15 — Domain-Driven Design

1. Roadmap
2. 1. What DDD already solves
3. 2. Transfer across aggregates
4. 3. Language alignment
5. Takeaways

Chapter 16 — Hexagonal, Onion, and Clean Architecture

1. Roadmap
2. 1. Inward dependencies
3. 2. Ports deliver players into a Context
4. 3. Interactors versus Contexts
5. Takeaways

Chapter 17 — CQRS and Event Sourcing

1. Roadmap
2. 1. Separate write and read
3. 2. Context on the command side
4. 3. Replay and limits
5. Takeaways

Chapter 18 — The actor model

1. Roadmap
2. 1. Message passing
3. 2. In-process actors with a Context
4. 3. Systems vs process-local actors
5. Takeaways

Chapter 19 — Entity–Component–System

1. Roadmap
2. 1. Data-oriented loops
3. 2. ECS-shaped balances
4. 3. When to choose which
5. Takeaways

Part V — Exotic and adjacent

Chapter 20 — Naked Objects, PAC, HMVC

1. Roadmap
2. 1. Naked Objects
3. 2. PAC and HMVC
4. 3. Auto-UI Account vs Transfer Context
5. Takeaways

Chapter 21 — Traits, aspects, subject-oriented, Qi4j

1. Roadmap
2. 1. Injection embeddings
3. 2. Mixin-style Transfer
4. 3. Where AOP and Qi4j fit
5. Takeaways

Chapter 22 — Steelman the critics: Hickey and data-first design

1. Roadmap
2. 1. Data-first cousins
3. 2. What Hickey actually argues
4. 3. Where Hickey and DCI already agree
5. 4. Where they part—and a fair comparison
6. Takeaways

Part VI — DCI, then agents

Chapter 23 — DCI in depth: Data, Context, Interaction

1. Roadmap
2. 1. Responsibilities, lifecycle, identity
3. 2. Full Money Transfer
4. 3. Testing and failure modes
5. Takeaways

Chapter 24 — DCI by Example

1. Roadmap
2. 1. The recipe
3. 2. Library loan
4. 3. Checkout
5. 4. Dijkstra
6. What the three examples share
7. Takeaways

Chapter 25 — From a fat Rails model to a Context

1. Roadmap
2. 1. Before
3. 2. Pin the behavior
4. 3. Move the body, unchanged
5. 4. Name the roles
6. 5. The controller, and the next rule
7. Takeaways

Chapter 26 — Why DCI fits: completing MVC

1. Roadmap
2. 1. Completing the pair
3. 2. Screen gesture → Context
4. 3. What DCI is not—and a brownfield path
5. Takeaways

Chapter 27 — DCI against the whole map

1. Roadmap
2. 1. Layer cake
3. 2. Decision cookbook
4. 3. One-page checklist
5. Takeaways

Chapter 28 — DCI and AI agents

1. Roadmap
2. 1. Where the model sits
3. 2. A runnable agent Context
4. 3. Contexts as config
5. Takeaways

Chapter 29 — Epilogue: habitability

1. Roadmap
2. 1. Habitability
3. 2. Closing—don’t worship the book

Sources and further reading

1. Primary
2. Also cited