Robert C. Martin

Clean Architecture

A Craftsman's Guide to Software Structure and Design


1. Auflage
Erscheinungsjahr: 2017
Print-ISBN: 978-0-13-449416-6
E-ISBN: 978-0-13-449433-3

Sprache: Englisch






Zusammenfassung

Practical Software Architecture Solutions from the Legendary Robert C. Martin (“Uncle Bob”). By applying universal rules of software architecture, you can dramatically improve developer productivity throughout the life of any software system. Now, building upon the success of his best-selling books "Clean Code" and "The Clean Coder" legendary software craftsman Robert C. Martin (“Uncle Bob”) reveals those rules and helps you apply them.
Martin’s "Clean Architecture" doesn’t merely present options. Drawing on over a half-century of experience in software environments of every imaginable type, Martin tells you what choices to make and why they are critical to your success. As you’ve come to expect from Uncle Bob, this book is packed with direct, no-nonsense solutions for the real challenges you’ll face–the ones that will make or break your projects.

  • Learn what software architects need to achieve–and core disciplines and practices for achieving it.
  • Master essential software design principles for addressing function, component separation, and data management
  • See how programming paradigms impose discipline by restricting what developers can do
  • Understand what’s critically important and what’s merely a “detail”
  • Implement optimal, high-level structures for web, database, thick-client, console, and embedded applications
  • Define appropriate boundaries and layers, and organize components and services
  • See why designs and architectures go wrong, and how to prevent (or fix) these failures

"Clean Architecture" is essential reading for every current or aspiring software architect, systems analyst, system designer, and software manager–and for every programmer who must execute someone else’s designs.

Inhaltsverzeichnis

  • Cover
    1
    -
    1
  • Half Title
    1
    -
    3
  • Title Page
    3
    -
    4
  • Copyright Page
    4
    -
    5
  • Dedication
    5
    -
    7
  • Contents
    7
    -
    15
  • Foreword
    15
    -
    19
  • Preface
    19
    -
    23
  • Acknowledgments
    23
    -
    25
  • About the Author
    25
    -
    27
  • +
    PART I: Introduction
    27
    -
    45

    • +
      Chapter 1 What Is Design and Architecture?
      29
      -
      39

      • The Goal?
        30
        -
        31
      • Case Study
        31
        -
        38
      • Conclusion
        38
        -
        39
    • +
      Chapter 2 A Tale of Two Values
      39
      -
      44

      • Behavior
        40
        -
        40
      • Architecture
        40
        -
        41
      • The Greater Value
        41
        -
        42
      • Eisenhower’s Matrix
        42
        -
        44
      • Fight for the Architecture
        44
        -
        45
  • +
    PART II: Starting with the Bricks: Programming Paradigms
    45
    -
    83

    • +
      Chapter 3 Paradigm Overview
      47
      -
      51

      • Structured Programming
        48
        -
        48
      • Object-Oriented Programming
        48
        -
        48
      • Functional Programming
        48
        -
        49
      • Food for Thought
        49
        -
        50
      • Conclusion
        50
        -
        51
    • +
      Chapter 4 Structured Programming
      51
      -
      59

      • Proof
        53
        -
        54
      • A Harmful Proclamation
        54
        -
        55
      • Functional Decomposition
        55
        -
        56
      • No Formal Proofs
        56
        -
        56
      • Science to the Rescue
        56
        -
        57
      • Tests
        57
        -
        57
      • Conclusion
        57
        -
        59
    • +
      Chapter 5 Object-Oriented Programming
      59
      -
      75

      • Encapsulation?
        60
        -
        63
      • Inheritance?
        63
        -
        66
      • Polymorphism?
        66
        -
        73
      • Conclusion
        73
        -
        75
    • +
      Chapter 6 Functional Programming
      75
      -
      82

      • Squares of Integers
        76
        -
        78
      • Immutability and Architecture
        78
        -
        78
      • Segregation of Mutability
        78
        -
        80
      • Event Sourcing
        80
        -
        82
      • Conclusion
        82
        -
        83
  • +
    PART III: Design Principles
    83
    -
    119

    • +
      Chapter 7 SRP: The Single Responsibility Principle
      87
      -
      95

      • Symptom 1: Accidental Duplication
        89
        -
        91
      • Symptom 2: Merges
        91
        -
        92
      • Solutions
        92
        -
        93
      • Conclusion
        93
        -
        95
    • +
      Chapter 8 OCP: The Open-Closed Principle
      95
      -
      103

      • A Thought Experiment
        96
        -
        100
      • Directional Control
        100
        -
        100
      • Information Hiding
        100
        -
        101
      • Conclusion
        101
        -
        103
    • +
      Chapter 9 LSP: The Liskov Substitution Principle
      103
      -
      109

      • Guiding the Use of Inheritance
        104
        -
        105
      • The Square/Rectangle Problem
        105
        -
        106
      • LSP and Architecture
        106
        -
        106
      • Example LSP Violation
        106
        -
        108
      • Conclusion
        108
        -
        109
    • +
      Chapter 10 ISP: The Interface Segregation Principle
      109
      -
      113

      • ISP and Language
        111
        -
        112
      • ISP and Architecture
        112
        -
        112
      • Conclusion
        112
        -
        113
    • +
      Chapter 11 DIP: The Dependency Inversion Principle
      113
      -
      117

      • Stable Abstractions
        114
        -
        115
      • Factories
        115
        -
        117
      • Concrete Components
        117
        -
        117
      • Conclusion
        117
        -
        119
  • +
    PART IV: Component Principles
    119
    -
    159

    • +
      Chapter 12 Components
      121
      -
      129

      • A Brief History of Components
        122
        -
        125
      • Relocatability
        125
        -
        126
      • Linkers
        126
        -
        128
      • Conclusion
        128
        -
        129
    • +
      Chapter 13 Component Cohesion
      129
      -
      137

      • The Reuse/Release Equivalence Principle
        130
        -
        131
      • The Common Closure Principle
        131
        -
        133
      • The Common Reuse Principle
        133
        -
        134
      • The Tension Diagram for Component Cohesion
        134
        -
        136
      • Conclusion
        136
        -
        137
    • +
      Chapter 14 Component Coupling
      137
      -
      158

      • The Acyclic Dependencies Principle
        138
        -
        144
      • Top-Down Design
        144
        -
        146
      • The Stable Dependencies Principle
        146
        -
        152
      • The Stable Abstractions Principle
        152
        -
        158
      • Conclusion
        158
        -
        159
  • +
    PART V: Architecture
    159
    -
    301

    • +
      Chapter 15 What Is Architecture?
      161
      -
      173

      • Development
        163
        -
        164
      • Deployment
        164
        -
        164
      • Operation
        164
        -
        165
      • Maintenance
        165
        -
        166
      • Keeping Options Open
        166
        -
        168
      • Device Independence
        168
        -
        170
      • Junk Mail
        170
        -
        171
      • Physical Addressing
        171
        -
        172
      • Conclusion
        172
        -
        173
    • +
      Chapter 16 Independence
      173
      -
      185

      • Use Cases
        174
        -
        175
      • Operation
        175
        -
        175
      • Development
        175
        -
        176
      • Deployment
        176
        -
        176
      • Leaving Options Open
        176
        -
        177
      • Decoupling Layers
        177
        -
        178
      • Decoupling Use Cases
        178
        -
        179
      • Decoupling Mode
        179
        -
        179
      • Independent Develop-ability
        179
        -
        180
      • Independent Deployability
        180
        -
        180
      • Duplication
        180
        -
        181
      • Decoupling Modes (Again)
        181
        -
        184
      • Conclusion
        184
        -
        185
    • +
      Chapter 17 Boundaries: Drawing Lines
      185
      -
      201

      • A Couple of Sad Stories
        186
        -
        189
      • FitNesse
        189
        -
        191
      • Which Lines Do You Draw, and When Do You Draw Them?
        191
        -
        195
      • What About Input and Output?
        195
        -
        196
      • Plugin Architecture
        196
        -
        198
      • The Plugin Argument
        198
        -
        199
      • Conclusion
        199
        -
        201
    • +
      Chapter 18 Boundary Anatomy
      201
      -
      209

      • Boundary Crossing
        202
        -
        202
      • The Dreaded Monolith
        202
        -
        204
      • Deployment Components
        204
        -
        205
      • Threads
        205
        -
        205
      • Local Processes
        205
        -
        206
      • Services
        206
        -
        207
      • Conclusion
        207
        -
        209
    • +
      Chapter 19 Policy and Level
      209
      -
      215

      • Level
        210
        -
        213
      • Conclusion
        213
        -
        215
    • +
      Chapter 20 Business Rules
      215
      -
      221

      • Entities
        216
        -
        217
      • Use Cases
        217
        -
        219
      • Request and Response Models
        219
        -
        220
      • Conclusion
        220
        -
        221
    • +
      Chapter 21 Screaming Architecture
      221
      -
      227

      • The Theme of an Architecture
        222
        -
        223
      • The Purpose of an Architecture
        223
        -
        223
      • But What About the Web?
        223
        -
        224
      • Frameworks Are Tools, Not Ways of Life
        224
        -
        224
      • Testable Architectures
        224
        -
        225
      • Conclusion
        225
        -
        227
    • +
      Chapter 22 The Clean Architecture
      227
      -
      237

      • The Dependency Rule
        229
        -
        233
      • A Typical Scenario
        233
        -
        235
      • Conclusion
        235
        -
        237
    • +
      Chapter 23 Presenters and Humble Objects
      237
      -
      243

      • The Humble Object Pattern
        238
        -
        238
      • Presenters and Views
        238
        -
        239
      • Testing and Architecture
        239
        -
        240
      • Database Gateways
        240
        -
        240
      • Data Mappers
        240
        -
        241
      • Service Listeners
        241
        -
        241
      • Conclusion
        241
        -
        243
    • +
      Chapter 24 Partial Boundaries
      243
      -
      247

      • Skip the Last Step
        244
        -
        245
      • One-Dimensional Boundaries
        245
        -
        246
      • Facades
        246
        -
        246
      • Conclusion
        246
        -
        247
    • +
      Chapter 25 Layers and Boundaries
      247
      -
      257

      • Hunt the Wumpus
        248
        -
        249
      • Clean Architecture?
        249
        -
        252
      • Crossing the Streams
        252
        -
        253
      • Splitting the Streams
        253
        -
        254
      • Conclusion
        254
        -
        257
    • +
      Chapter 26 The Main Component
      257
      -
      265

      • The Ultimate Detail
        258
        -
        263
      • Conclusion
        263
        -
        265
    • +
      Chapter 27 Services: Great and Small
      265
      -
      275

      • Service Architecture?
        266
        -
        266
      • Service Benefits?
        266
        -
        268
      • The Kitty Problem
        268
        -
        270
      • Objects to the Rescue
        270
        -
        271
      • Component-Based Services
        271
        -
        272
      • Cross-Cutting Concerns
        272
        -
        273
      • Conclusion
        273
        -
        275
    • +
      Chapter 28 The Test Boundary
      275
      -
      281

      • Tests as System Components
        276
        -
        277
      • Design for Testability
        277
        -
        278
      • The Testing API
        278
        -
        279
      • Conclusion
        279
        -
        281
    • +
      Chapter 29 Clean Embedded Architecture
      281
      -
      299

      • App-titude Test
        284
        -
        287
      • The Target-Hardware Bottleneck
        287
        -
        299
      • Conclusion
        299
        -
        301
  • +
    PART VI: Details
    301
    -
    349

    • +
      Chapter 30 The Database Is a Detail
      303
      -
      311

      • Relational Databases
        304
        -
        305
      • Why Are Database Systems So Prevalent?
        305
        -
        306
      • What If There Were No Disk?
        306
        -
        307
      • Details
        307
        -
        307
      • But What about Performance?
        307
        -
        307
      • Anecdote
        307
        -
        309
      • Conclusion
        309
        -
        311
    • +
      Chapter 31 The Web Is a Detail
      311
      -
      317

      • The Endless Pendulum
        312
        -
        314
      • The Upshot
        314
        -
        315
      • Conclusion
        315
        -
        317
    • +
      Chapter 32 Frameworks Are Details
      317
      -
      323

      • Framework Authors
        318
        -
        318
      • Asymmetric Marriage
        318
        -
        319
      • The Risks
        319
        -
        320
      • The Solution
        320
        -
        321
      • I Now Pronounce You …
        321
        -
        321
      • Conclusion
        321
        -
        323
    • +
      Chapter 33 Case Study: Video Sales
      323
      -
      329

      • The Product
        324
        -
        324
      • Use Case Analysis
        324
        -
        326
      • Component Architecture
        326
        -
        328
      • Dependency Management
        328
        -
        328
      • Conclusion
        328
        -
        329
    • +
      Chapter 34 The Missing Chapter
      329
      -
      347

      • Package by Layer
        330
        -
        332
      • Package by Feature
        332
        -
        334
      • Ports and Adapters
        334
        -
        336
      • Package by Component
        336
        -
        341
      • The Devil Is in the Implementation Details
        341
        -
        342
      • Organization versus Encapsulation
        342
        -
        345
      • Other Decoupling Modes
        345
        -
        347
      • Conclusion: The Missing Advice
        347
        -
        349
  • PART VII: Appendix
    349
    -
    351
  • Appendix A: Architecture Archaeology
    351
    -
    401
  • +
    Index
    401
    -
    426

    • A
      401
      -
      403
    • B
      403
      -
      404
    • C
      404
      -
      407
    • D
      407
      -
      411
    • E
      411
      -
      411
    • F
      411
      -
      412
    • G
      412
      -
      413
    • H
      413
      -
      413
    • I
      413
      -
      414
    • J
      414
      -
      415
    • K
      415
      -
      415
    • L
      415
      -
      416
    • M
      416
      -
      417
    • N
      417
      -
      417
    • O
      417
      -
      418
    • P
      418
      -
      419
    • R
      419
      -
      420
    • S
      420
      -
      423
    • T
      423
      -
      424
    • U
      424
      -
      425
    • V
      425
      -
      425
    • W
      425
      -
      426
    • Y
      426
      -
      426
    • Z
      426
      -
      427

Über die Autoren

Robert C. Martin

Author

Weitere Beiträge zur Thematik