Facebook
From Flying Parrot, 2 Years ago, written in Plain Text.
Embed
Download Paste or View Raw
Hits: 232
  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