Effektives Arbeiten mit Legacy Code - Refactoring und Testen bestehender Software

Cover

Titel

Impressum

Inhaltsverzeichnis

Vorwort

Geleitwort

Danksagungen

Einführung - Wie man dieses Buch lesen sollte

Teil I: Wie Wandel funktioniert

Kapitel 1: Software ändern

1.1 Vier Gründe, Software zu ändern

1.2 Riskante Änderungen

Kapitel 2: Mit Feedback arbeiten

2.1 Was sind Unit-Tests?

2.2 Higher-Level-Tests

2.3 Testabdeckung

2.4 Der Algorithmus zur Änderung von Legacy Code

Kapitel 3: Überwachung und Trennung

3.1 Kollaborateure simulieren

Kapitel 4: Das Seam-Modell

4.1 Ein riesiges Blatt mit Text

4.2 Seams

4.3 Seam-Arten

Kapitel 5: Tools

5.1 Automatisierte Refactoring-Tools

5.2 Mock-Objekte

5.3 Unit-Test-Harnische

5.4 Allgemeine Test-Harnische

Teil II: Software ändern

Kapitel 6: Ich habe nicht viel Zeit und ich muss den Code ändern

6.1 Sprout Method

6.2 Sprout Class

6.3 Wrap Method

6.4 Wrap Class

6.5 Zusammenfassung

Kapitel 7: Änderungen brauchen eine Ewigkeit

7.1 Verständlichkeit

7.2 Verzögerungszeit

7.3 Dependencies aufheben

7.4 Zusammenfassung

Kapitel 8: Wie füge ich eine Funktion hinzu?

8.1 Test-Driven Development (TDD)

8.2 Programming by Difference

8.3 Zusammenfassung

Kapitel 9: Ich kann diese Klasse nicht in einen Test-Harnisch einfügen

9.1 Der Fall des irritierenden Parameters

9.2 Der Fall der verborgenen Dependency

9.3 Der Fall der verketteten Konstruktionen

9.4 Der Fall der irritierenden globalen Dependency

9.5 Der Fall der schrecklichen Include-Dependencies

9.6 Der Fall der Zwiebel-Parameter

9.7 Der Fall des Alias-Parameters

Kapitel 10: Ich kann diese Methode nicht in einem Test-Harnisch ausführen

10.1 Der Fall der verborgenen Methode

10.2 Der Fall der »hilfreichen« Sprachfunktion

10.3 Der Fall des nicht erkennbaren Nebeneffekts

Kapitel 11: Ich muss eine Änderung vornehmen. Welche Methoden sollte ich testen?

11.1 Effekte analysieren

11.2 Vorwärtsanalyse (Reasoning Forward)

11.3 Effektfortpflanzung (Effect Propagation)

11.4 Tools für Effektanalysen

11.5 Von der Effektanalyse lernen

11.6 Effektskizzen vereinfachen

Kapitel 12: Ich muss in einem Bereich vieles ändern. Muss ich die Dependencies für alle beteiligten Klassen aufheben?

12.1 Abfangpunkte

12.2 Ein Design mit Einschnürpunkten beurteilen

12.3 Fallen bei Einschnürpunkten

Kapitel 13: Ich muss etwas ändern, weiß aber nicht, welche Tests ich schreiben soll

13.1 Charakterisierungs-Tests

13.2 Klassen charakterisieren

13.3 Gezielt testen

13.4 Eine Heuristik für das Schreiben von Charakterisierungs-Tests

Kapitel 14: Dependencies von Bibliotheken bringen mich um

Kapitel 15: Meine Anwendung besteht nur aus API-Aufrufen

Kapitel 16: Ich verstehe den Code nicht gut genug, um ihn zu ändern

16.1 Notizen/Skizzen

16.2 Listing Markup

16.3 Scratch Refactoring

16.4 Ungenutzten Code löschen

Kapitel 17: Meine Anwendung hat keine Struktur

17.1 Die Geschichte des Systems erzählen

17.2 Naked CRC

17.3 Conversation Scrutiny

Kapitel 18: Der Test-Code ist im Weg

18.1 Konventionen für Klassennamen

18.2 Der Speicherort für Tests

Kapitel 19: Mein Projekt ist nicht objektorientiert. Wie kann ich es sicher ändern?

19.1 Ein einfacher Fall

19.2 Ein schwieriger Fall

19.3 Neues Verhalten hinzufügen

19.4 Die Objektorientierung nutzen

19.5 Es ist alles objektorientiert

Kapitel 20: Diese Klasse ist zu groß und soll nicht noch größer werden

20.1 Aufgaben erkennen

20.2 Andere Techniken

20.3 Die nächsten Schritte

20.4 Nach dem Extrahieren von Klassen

Kapitel 21: Ich ändere im ganzen System denselben Code

21.1 Erste Schritte

Kapitel 22: Ich muss eine Monster-Methode ändern und kann keine Tests dafür schreiben

22.1 Spielarten von Monstern

22.2 Monster mit automatischer Refactoring-Unterstützung zähmen

22.3 Die Herausforderung des manuellen Refactorings

22.4 Strategie

Kapitel 23: Wie erkenne ich, dass ich nichts kaputtmache?

23.1 »Hyperaware Editing«

23.2 »Single-Goal Editing«

23.3 »Preserve Signatures«

23.4 »Lean on the Compiler«

Kapitel 24: Wir fühlen uns überwältigt. Es wird nicht besser.

Teil III: Techniken zur Aufhebung von Dependencies

Kapitel 25: Techniken zur Aufhebung von Dependencies

25.1 »Adapt Parameter«

25.2 »Break Out Method Object«

25.3 »Definition Completion«

25.4 »Encapsulate Global References«

25.5 »Expose Static Method«

25.6 »Extract and Override Call«

25.7 »Extract and Override Factory Method«

25.8 »Extract and Override Getter«

25.9 »Extract Implementer«

25.10 »Extract Interface«

25.11 »Introduce Instance Delegator«

25.12 »Introduce Static Setter«

25.13 »Link Substitution«

25.14 »Parameterize Constructor«

25.15 »Parameterize Method«

25.16 »Primitivize Parameter«

25.17 »Pull Up Feature«

25.18 »Push Down Dependency«

25.19 »Replace Function with Function Pointer«

25.20 »Replace Global Reference with Getter«

25.21 Subclass and Override Method

25.22 Supersede Instance Variable

25.23 »Template Redefinition«

25.24 »Text Redefinition«

Anhang A: Refactoring

A.1 Extract Method

Anhang B: Glossar

Stichwortverzeichnis