Praca z zastanym kodem Najlepsze techniki

Naucz się pracować na gotowych projektach!

Programiści uwielbiają brać udział w nowych projektach, być świadkami ewolucji kodu, mieć wpływ na wybór narzędzi i projektować ich architekturę. Niestety, w ogromnej większości przypadków muszą pracować z kodem mającym wiele lat i pisanym przez wiele osób. Jak sobie poradzić w takim środowisku? Jak dobrać techniki pracy do gotowego kodu? Na te i wiele innych podobnych pytań odpowiada ten wyjątkowy podręcznik.

Dzięki niemu dowiesz się, jak wprowadzać zmiany w zastanym kodzie, tworzyć testy automatyczne oraz modyfikować architekturę rozwiązania. Ponadto poznasz najlepsze techniki pracy z projektami niezorientowanymi obiektowo oraz przekonasz się, że można skutecznie poradzić sobie z przerośniętymi klasami i metodami. Ostatnia część książki została poświęcona technikom usuwania zależności. Ten podręcznik to lektura obowiązkowa każdego programisty. Dzięki niemu Twoja praca z zastanym kodem nabierze nowego sensu. Musisz ją mieć!

Dzięki tej książce:
- poradzisz sobie z zastanym kodem
- nauczysz się wprowadzać w nim zmiany
- zastosujesz testy automatyczne
- przeprowadzisz skuteczną refaktoryzację

Praca z zastanym kodem nie musi być nużąca!

Spis treści:

CZĘŚĆ I: MECHANIKA ZMIAN (19)

Rozdział 1. Zmiany w oprogramowaniu (21)

• Cztery powody wprowadzania zmian w oprogramowaniu (21)
• Ryzykowna zmiana (25)

Rozdział 2. Praca z informacją zwrotną (27)

• Co to jest testowanie jednostkowe? (30)
• Testy wyższego poziomu (32)
• Pokrycie testami (33)
• Algorytm dokonywania zmian w cudzym kodzie (36)

Rozdział 3. Rozpoznanie i separowanie (39)

• Fałszywi współpracownicy (41)

Rozdział 4. Model spoinowy (47)

• Ogromny arkusz z tekstem (47)
• Spoiny (48)
• Rodzaje spoin (51)

Rozdział 5. Narzędzia (63)

• Narzędzia do automatycznej refaktoryzacji (63)
• Obiekty pozorowane (65)
• Jarzmo testowania jednostkowego (66)
• Ogólne jarzmo testowe (71)

CZĘŚĆ II: ZMIANY W OPROGRAMOWANIU (73)

Rozdział 6. Nie mam zbyt wiele czasu, a muszę to zmienić (75)

• Kiełkowanie metody (77)
• Kiełkowanie klasy (80)
• Opakowywanie metody (85)
• Opakowywanie klasy (88)
• Podsumowanie (93)

Rozdział 7. Dokonanie zmiany trwa całą wieczność (95)

• Zrozumienie (95)
• Opóźnienie (96)
• Usuwanie zależności (97)
• Podsumowanie (102)

Rozdział 8. Jak mogę dodać nową funkcjonalność? (103)

• Programowanie sterowane testami (104)
• Programowanie różnicowe (110)
• Podsumowanie (119)

Rozdział 9. Nie mogę umieścić tej klasy w jarzmie testowym (121)

• Przypadek irytującego parametru (121)
• Przypadek ukrytej zależności (128)
• Przypadek konstrukcyjnego kłębowiska (131)
• Przypadek irytującej zależności globalnej (133)
• Przypadek straszliwych zależności dyrektyw include (141)
• Przypadek cebulowego parametru (144)
• Przypadek zaliasowanego parametru (147)

Rozdział 10. Nie mogę uruchomić tej metody w jarzmie testowym (151)

• Przypadek ukrytej metody (152)
• Przypadek "pomocnych" funkcji języka (155)
• Przypadek niewykrywalnych skutków ubocznych (158)

Rozdział 11. Muszę dokonać zmian. Które metody powinienem przetestować? (165)

• Myślenie o skutkach (166)
• Śledzenie w przód (171)
• Propagacja skutków (176)
• Narzędzia do wyszukiwania skutków (177)
• Wyciąganie wniosków z analizy skutków (179)
• Upraszczanie schematów skutków (180)

Rozdział 12. Muszę dokonać wielu zmian w jednym miejscu. Czy powinienem pousuwać zależności we wszystkich klasach, których te zmiany dotyczą? (183)

• Punkty przechwycenia (184)
• Ocena projektu z punktami zwężenia (191)
• Pułapki w punktach zwężenia (192)

Rozdział 13. Muszę dokonać zmian, ale nie wiem, jakie testy napisać (195)

• Testy charakteryzujące (196)
• Charakteryzowanie klas (199)
• Testowanie ukierunkowane (200)
• Heurystyka pisania testów charakteryzujących (205)

Rozdział 14. Dobijają mnie zależności biblioteczne (207)

Rozdział 15. Cała moja aplikacja to wywołania API (209)

Rozdział 16. Nie rozumiem wystarczająco dobrze kodu, żeby go zmienić (219)

• Notatki i rysunki (220)
• Adnotowanie listingów (221)
• Szybka refaktoryzacja (222)
• Usuwanie nieużywanego kodu (223)

Rozdział 17. Moja aplikacja nie ma struktury (225)

• Opowiadanie historii systemu (226)
• Puste karty CRC (230)
• Analiza rozmowy (232)

Rozdział 18. Przeszkadza mi mój testowy kod (235)

• Konwencje nazewnicze klas (235)
• Lokalizacja testu (236)

Rozdział 19. Mój projekt nie jest zorientowany obiektowo. Jak mogę bezpiecznie wprowadzać zmiany? (239)

• Prosty przypadek (240)
• Przypadek trudny (241)
• Dodawanie nowego zachowania (244)
• Korzystanie z przewagi zorientowania obiektowego (247)
• Wszystko jest zorientowane obiektowo (250)

Rozdział 20. Ta klasa jest za duża, a ja nie chcę, żeby stała się jeszcze większa (253)

• Dostrzeganie odpowiedzialności (257)
• Inne techniki (269)
• Posuwanie się naprzód (270)
• Po wyodrębnieniu klasy (273)

Rozdział 21. Wszędzie zmieniam ten sam kod (275)

• Pierwsze kroki (278)

Rozdział 22. Muszę zmienić monstrualną metodę, lecz nie mogę napisać do niej testów (293)

• Rodzaje monstrów (294)
• Stawianie czoła monstrom przy wsparciu automatycznej refaktoryzacji (297)
• Wyzwanie ręcznej refaktoryzacji (300)
• Strategia (307)

Rozdział 23. Skąd mam wiedzieć, czy czegoś nie psuję? (311)

• Superświadome edytowanie (312)
• Edytowanie jednego elementu naraz (313)
• Zachowywanie sygnatur (314)
• Wsparcie kompilatora (317)
• Programowanie w parach (318)

Rozdział 24. Czujemy się przytłoczeni. Czy nie będzie chociaż trochę lepiej? (321)

CZĘŚĆ III: TECHNIKI USUWANIA ZALEŻNOŚCI (325)

Rozdział 25. Techniki usuwania zależności (327)

• Adaptacja parametru (328)
• Wyłonienie obiektu metody (332)
• Uzupełnianie definicji (338)
• Hermetyzacja referencji globalnej (340)
• Upublicznienie metody statycznej (346)
• Wyodrębnienie i przesłonięcie wywołania (349)
• Wyodrębnienie i przesłonięcie metody wytwórczej (351)
• Wyodrębnienie i przesłonięcie gettera (353)
• Wyodrębnienie implementera (356)
• Wyodrębnienie interfejsu (361)
• Wprowadzenie delegatora instancji (367)
• Wprowadzenie statycznego settera (370)
• Zastępowanie biblioteki (375)
• Parametryzacja konstruktora (377)
• Parametryzacja metody (381)
• Uproszczenie parametru (383)
• Przesunięcie funkcjonalności w górę hierarchii (386)
• Przesunięcie zależności w dół hierarchii (390)
• Zastąpienie funkcji wskaźnikiem do funkcji (393)
• Zastąpienie referencji globalnej getterem (396)
• Utworzenie podklasy i przesłonięcie metody (398)
• Zastąpienie zmiennej instancji (401)
• Przedefiniowanie szablonu (405)
• Przedefiniowanie tekstu (409)

Dodatek: Refaktoryzacja (411)

• Wyodrębnianie metody (411)