Clean Architecture: A Craftsman's Guide to Software Structure and Design

Inhaltsverzeichnis



Foreword xv


Preface xix


Acknowledgments xxiii


About the Author xxv


 



Part I: Introduction 1


 


Chapter 1: 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


 



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


 


Chapter 8: OCP: 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 11: 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


 


Chapter 14: Component Coupling 111


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


 


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


 


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


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 31: 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


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


 



Part VII: Appendix 323




Appendix A Architecture Archaeology 325


 


Index 375


Clean Architecture: A Craftsman's Guide to Software Structure and Design

A Craftsman's Guide to Software Structure and Design

Buch (Taschenbuch, Englisch)

30,99 €

inkl. gesetzl. MwSt.
Taschenbuch

Taschenbuch

30,99 €

Clean Architecture: A Craftsman's Guide to Software Structure and Design

Ebenfalls verfügbar als:

Taschenbuch

Taschenbuch

ab 30,99 €
eBook

eBook

ab 23,99 €

Beschreibung

Details

Verkaufsrang

12165

Einband

Taschenbuch

Erscheinungsdatum

10.09.2017

Verlag

Pearson Education Limited

Seitenzahl

432

Beschreibung

Details

Verkaufsrang

12165

Einband

Taschenbuch

Erscheinungsdatum

10.09.2017

Verlag

Pearson Education Limited

Seitenzahl

432

Maße (L/B/H)

23,1/18,3/2 cm

Gewicht

656 g

Auflage

1

Sprache

Englisch

ISBN

978-0-13-449416-6

Unsere Kundinnen und Kunden meinen

0.0

0 Bewertungen

Informationen zu Bewertungen

Zur Abgabe einer Bewertung ist eine Anmeldung im Konto notwendig. Die Authentizität der Bewertungen wird von uns nicht überprüft. Wir behalten uns vor, Bewertungstexte, die unseren Richtlinien widersprechen, entsprechend zu kürzen oder zu löschen.

Verfassen Sie die erste Bewertung zu diesem Artikel

Helfen Sie anderen Kund*innen durch Ihre Meinung

Erste Bewertung verfassen

Unsere Kundinnen und Kunden meinen

0.0

0 Bewertungen filtern

Die Leseprobe wird geladen.
  • Clean Architecture: A Craftsman's Guide to Software Structure and Design


  • Foreword xv


    Preface xix


    Acknowledgments xxiii


    About the Author xxv


     



    Part I: Introduction 1


     


    Chapter 1: 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


     



    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


     


    Chapter 8: OCP: 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 11: 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


     


    Chapter 14: Component Coupling 111


    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


     


    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


     


    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


    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 31: 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


    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


     



    Part VII: Appendix 323




    Appendix A Architecture Archaeology 325


     


    Index 375