Effektives Arbeiten mit Legacy Code

Table of contents

1. Umschlag
2. Titel
3. Impressum
4. Widmung
5. Inhaltsverzeichnis
6. Vorwort
7. Geleitwort
8. Danksagungen
9. Einführung – Wie man dieses Buch lesen sollte
10. Teil I Wie Wandel funktioniert
    1. 1 Software ändern
       1. 1.1 Vier Gründe, Software zu ändern
       2. 1.2 Riskante Änderungen
    2. 2 Mit Feedback arbeiten
       1. 2.1 Was sind Unit-Tests?
       2. 2.2 Higher-Level-Tests
       3. 2.3 Testabdeckung
       4. 2.4 Der Algorithmus zur Änderung von Legacy Code
    3. 3 Überwachung und Trennung
       1. 3.1 Kollaborateure simulieren
    4. 4 Das Seam-Modell
       1. 4.1 Ein riesiges Blatt mit Text
       2. 4.2 Seams
       3. 4.3 Seam-Arten
    5. 5 Tools
       1. 5.1 Automatisierte Refactoring-Tools
       2. 5.2 Mock-Objekte
       3. 5.3 Unit-Test-Harnische
       4. 5.4 Allgemeine Test-Harnische
11. Teil II Software ändern
    1. 6 Ich habe nicht viel Zeit und ich muss den Code ändern
       1. 6.1 Sprout Method
       2. 6.2 Sprout Class
       3. 6.3 Wrap Method
       4. 6.4 Wrap Class
       5. 6.5 Zusammenfassung
    2. 7 Änderungen brauchen eine Ewigkeit
       1. 7.1 Verständlichkeit
       2. 7.2 Verzögerungszeit
       3. 7.3 Dependencies aufheben
       4. 7.4 Zusammenfassung
    3. 8 Wie füge ich eine Funktion hinzu?
       1. 8.1 Test-Driven Development (TDD)
       2. 8.2 Programming by Difference
       3. 8.3 Zusammenfassung
    4. 9 Ich kann diese Klasse nicht in einen Test-Harnisch einfügen
       1. 9.1 Der Fall des irritierenden Parameters
       2. 9.2 Der Fall der verborgenen Dependency
       3. 9.3 Der Fall der verketteten Konstruktionen
       4. 9.4 Der Fall der irritierenden globalen Dependency
       5. 9.5 Der Fall der schrecklichen Include-Dependencies
       6. 9.6 Der Fall der Zwiebel-Parameter
       7. 9.7 Der Fall des Alias-Parameters
    5. 10 Ich kann diese Methode nicht in einem Test-Harnisch ausführen
       1. 10.1 Der Fall der verborgenen Methode
       2. 10.2 Der Fall der »hilfreichen« Sprachfunktion
       3. 10.3 Der Fall des nicht erkennbaren Nebeneffekts
    6. 11 Ich muss eine Änderung vornehmen. Welche Methoden sollte ich testen?
       1. 11.1 Effekte analysieren
       2. 11.2 Vorwärtsanalyse (Reasoning Forward)
       3. 11.3 Effektfortpflanzung (Effect Propagation)
       4. 11.4 Tools für Effektanalysen
       5. 11.5 Von der Effektanalyse lernen
       6. 11.6 Effektskizzen vereinfachen
    7. 12 Ich muss in einem Bereich vieles ändern. Muss ich die Dependencies für alle beteiligten Klassen aufheben?
       1. 12.1 Abfangpunkte
       2. 12.2 Ein Design mit Einschnürpunkten beurteilen
       3. 12.3 Fallen bei Einschnürpunkten
    8. 13 Ich muss etwas ändern, weiß aber nicht, welche Tests ich schreiben soll
       1. 13.1 Charakterisierungs-Tests
       2. 13.2 Klassen charakterisieren
       3. 13.3 Gezielt testen
       4. 13.4 Eine Heuristik für das Schreiben von Charakterisierungs-Tests
    9. 14 Dependencies von Bibliotheken bringen mich um
    10. 15 Meine Anwendung besteht nur aus API-Aufrufen
    11. 16 Ich verstehe den Code nicht gut genug, um ihn zu ändern
        1. 16.1 Notizen/Skizzen
        2. 16.2 Listing Markup
        3. 16.3 Scratch Refactoring
        4. 16.4 Ungenutzten Code löschen
    12. 17 Meine Anwendung hat keine Struktur
        1. 17.1 Die Geschichte des Systems erzählen
        2. 17.2 Naked CRC
        3. 17.3 Conversation Scrutiny
    13. 18 Der Test-Code ist im Weg
        1. 18.1 Konventionen für Klassennamen
        2. 18.2 Der Speicherort für Tests
    14. 19 Mein Projekt ist nicht objektorientiert. Wie kann ich es sicher ändern?
        1. 19.1 Ein einfacher Fall
        2. 19.2 Ein schwieriger Fall
        3. 19.3 Neues Verhalten hinzufügen
        4. 19.4 Die Objektorientierung nutzen
        5. 19.5 Es ist alles objektorientiert
    15. 20 Diese Klasse ist zu groß und soll nicht noch größer werden
        1. 20.1 Aufgaben erkennen
        2. 20.2 Andere Techniken
        3. 20.3 Die nächsten Schritte
        4. 20.4 Nach dem Extrahieren von Klassen
    16. 21 Ich ändere im ganzen System denselben Code
        1. 21.1 Erste Schritte
    17. 22 Ich muss eine Monster-Methode ändern und kann keine Tests dafür schreiben
        1. 22.1 Spielarten von Monstern
        2. 22.2 Monster mit automatischer Refactoring-Unterstützung zähmen
        3. 22.3 Die Herausforderung des manuellen Refactorings
        4. 22.4 Strategie
    18. 23 Wie erkenne ich, dass ich nichts kaputtmache?
        1. 23.1 Hyperaware Editing
        2. 23.2 Single-Goal Editing
        3. 23.3 Preserve Signatures
        4. 23.4 Lean on the Compiler
    19. 24 Wir fühlen uns überwältigt. Es wird nicht besser
12. Teil III Techniken zur Aufhebung von Dependencies
    1. 25 Techniken zur Aufhebung von Dependencies
       1. 25.1 Adapt Parameter
       2. 25.2 Break Out Method Object
       3. 25.3 Definition Completion
       4. 25.4 Encapsulate Global References
       5. 25.5 Expose Static Method
       6. 25.6 Extract and Override Call
       7. 25.7 Extract and Override Factory Method
       8. 25.8 Extract and Override Getter
       9. 25.9 Extract Implementer
       10. 25.10 Extract Interface
       11. 25.11 Introduce Instance Delegator
       12. 25.12 Introduce Static Setter
       13. 25.13 Link Substitution
       14. 25.14 Parameterize Constructor
       15. 25.15 Parameterize Method
       16. 25.16 Primitivize Parameter
       17. 25.17 Pull Up Feature
       18. 25.18 Push Down Dependency
       19. 25.19 Replace Function with Function Pointer
       20. 25.20 Replace Global Reference with Getter
       21. 25.21 Subclass and Override Method
       22. 25.22 Supersede Instance Variable
       23. 25.23 Template Redefinition
       24. 25.24 Text Redefinition
13. A Refactoring
    1. A.1 Extract Method
14. B Glossar