Five Lines of Code
Rheinwerk (Verlag)
978-3-8362-9224-5 (ISBN)
- Code-Smells finden und durch sicheres Refactoring beheben
- Erweiterbarer Code in kurzen Funktionen, optimal für agile Devs
- Mit vielen Beispielen in TypeScript und Refactoring-Lösungen aus realen Projekten
Patterns und Praktiken für nachhaltigen Code
Refactoring ist die Kunst, bestehenden Code so zu verbessern, dass der Wert von Software langfristig erhalten bleibt. Das Ergebnis des Vorgangs ist als Clean Code bekannt – aber wie kommen Sie dahin?
Christian Clausen legt hier eine ganz neuartige Schule des Refactorings vor, die Sie Schritt für Schritt anleitet. Das Vorgehen eignet sich für alle OOP-Sprachen. Die gut lesbaren Beispiele in TypeScript sind in einem Stil gehalten, der insbesondere Java- und C#- Entwickler*innen vertraut sein dürfte. Ein zweispaltiges Vorher-Nachher-Layout mit zeilengenauen Codekommentaren macht jeden Arbeitsschritt hervorragend nachvollziehbar. So gelingt Ihr Refactoring sicher!
Sehen, ändern, testen
Kleine Änderungsschritte und stetiges Testen machen Ihre Arbeit erfolgreich. Christian Clausen schlägt viele konkrete Verbesserungen vor und zeigt, wie Sie sie sicher umsetzen – an nebeneinander gesetzten Codebeispielen Schritt für Schritt nachvollziehbar.
Patterns und Beispielcode
Mit Refactoring Patterns nutzen Sie erprobte Vorgehensweisen für Ihren Code. Um sie zu verstehen, hilft ein anschauliches, reales Beispiel: Im Buch wird nach und nach die Codebasis eines Casual Games auf solide Füße gestellt.
Fünf Zeilen Code
Am Ende steht Code, der pro Funktion oder Methode mit fünf Zeilen auskommt – aber auch von dieser Regel gibt es Ausnahmen! Intuition und Domänenwissen bleiben selbstverständlich im Boot. Die Patterns und Regeln sind die Grundlage, das gelungene Refactoring bleibt Ihr Werk.
Allgemeinverständliche Codebeispiele
Das Vorgehen eignet sich für alle OOP-Sprachen. Die Codebeispiele in TypeScript sind in einem Stil gehalten, der für Entwicker*innen verschiedener OOP-Sprachen leicht zu lesen ist. Insbesondere, wer Java oder C# gewohnt ist, wird sich gleich zu Hause fühlen.
Aus dem Inhalt:
Anzeichen für Verbesserungsbedarf im Code
Code in sicheren Schritten verbessern – auch, wenn Sie ihn nicht verstehen
Optimierungen und Wiederverwendbarkeit sinnvoll abwägen
Gute Compiler-Praxis
Viele Patterns und Methoden für das konkrete Vorgehen
Wie man Code schreibt, der ohne Kommentare auskommt
Best Practices aus realen Projekten
Christian Clausen ist Agile Coach mit einem Beratungsschwerpunkt auf der technischen Seite der Softwareentwicklung. In seinen Workshops und Trainings leitet er agile Teams an, sich erfolgreiches Refactoring zur Gewohnheit zu machen.
Materialien zum Buch ... 16
Vorwort ... 17
Einführung ... 19
Danksagungen ... 23
Der Autor ... 25
Der Übersetzer ... 25
1. Refactorings für Refactoring ... 27
1.1 ... Was ist Refactoring? ... 28
1.2 ... Fähigkeiten: Was sollte ich refactorn? ... 29
1.3 ... Kultur: Wann sollte ich refactorn? ... 31
1.4 ... Werkzeuge: Wie sollte ich (sicher) refactorn? ... 33
1.5 ... Werkzeuge für den Anfang ... 34
1.6 ... Das durchgehende Beispiel: ein 2D-Rätselspiel ... 36
1.7 ... Ein Wort zu Software aus der echten Welt ... 38
1.8 ... Zusammenfassung ... 39
2. Ein Blick unter die Haube ... 41
2.1 ... Lesbarkeit und Wartbarkeit verbessern ... 41
2.2 ... Geschwindigkeit, Flexibilität und Stabilität gewinnen ... 45
2.3 ... Refactoring und die tägliche Arbeit ... 47
2.4 ... Die Domäne einer Software definieren ... 48
2.5 ... Zusammenfassung ... 49
TEIL I. Das Refactoring eines Computerspiels als Lernbeispiel ... 51
3. Lange Funktionen zerschlagen ... 53
3.1 ... Unsere erste Regel: Warum fünf Zeilen? ... 54
3.2 ... Ein Refactoring, um Funktionen aufzubrechen ... 57
3.3 ... Funktionen teilen, um Abstraktionsebenen zu trennen ... 66
3.4 ... Eigenschaften eines guten Funktionsnamens ... 69
3.5 ... Funktionen aufbrechen, die zu viel tun ... 72
3.6 ... Zusammenfassung ... 76
4. Typen richtig nutzen ... 77
4.1 ... Refactoring einer einfachen if-Anweisung ... 77
4.2 ... Refactoring einer großen »if«-Anweisung ... 98
4.3 ... Mit doppeltem Code umgehen ... 114
4.4 ... Refactoring von zwei komplexen »if«-Anweisungen ... 118
4.5 ... Toten Code entfernen ... 122
4.6 ... Zusammenfassung ... 124
5. Ähnlichen Code zusammenführen ... 127
5.1 ... Ähnliche Klassen zusammenführen ... 128
5.2 ... Einfache Bedingungen zusammenführen ... 145
5.3 ... Komplexe Bedingungen zusammenführen ... 150
5.4 ... Code in verschiedenen Klassen zusammenführen ... 156
5.5 ... Ähnliche Funktionen zusammenführen ... 178
5.6 ... Ähnlichen Code zusammenführen ... 182
5.7 ... Zusammenfassung ... 187
6. Die Daten verteidigen ... 189
6.1 ... Kapselung ohne Getter ... 189
6.2 ... Einfache Daten kapseln ... 201
6.3 ... Komplexe Daten kapseln ... 214
6.4 ... Invariante Reihenfolgen entfernen ... 222
6.5 ... Ein anderes Vorgehen, um Enums zu löschen ... 226
6.6 ... Zusammenfassung ... 232
TEIL II. Das Gelernte in die Praxis übertragen ... 233
7. Mit dem Compiler zusammenarbeiten ... 235
7.1 ... Den Compiler kennenlernen ... 236
7.2 ... Den Compiler benutzen ... 245
7.3 ... Vertraue dem Compiler ... 255
7.4 ... Vertraue nur dem Compiler ... 258
7.5 ... Zusammenfassung ... 259
8. Finger weg von Kommentaren ... 261
8.1 ... Veraltete Kommentare löschen ... 263
8.2 ... Auskommentierten Code löschen ... 263
8.3 ... Überflüssige Kommentare löschen ... 264
8.4 ... Kommentare in Methodennamen umsetzen ... 265
8.5 ... Kommentare behalten, die Invarianten dokumentieren ... 266
8.6 ... Zusammenfassung ... 267
9. Lerne, das Löschen zu lieben ... 269
9.1 ... Code löschen: das nächste Abenteuer ... 270
9.2 ... Code löschen, um anfallende Komplexitätzu reduzieren ... 271
9.3 ... Code nach Vertrautheit kategorisieren ... 274
9.4 ... Code in einem Legacy-System löschen ... 275
9.5 ... Code aus einem eingefrorenen Projekt löschen ... 278
9.6 ... Branches aus der Versionskontrolle löschen ... 280
9.7 ... Codedokumentation löschen ... 282
9.8 ... Testcode löschen ... 284
9.9 ... Konfigurationscode löschen ... 286
9.10 ... Code löschen, um Bibliotheken loszuwerden ... 288
9.11 ... Code aus funktionierenden Features entfernen ... 291
9.12 ... Zusammenfassung ... 292
10. Keine Angst vor neuem Code ... 293
10.1 ... Unsicherheit akzeptieren: In die Gefahr eintreten ... 294
10.2 ... Prototypen: gegen die Angst, das Falsche zu entwickeln ... 294
10.3 ... Verhältnismäßige Arbeit: gegen die Angst vor Verschwendung und Risiko ... 296
10.4 ... Schrittweise Verbesserung: gegen die Angst vor Imperfektion ... 297
10.5 ... Wie Copy & Paste unsere Geschwindigkeit beeinflusst ... 298
10.6 ... Verändern durch Hinzufügen: geplante Erweiterbarkeit ... 299
10.7 ... Verändern durch Hinzufügen erlaubt Abwärtskompatibilität ... 300
10.8 ... Verändern durch Hinzufügen mit Featureschaltern ... 302
10.9 ... Verändern durch Hinzufügen mit Verzweigung durch Abstraktion ... 306
10.10 ... Zusammenfassung ... 309
11. Folge der Struktur im Code ... 311
11.1 ... Strukturen einteilen nach Wirkungsbereich und Herkunft ... 311
11.2 ... Drei Arten, wie Code Verhalten spiegelt ... 313
11.3 ... Code hinzufügen, um Struktur zu betonen ... 321
11.4 ... Beobachten statt vorhersagen -- empirische Techniken einsetzen ... 322
11.5 ... Sicherheit gewinnen, ohne den Code zu verstehen ... 323
11.6 ... Ungenutzte Strukturen finden ... 324
11.7 ... Zusammenfassung ... 333
12. Vermeide Optimierung und Generalität ... 335
12.1 ... Nach Einfachheit streben ... 336
12.2 ... Verallgemeinern -- wann und wie ... 338
12.3 ... Optimieren -- wann und wie ... 340
12.4 ... Zusammenfassung ... 352
13. Schlechter Code soll schlecht aussehen ... 353
13.1 ... Auf Prozessprobleme mit schlechtem Code aufmerksam machen ... 353
13.2 ... Trennung in sauberen und problematischen Code ... 355
13.3 ... Ansätze, schlechten Code zu definieren ... 356
13.4 ... Regeln für sicheren Vandalismus ... 359
13.5 ... Methoden für sicheren Vandalismus ... 359
13.6 ... Zusammenfassung ... 369
14. Zum Abschluss ... 371
14.1 ... Ein Rückblick auf die Reise in diesem Buch ... 371
14.2 ... Die Philosophie dahinter ... 372
14.3 ... Wie mache ich weiter? ... 377
14.4 ... Zusammenfassung ... 378
A. Die Werkzeuge für Teil I installieren ... 381
A.1 ... Node.js ... 381
A.2 ... TypeScript ... 381
A.3 ... Visual Studio Code ... 381
A.4 ... Git ... 382
A.5 ... Das TypeScript-Projekt einrichten ... 382
A.6 ... Das TypeScript-Projekt bauen ... 382
A.7 ... Wie du den Level änderst ... 383
Index ... 385
»Mit Beispielen in Typescript nimmt das Handbuch den:die Leser:in an die Hand und führt anhand von klaren Regeln und Aufgaben Schritt für Schritt in die Lehren des Refactorings ein, ohne dem:der Leser:in die eigene Intuition und Kreativität bei der Lösungsfindung streitig zu machen. Dabei werden auch immer wieder Best Practices aus realen Projekten vorgestellt. Der 388 Seiten starke Ratgeber eignet sich praktischerweise für alle objektorientierten Programmiersprachen.« t3n 202302
»Mit Beispielen in Typescript nimmt das Handbuch den:die Leser:in an die Hand und führt anhand von klaren Regeln und Aufgaben Schritt für Schritt in die Lehren des Refactorings ein, ohne dem:der Leser:in die eigene Intuition und Kreativität bei der Lösungsfindung streitig zu machen. Dabei werden auch immer wieder Best Practices aus realen Projekten vorgestellt. Der 388 Seiten starke Ratgeber eignet sich praktischerweise für alle objektorientierten Programmiersprachen.«
| Erscheinungsdatum | 28.11.2022 |
|---|---|
| Verlagsort | Bonn |
| Sprache | deutsch |
| Maße | 190 x 240 mm |
| Einbandart | kartoniert |
| Themenwelt | Mathematik / Informatik ► Informatik ► Programmiersprachen / -werkzeuge |
| Schlagworte | agile development • Agilität • Bücher Lernen Kurse Grundlagen Seminare Tutorials Workshops Training • Clean Code • Codebasen • Code Smells • OOP-Sprachen • Optimierung • Programmieren • Programmiersprachen • Programmierung • Refactoring • Software-Entwicklung • Styleguide • TypeScript |
| ISBN-10 | 3-8362-9224-6 / 3836292246 |
| ISBN-13 | 978-3-8362-9224-5 / 9783836292245 |
| Zustand | Neuware |
| Haben Sie eine Frage zum Produkt? |
aus dem Bereich
