.

0 (hodnocen0 x )

(2) Půjčeno:4x 

BK

Příručka

Boston : Prentice Hall, [2018]

xxv, 404 stran : ilustrace ; 24 cm

ISBN 978-0-13-449416-6 (brožováno)

Robert C. Martin series

Obsahuje rejstřík

001463443

Contents // Foreword xv // Preface xix // Acknowledgments xxiii // About the Author xxv // PART I Introduction I // Chapter I What Is Design and Architecture? 3 // The Goal? 4 // Case Study 5 // Conclusion 12 // Chapter 2 A Tale of Two Values 13 // Behavior 14 // Architecture 14 // The Greater Value 15 // Eisenhower’s Matrix 16 // Fight for the Architecture 18 // « 0 // VII // Contents // PART II Starting with the Bricks: Programming Paradigms 19 // Chapter 3 Paradigm Overview 21 // Structured Programming 22 // Object-Oriented Programming 22 // Functional Programming 22 // Food for Thought 23 // Conclusion 24 // Chapter 4 Structured Programming 25 // Proof 27 // A Harmful Proclamation 28 // Functional Decomposition 29 // No Formal Proofs 30 // Science to the Rescue 30 // Tests 31 // Conclusion 31 // Chapter 5 Object-Oriented Programming 33 // Encapsulation? 34 // Inheritance? 37 // Polymorphism? 40 // Conclusion 47 // Chapter 6 Functional Programming 49 // Squares of Integers 50 // Immutability and Architecture 52 // Segregation of Mutability 52 // Event Sourcing 54 // Conclusion 56 // PART III Design Principles 57 // Chapter 7 SRP: The Single Responsibility Principle 61 // Symptom 1: Accidental Duplication 63 // Symptom 2: Merges 65 // Solutions 66 // Conclusion 67 // Vili // ??? // Contents // Chapter 8 OCR: The Open-Closed Principle 69 // A Thought Experiment 70 // Directional Control 74 // Information Hiding 74 // Conclusion 75 // Chapter 9 LSP: The Liskov

Substitution Principle 77 // Guiding the Use of Inheritance 78 // The Square/Rectangle Problem 79 // LSP and Architecture 80 // Example LSP Violation 80 // Conclusion 82 // Chapter 10 ISP: The Interface Segregation Principle 83 // ISP and Language 85 // ISP and Architecture 86 // Conclusion 86 // Chapter 1 1 DIP: The Dependency Inversion Principle 87 // Stable Abstractions 88 // Factories 89 // Concrete Components 91 // Conclusion 91 // PART IV Component Principles 93 // Chapter 12 Components 95 // A Brief History of Components 96 // Relocatability 99 // Linkers 100 // Conclusion 102 // Chapter 13 Component Cohesion 103 // The Reuse/Release Equivalence Principle 104 // The Common Closure Principle 105 // The Common Reuse Principle 107 // The Tension Diagram for Component Cohesion 108 // Conclusion 110 // ix // Contents // ??? // Chapter 14 Component Coupling III // The Acyclic Dependencies Principle 112 // Top-Down Design 118 // The Stable Dependencies Principle 120 // The Stable Abstractions Principle 126 // Conclusion 132 // PART V Architecture 133 // Chapter 15 What Is Architecture? 135 // Development 137 // Deployment 138 // Operation 138 // Maintenance 139 // Keeping Options Open 140 // . Device Independence 142 // Junk Mail 144 // Physical Addressing 145 // Conclusion 146 // Chapter 16 Independence 147 // Use Cases 148 // Operation 149 // Development 149 // Deployment 150 // Leaving Options Open 150 // Decoupling Layers 151 // Decoupling Use Cases 152 // Decoupling Mode

153 // Independent Develop-ability 153 // Independent Deployability 154 // Duplication 154 // Decoupling Modes (Again) 155 // Conclusion 158 // ?? // 1??? // X // Contents // // Chapter 17 Boundaries: Drawing Lines 159 // A Couple of Sad Stories 160 // FitNesse 163 // Which Lines Do You Draw, and When Do You Draw Them? 165 // What About Input and Output? 169 // Plugin Architecture 170 // The Plugin Argument 172 // Conclusion 173 // Chapter 18 Boundary Anatomy 175 // Boundary Crossing 176 // The Dreaded Monolith 176 // Deployment Components 178 // Threads 179 // Local Processes 179 // Services 180 // Conclusion 181 // Chapter 19 Policy and Level 183 // Level 184 // Conclusion 187 // Chapter 20 Business Rules 189 // Entities 190 // Use Cases 191 // Request and Response Models 193 // Conclusion 194 // Chapter 21 Screaming Architecture 195 // The Theme of an Architecture 196 // The Purpose of an Architecture 197 // But What About the Web? 197 // Frameworks Are Tools, Not Ways of Life 198 // Testable Architectures 198 // Conclusion 199 // // xi // Contents // Chapter 22 The Clean Architecture 201 // The Dependency Rule 203 // A Typical Scenario 207 // Conclusion 209 // Chapter 23 Presenters and Humble Objects 211 // The Humble Object Pattern 212 // Presenters and Views 212 // Testing and Architecture 213 // Database Gateways 214 // Data Mappers 214 // Service Listeners 215 // Conclusion 215 // Chapter 24 Partial Boundaries 217

// Skip the Last Step 218 // One-Dimensional Boundaries 219 // Facades 220 // Conclusion 220 // Chapter 25 Layers and Boundaries 221 // Hunt the Wumpus 222 // Clean Architecture? 223 // Crossing the Streams 226 // Splitting the Streams 227 // Conclusion 228 // Chapter 26 The Main Component 231 // The Ultimate Detail 232 // Conclusion 237 // Chapter 27 Services: Great and Small 239 // Service Architecture? 240 // Service Benefits? 240 // The Kitty Problem 242 // Objects to the Rescue 244 // ??? // xii // Contents // Component-Based Services 245 // Cross-Cutting Concerns 246 // Conclusion 247 // Chapter 28 The Test Boundary 249 // Tests as System Components 250 // Design for Testability 251 // The Testing API 252 // Conclusion 253 // Chapter 29 Clean Embedded Architecture 255 // App-titude Test 258 // The Target-Hardware Bottleneck 261 // Conclusion 273 // PART VI Details 275 // Chapter 30 The Database Is a Detail 277 // Relational Databases 278 // Why Are Database Systems So Prevalent? 279 // What If There Were No Disk? 280 // Details 281 // But What about Performance? 281 // Anecdote 281 // Conclusion 283 // Chapter 3 1 The Web Is a Detail 285 // The Endless Pendulum 286 // The Upshot 288 // Conclusion 289 // Chapter 32 Frameworks Are Details 291 // Framework Authors 292 // Asymmetric Marriage 292 // The Risks 293 // The Solution 294 // XiSl // // Contents // I Now Pronounce You ... 295 // Conclusion 295 // Chapter 33 Case Study: Video Sales 297 // The Product 298 // Use Case

Analysis 298 // Component Architecture 300 // Dependency Management 302 // Conclusion 302 // Chapter 34 The Missing Chapter 303 // Package by Layer 304 // Package by Feature 306 // Ports and Adapters 308 // Package by Component 310 // The Devil Is in the Implementation Details 315 // Organization versus Encapsulation 316 // Other Decoupling Modes 319 // Conclusion: The Missing Advice 321 // Afterword 323 // PART VII Appendix 327 // Appendix A Architecture Archaeology 329 // Index 379