1. PART I Introduction
2. Chapter 1 What Is Design and Architecture?
3. The Goal?
4. Case Study
5. Conclusion
6. Chapter 2 A Tale of Two Values
7. Behavior
8. Architecture
9. The Greater Value
10. Eisenhower’s Matrix
11. Fight for the Architecture
12. PART II Starting with the Bricks: Programming Paradigms
13. Chapter 3 Paradigm Overview
14. Structured Programming
15. Object-Oriented Programming
16. Functional Programming
17. Food for Thought
18. Conclusion
19. Chapter 4 Structured Programming
20. Proof
21. A Harmful Proclamation
22. Functional Decomposition
23. No Formal Proofs
24. Science to the Rescue
25. Tests
26. Conclusion
27. Chapter 5 Object-Oriented Programming
28. Encapsulation?
29. Inheritance?
30. Polymorphism?
31. Conclusion
32. Chapter 6 Functional Programming
33. Squares of Integers
34. Immutability and Architecture
35. Segregation of Mutability
36. Event Sourcing
37. Conclusion
38. PART III Design Principles
39. Chapter 7 SRP: The Single Responsibility Principle
40. Symptom 1: Accidental Duplication
41. Symptom 2: Merges
42. Solutions
43. Conclusion
44. Chapter 8 OCP: The Open-Closed Principle
45. A Thought Experiment
46. Directional Control
47. Information Hiding
48. Conclusion
49. Chapter 9 LSP: The Liskov Substitution Principle
50. Guiding the Use of Inheritance
51. The Square/Rectangle Problem
52. LSP and Architecture
53. Example LSP Violation
54. Conclusion
55. Chapter 10 ISP: The Interface Segregation Principle
56. ISP and Language
57. ISP and Architecture
58. Conclusion
59. Chapter 11 DIP: The Dependency Inversion Principle
60. Stable Abstractions
61. Factories
62. Concrete Components
63. Conclusion
64. PART IV Component Principles
65. Chapter 12 Components
66. A Brief History of Components
67. Relocatability
68. Linkers
69. Conclusion
70. Chapter 13 Component Cohesion
71. The Reuse/Release Equivalence Principle
72. The Common Closure Principle
73. The Common Reuse Principle
74. The Tension Diagram for Component Cohesion
75. Conclusion
76. Chapter 14 Component Coupling
77. The Acyclic Dependencies Principle
78. Top-Down Design
79. The Stable Dependencies Principle
80. The Stable Abstractions Principle
81. Conclusion
82. PART V Architecture
83. Chapter 15 What Is Architecture?
84. Development
85. Deployment
86. Operation
87. Maintenance
88. Keeping Options Open
89. Device Independence
90. Junk Mail
91. Physical Addressing
92. Conclusion
93. Chapter 16 Independence
94. Use Cases
95. Operation
96. Development
97. Deployment
98. Leaving Options Open
99. Decoupling Layers
100. Decoupling Use Cases
101. Decoupling Mode
102. Independent Develop-ability
103. Independent Deployability
104. Duplication
105. Decoupling Modes (Again)
106. Conclusion
107. Chapter 17 Boundaries: Drawing Lines
108. A Couple of Sad Stories
109. FitNesse
110. Which Lines Do You Draw, and When Do You Draw Them?
111. What About Input and Output?
112. Plugin Architecture
113. The Plugin Argument
114. Conclusion
115. Chapter 18 Boundary Anatomy
116. Boundary Crossing
117. The Dreaded Monolith
118. Deployment Components
119. Threads
120. Local Processes
121. Services
122. Conclusion
123. Chapter 19 Policy and Level
124. Level
125. Conclusion
126. Chapter 20 Business Rules
127. Entities
128. Use Cases
129. Request and Response Models
130. Conclusion
131. Chapter 21 Screaming Architecture
132. The Theme of an Architecture
133. The Purpose of an Architecture
134. But What About the Web?
135. Frameworks Are Tools, Not Ways of Life
136. Testable Architectures
137. Conclusion
138. Chapter 22 The Clean Architecture
139. The Dependency Rule
140. A Typical Scenario
141. Conclusion
142. Chapter 23 Presenters and Humble Objects
143. The Humble Object Pattern
144. Presenters and Views
145. Testing and Architecture
146. Database Gateways
147. Data Mappers
148. Service Listeners
149. Conclusion
150. Chapter 24 Partial Boundaries
151. Skip the Last Step
152. One-Dimensional Boundaries
153. Facades
154. Conclusion
155. Chapter 25 Layers and Boundaries
156. Hunt the Wumpus
157. Clean Architecture?
158. Crossing the Streams
159. Splitting the Streams
160. Conclusion
161. Chapter 26 The Main Component
162. The Ultimate Detail
163. Conclusion
164. Chapter 27 Services: Great and Small
165. Service Architecture?
166. Service Benefits?
167. The Kitty Problem
168. Objects to the Rescue
169. Component-Based Services
170. Cross-Cutting Concerns
171. Conclusion
172. Chapter 28 The Test Boundary
173. Tests as System Components
174. Design for Testability
175. The Testing API
176. Conclusion
177. Chapter 29 Clean Embedded Architecture
178. App-titude Test
179. The Target-Hardware Bottleneck
180. Conclusion
181. PART VI Details
182. Chapter 30 The Database Is a Detail
183. Relational Databases
184. Why Are Database Systems So Prevalent?
185. What If There Were No Disk?
186. Details
187. But What about Performance?
188. Anecdote
189. Conclusion
190. Chapter 31 The Web Is a Detail
191. The Endless Pendulum
192. The Upshot
193. Conclusion
194. Chapter 32 Frameworks Are Details
195. Framework Authors
196. Asymmetric Marriage
197. The Risks
198. The Solution
199. I Now Pronounce You …
200. Conclusion
201. Chapter 33 Case Study: Video Sales
202. The Product
203. Use Case Analysis
204. Component Architecture
205. Dependency Management
206. Conclusion
207. Chapter 34 The Missing Chapter
208. Package by Layer
209. Package by Feature
210. Ports and Adapters
211. Package by Component
212. The Devil Is in the Implementation Details
213. Organization versus Encapsulation
214. Other Decoupling Modes
215. Conclusion: The Missing Advice
216. PART VII Appendix
217. Appendix A Architecture Archaeology
218. Index