Clean Architecture (eBook)

Das Praxis-Handbuch für professionelles Softwaredesign.Regeln und Paradigmen für effiziente Softwarestrukturierung.

Robert C. Martin (Autor)

eBook Download: PDF

2018 | 1. Auflage
377 Seiten
MITP Verlags GmbH & Co. KG
978-3-95845-725-6 (ISBN)

Infos

• Praktische Lösungen für den Aufbau von Softwarearchitekturen von dem legendären Softwareentwickler Robert C. Martin (»Uncle Bob«)
• Allgemeingültige Regeln für die Verbesserung der Produktivität in der Softwareentwicklung über den gesamten Lebenszyklus
• Wie Softwareentwickler wesentliche Prinzipien des Softwaredesigns meistern, warum Softwarearchitekturen häufig scheitern und wie man solche Fehlschläge verhindern kann

Wirklich gute Software zu entwickeln, ist ein schwieriges Unterfangen und eine große Herausforderung. Aber wenn Software in der richtigen Art und Weise entwickelt wird, erfordert die Erstellung und Instandhaltung nur wenige Ressourcen, Modifikationen und Anpassungen lassen sich schnell und einfach umsetzen und Mängel und Fehler treten nur hin und wieder in Erscheinung. Der Entwicklungsaufwand ist minimal, und das bei maximaler Funktionalität und Flexibilität.

Was hier utopisch klingt, hat Robert C. Martin schon selbst erlebt und weiß deshalb, dass es so funktionieren kann.

Als Entwickler können Sie Ihre Produktivität über die Lebenszeit eines jeden Softwaresystems dramatisch verbessern, indem Sie allgemeingültige Grundsätze für die Entwicklung professioneller Softwarearchitektur anwenden. In diesem Buch verrät Ihnen der legendäre Softwareentwickler diese maßgeblichen Prinzipien und zeigt Ihnen, wie Sie diese erfolgreich und effektiv anwenden.

Basierend auf seiner mehr als 50-jährigen Berufserfahrung mit Softwareumgebungen jeder erdenklichen Art demonstriert Robert C. Martin in diesem Buch auf eindrucksvolle Weise, welche Entscheidungen Sie im Entwicklungsprozess treffen sollten und warum diese für Ihren Erfolg ausschlaggebend sind. Wie man es von »Uncle Bob« kennt, enthält dieses Buch zahlreiche unmittelbar anwendbare und in sich schlüssige Lösungen für die Herausforderungen, mit denen Sie im Berufsleben konfrontiert sein werden - jenen, die über Gedeih und Verderb Ihrer Projekte entscheiden.

In diesem Buch lernen Sie:

• Architektonische Zielsetzungen der Softwareentwicklung richtig abstecken und die dafür notwendigen Kerndisziplinen und -praktiken planvoll einsetzen
• Die grundlegenden Prinzipien des Softwaredesigns für den Umgang mit Funktionalität, Komponententrennung und Datenmanagement meistern
• Den Entwicklungsprozess optimieren durch die zielgerichtete Anwendung von Programmierparadigmen und die klare Definition der Handlungsspielräume der Softwareentwickler
• Wichtige systemrelevante Programmbestandteile von bloßen »Details« unterscheiden
• Optimale, hochschichtige Strukturen für Web, Datenbank, Fat Client, Konsole und eingebettete Anwendungen implementieren
• Angemessene Grenzen und Layer definieren und die Komponenten und Services in Ihrem System organisieren
• Faktoren für das Scheitern von Softwaredesigns und -architekturen erkennen und diese Fehler vermeiden

Clean Architecture ist für jeden gegenwärtigen oder angehenden Softwarearchitekten, Systemanalysten, Systemdesigner und Softwaremanager eine Pflichtlektüre - ebenso wie für jeden Programmierer, der die Softwaredesigns anderer Entwickler ausführen muss.

Robert C. Martin (»Uncle Bob«) ist bereits seit 1970 als Programmierer tätig. Neben seiner Beraterfirma Uncle Bob Consulting, LLC gründete er gemeinsam mit seinem Sohn Micah Martin auch das Unternehmen The Clean Coders, LLC. Er hat zahlreiche Artikel in verschiedenen Zeitschriften veröffentlicht und hält regelmäßig Vorträge auf internationalen Konferenzen.

Inhalt

Cover 1
Titel 4
Impressum 5
Inhaltsverzeichnis 6
Vorwort 16
Einleitung 20
Über den Autor 24
Danksagung 25
Teil I: Einführung 26
Kapitel 1: Was bedeuten »Design« und »Architektur«? 30
1.1 Das Ziel? 31
1.2 Fallstudie 32
1.2.1 Die Signatur des Chaos 33
1.2.2 Die Perspektive der Unternehmensleitung 34
1.2.3 Was ist schiefgelaufen? 35
1.3 Fazit 38
Kapitel 2: Die Geschichte zweier Werte 40
2.1 Verhalten 40
2.2 Architektur 41
2.3 Der größere Wert 42
2.4 Das Eisenhower-Prinzip 43
2.5 Der Kampf für die Architektur 44
Teil II: Die ersten Bausteine setzen: Programmierparadigmen 46
Kapitel 3: Die Paradigmen 48
3.1 Strukturierte Programmierung 48
3.2 Objektorientierte Programmierung 49
3.3 Funktionale Programmierung 49
3.4 Denkanstöße 50
3.5 Fazit 50
Kapitel 4: Strukturierte Programmierung 52
4.1 Die Beweisführung 53
4.2 Eine »schädliche« Proklamation 55
4.3 Funktionale Dekomposition 56
4.4 Keine formalen Beweise 56
4.5 Wissenschaft als Rettung 56
4.6 Tests 57
4.7 Fazit 58
Kapitel 5: Objektorientierte Programmierung 60
5.1 Datenkapselung? 61
5.2 Vererbung? 64
5.3 Polymorphie 66
5.3.1 Die Macht der Polymorphie 68
5.3.2 Abhängigkeitsumkehr 69
5.4 Fazit 72
Kapitel 6: Funktionale Programmierung 74
6.1 Quadrierung von Integern 75
6.2 Unveränderbarkeit und Architektur 76
6.3 Unterteilung der Veränderbarkeit 77
6.4 Event Sourcing 78
6.5 Fazit 80
Teil III: Designprinzipien 82
Kapitel 7: SRP: Das Single-Responsibility-Prinzip 86
7.1 Symptom 1: Versehentliche Duplizierung 87
7.2 Symptom 2: Merges 89
7.3 Lösungen 90
7.4 Fazit 91
Kapitel 8: OCP: Das Open-Closed-Prinzip 92
8.1 Ein Gedankenexperiment 93
8.2 Richtungssteuerung 96
8.3 Information Hiding 96
8.4 Fazit 97
Kapitel 9: LSP: Das Liskov’sche Substitutionsprinzip 98
9.1 Gesteuerte Nutzung der Vererbung 99
9.2 Das Quadrat-Rechteck-Problem 99
9.3 Das LSP und die Softwarearchitektur 100
9.4 Beispiel für einen Verstoß gegen das LSP 100
9.5 Fazit 102
Kapitel 10: ISP: Das Interface-Segregation-Prinzip 104
10.1 Das ISP und die Programmiersprachen 105
10.2 Das ISP und die Softwarearchitektur 106
10.3 Fazit 106
Kapitel 11: DIP: Das Dependency-Inversion-Prinzip 108
11.1 Stabile Abstraktionen 109
11.2 Factories 110
11.3 Konkrete Komponenten 111
11.4 Fazit 111
Teil IV: Komponentenprinzipien 112
Kapitel 12: Komponenten 114
12.1 Eine kurze Historie der Komponenten 115
12.2 Relokatierbarkeit 117
12.3 Linker 118
12.4 Fazit 120
Kapitel 13: Komponentenkohäsion 122
13.1 REP: Das Reuse-Release-Equivalence-Prinzip 122
13.2 CCP: Das Common-Closure-Prinzip 124
13.2.1 Ähnlichkeiten mit dem SRP 125
13.3 CRP: Das Common-Reuse-Prinzip 125
13.3.1 Relation zum ISP 126
13.4 Das Spannungsdiagramm für die Komponentenkohäsion 126
13.5 Fazit 128
Kapitel 14: Komponentenkopplung 130
14.1 ADP: Das Acyclic-Dependencies-Prinzip 130
14.1.1 Der wöchentliche Build 131
14.1.2 Abhängigkeitszyklen abschaffen 132
14.1.3 Auswirkung eines Zyklus in einem Komponentenabhängigkeitsgraphen 134
14.1.4 Den Zyklus durchbrechen 135
14.1.5 Jitters (Fluktuationen) 136
14.2 Top-down-Design 137
14.3 SDP: Das Stable-Dependencies-Prinzip 138
14.3.1 Stabilität 138
14.3.2 Stabilitätsmetriken 140
14.3.3 Nicht alle Komponenten sollten stabil sein 142
14.3.4 Abstrakte Komponenten 144
14.4 SAP: Das Stable-Abstractions-Prinzip 144
14.4.1 Wo werden die übergeordneten Richtlinien hinterlegt? 144
14.4.2 Einführung in das SAP (Stable-Abstractions-Prinzip) 144
14.4.3 Bemessung der Abstraktion 145
14.4.4 Die Hauptreihe 145
14.4.5 Die »Zone of Pain« 146
14.4.6 Die »Zone of Uselessness« 147
14.4.7 Die Ausschlusszonen vermeiden 148
14.4.8 Abstand von der Hauptreihe 148
14.5 Fazit 150
Teil V: Softwarearchitektur 152
Kapitel 15: Was ist Softwarearchitektur? 154
15.1 Entwicklung 156
15.2 Deployment 156
15.3 Betrieb 157
15.4 Instandhaltung 158
15.5 Optionen offenhalten 158
15.6 Geräteunabhängigkeit 160
15.7 Junk Mail 162
15.8 Physische Adressierung 163
15.9 Fazit 164
Kapitel 16: Unabhängigkeit 166
16.1 Use Cases 166
16.2 Betrieb 167
16.3 Entwicklung 168
16.4 Deployment 168
16.5 Optionen offenhalten 169
16.6 Layer entkoppeln 169
16.7 Use Cases entkoppeln 170
16.8 Entkopplungsmodi 171
16.9 Unabhängige Entwickelbarkeit 172
16.10 Unabhängige Deploybarkeit 172
16.11 Duplizierung 172
16.12 Entkopplungsmodi (zum Zweiten) 173
16.12.1 Welcher Modus ist am besten geeignet? 174
16.13 Fazit 175
Kapitel 17: Grenzen: Linien ziehen 176
17.1 Ein paar traurige Geschichten 177
17.2 FitNesse 180
17.3 Welche Grenzen sollten Sie ziehen – und wann? 182
17.4 Wie verhält es sich mit der Ein- und Ausgabe? 185
17.5 Plug-in-Architektur 186
17.6 Das Plug-in-Argument 187
17.7 Fazit 188
Kapitel 18: Anatomie der Grenzen 190
18.1 Grenzüberschreitungen 190
18.2 Der gefürchtete Monolith 191
18.3 Deployment-Komponenten 193
18.4 Threads 193
18.5 Lokale Prozesse 194
18.6 Services 194
18.7 Fazit 195
Kapitel 19: Richtlinien und Ebenen 196
19.1 Ebene 197
19.2 Fazit 200
Kapitel 20: Geschäftsregeln 202
20.1 Entitäten 203
20.2 Use Cases 204
20.3 Request-and-Response-Modelle 206
20.4 Fazit 207
Kapitel 21: Die schreiende Softwarearchitektur 208
21.1 Das Thema einer Architektur 209
21.2 Der Zweck einer Softwarearchitektur 209
21.3 Aber was ist mit dem Web? 210
21.4 Frameworks sind Tools, keine Lebenseinstellung 210
21.5 Testfähige Architekturen 211
21.6 Fazit 211
Kapitel 22: Die saubere Architektur 212
22.1 Die Abhängigkeitsregel (Dependency Rule) 214
22.1.1 Entitäten 214
22.1.2 Use Cases 214
22.1.3 Schnittstellenadapter 215
22.1.4 Frameworks und Treiber 215
22.1.5 Nur vier Kreise? 216
22.1.6 Grenzen überschreiten 216
22.1.7 Welche Daten überqueren die Grenzlinien? 217
22.2 Ein typisches Beispiel 217
22.3 Fazit 218
Kapitel 23: Presenters und »Humble Objects« 220
23.1 Das Pattern »Humble Object« 220
23.2 Presenters und Views 221
23.3 Das Testen und die Softwarearchitektur 222
23.4 Datenbank-Gateways 222
23.5 Data Mappers 222
23.6 Service Listeners 223
23.7 Fazit 223
Kapitel 24: Partielle Grenzen 224
24.1 Den letzten Schritt weglassen 225
24.2 Eindimensionale Grenzen 225
24.3 Fassaden 226
24.4 Fazit 227
Kapitel 25: Layer und Grenzen 228
25.1 Hunt the Wumpus 229
25.2 Saubere Architektur? 230
25.3 Datenstromüberschreitungen 232
25.4 Datenströme teilen 233
25.5 Fazit 235
Kapitel 26: Die Komponente Main 236
26.1 Das ultimative Detail 236
26.2 Fazit 240
Kapitel 27: Services – große und kleine 242
27.1 Servicearchitektur? 242
27.2 Vorteile der Services? 243
27.2.1 Denkfalle: Entkopplung 243
27.2.2 Denkfalle: Unabhängige Entwickel- und Deploybarkeit 244
27.3 Das Kätzchen-Problem 244
27.4 Objekte als Rettung 246
27.5 Komponentenbasierte Services 248
27.6 Cross-Cutting Concerns 249
27.7 Fazit 249
Kapitel 28: Die Testgrenze 250
28.1 Tests als Systemkomponenten 250
28.2 Design für Testfähigkeit 251
28.3 Die Test-API 252
28.3.1 Strukturelle Kopplung 252
28.3.2 Sicherheit 253
28.4 Fazit 253
Kapitel 29: Saubere eingebettete Architektur 254
29.1 App-Eignungstest 257
29.2 Der Flaschenhals der Zielhardware 260
29.2.1 Eine saubere eingebettete Architektur ist eine testfähige eingebettete Architektur 261
29.2.2 Offenbaren Sie dem HAL-User keine Hardwaredetails 264
29.3 Fazit 270
Teil VI: Details 272
Kapitel 30: Die Datenbank ist ein Detail 274
30.1 Relationale Datenbanken 275
30.2 Warum sind Datenbanksysteme so weit verbreitet? 275
30.3 Was wäre, wenn es keine Festplatten gäbe? 276
30.4 Details 277
30.5 Und was ist mit der Performance? 277
30.6 Anekdote 278
30.7 Fazit 279
Kapitel 31: Das Web ist ein Detail 280
31.1 Der immerwährende Pendelausschlag 281
31.2 Quintessenz 282
31.3 Fazit 283
Kapitel 32: Ein Framework ist ein Detail 284
32.1 Framework-Autoren 285
32.2 Asymmetrische Ehe 285
32.3 Die Risiken 286
32.4 Die Lösung 286
32.5 Hiermit erkläre ich euch zu ... 287
32.6 Fazit 287
Kapitel 33: Fallstudie: Software für den Verkauf von Videos 288
33.1 Das Produkt 288
33.2 Use-Case-Analyse 289
33.3 Komponentenarchitektur 290
33.4 Abhängigkeitsmanagement 292
33.5 Fazit 292
Kapitel 34: Das fehlende Kapitel 294
34.1 Package by Layer 295
34.2 Package by Feature 296
34.3 Ports and Adapters 298
34.4 Package by Component 300
34.5 Der Teufel steckt in den Implementierungsdetails 305
34.6 Organisation vs. Kapselung 306
34.7 Andere Entkopplungsmodi 309
34.8 Fazit: Der fehlende Ratschlag 310
Anhang A: Architekturarchäologie 312
A.1 Das Buchhaltungssystem für die Gewerkschaft 313
A.2 Zurechtschneiden mit dem Laser 318
A.3 Monitoring von Aluminiumspritzguss 322
A.4 4-TEL 323
A.4.1 Service Area Computer 327
A.4.2 Ermittlung des Wartungsbedarfs 328
A.4.3 Architektur 328
A.4.4 Die große Neugestaltung 330
A.4.5 Europa 331
A.4.6 SAC: Fazit 331
A.5 Die Programmiersprache C 332
A.5.1 C 333
A.6 BOSS 333
A.7 Projekt CCU 334
A.7.1 Denkfalle: Die Planung 335
A.8 DLU/DRU 336
A.8.1 Architektur 337
A.9 VRS 338
A.9.1 Der Name 339
A.9.2 Architektur 339
A.9.3 VRS: Fazit 340
A.10 Der Elektronische Rezeptionist 341
A.10.1 Der Untergang des ER 342
A.11 Craft Dispatch System 343
A.12 Clear Communications 345
A.12.1 Die Gegebenheiten 346
A.12.2 Uncle Bob 347
A.12.3 Das Telefongespräch 347
A.13 ROSE 348
A.13.1 Fortsetzung der Debatten ... 349
A.13.2 ... unter anderem Namen 349
A.14 Prüfung zum eingetragenen Architekten 350
A.15 Fazit 353
Anhang B: Nachwort 354
Stichwortverzeichnis 358

Produkt-Details

• Erscheint lt. Verlag: 20.2.2018
• Reihe/Serie: mitp Professional
• Sprache: deutsch
• Themenwelt: Naturwissenschaften
• Themenwelt: Technik
• Schlagworte: Programmierung • Softewarearchitektur • Software • Softwareentwicklung
• ISBN-10: 3-95845-725-8 / 3958457258
• ISBN-13: 978-3-95845-725-6 / 9783958457256