Tworzenie oprogramowania nie może być procesem powolnym. DziÅ› zespoÅ‚y projektowe muszÄ… cechować siÄ™ elastycznoÅ›ciÄ… i dynamikÄ… dziaÅ‚ania, aby odnieść sukces. Wymagania stawiane kodowi mogÄ… wielokrotnie siÄ™ zmieniać podczas projektu. Oznacza to, że wprowadzanie zmian do kodu powinno być proste i możliwie maÅ‚o pracochÅ‚onne. Deweloperzy, którzy wdrożą zasady programowania zwinnego i bÄ™dÄ… przestrzegać zwiÄ…zanych z nimi dobrych praktyk, bÄ™dÄ… w stanie sprostać tym wymaganiom.

Niniejsza książka jest przeznaczona dla Å›rednio zaawansowanych programistów, którzy dobrze opanowali tworzenie kodu zorientowanego obiektowo i chcÄ… przyswoić sobie najlepsze praktyki programistyczne. Książka stanowi pomost miÄ™dzy teoriÄ… a praktykÄ…, uÅ‚atwiajÄ…cy wdrożenie w codziennej pracy wzorców projektowych, zasad SOLID, testów jednostkowych czy refaktoringu. WyjaÅ›niono tu stosowanie zawiÅ‚ych reguÅ‚, takich jak „otwarte – zamkniÄ™te”, zasad podstawienia Liskova, metod wstrzykiwania zależnoÅ›ci czy zwiÄ™kszania adaptywnoÅ›ci kodu za pomocÄ… interfejsów. Przedstawiono również pewne antywzorce projektowe wraz ze wskazówkami, w jaki sposób można ich uniknąć i zapewnić potrzebnÄ… funkcjonalność bez utraty elastycznoÅ›ci kodu.

Najważniejsze zagadnienia:

• metodologie Scrum i kanban,
• zależnoÅ›ci i warstwy architektury kodu,
• testy i refaktoring,
• odwracanie zależnoÅ›ci,
• wiÄ…zanie i spójność kodu.

Gary McLean Hall jest programistÄ… i architektem oprogramowania. Jest cenionym konsultantem, który specjalizuje siÄ™ w dobrych wzorcach i praktykach programistycznych. PracowaÅ‚ w wielu zespoÅ‚ach ukierunkowanych na tworzenie adaptywnego kodu w takich firmach, jak Eidos, Xerox, Nephila Capital czy The LateRooms Group. W swojej pracy zawsze szukaÅ‚ zÅ‚otego Å›rodka pomiÄ™dzy tworzeniem funkcjonalnego produktu i wysokiej jakoÅ›ci jego kodu źródÅ‚owego. Kod adaptywny: solidny, elastyczny i Å‚atwy w utrzymaniu!

Osoby które kupowały "Adaptywny kod. Zwinne programowanie, wzorce projektowe i SOLID-ne zasady. Wydanie II", wybierały także:

• F# 4.0 dla zaawansowanych. Wydanie IV 96,45 zÅ‚, (29,90 zÅ‚ -69%)
• Systemy reaktywne. Wzorce projektowe i ich stosowanie 65,31 zÅ‚, (20,90 zÅ‚ -68%)
• Scratch. Komiksowa przygoda z programowaniem 36,06 zÅ‚, (11,90 zÅ‚ -67%)
• GameMaker. Kurs video. Kompleksowy przewodnik tworzenia gier platformowych 154,58 zÅ‚, (55,65 zÅ‚ -64%)
• JavaScript. Kurs video. Programowanie funkcyjne i reaktywne 98,98 zÅ‚, (39,59 zÅ‚ -60%)

Spis treści

Adaptywny kod. Zwinne programowanie, wzorce projektowe i SOLID-ne zasady. Wydanie II eBook -- spis treści

Wprowadzenie (11)

CZĘŚĆ I. FRAMEWORKI ZWINNE

Rozdział 1. Wprowadzenie do metodologii Scrum (21)

• Scrum kontra model kaskadowy (24)
• Role i obowiÄ…zki (26)
  
  • WÅ‚aÅ›ciciel produktu (26)
  • Scrum master (27)
  • ZespóÅ‚ deweloperski (28)
• Artefakty (29)
  
  • Tablica Scruma (29)
  • Wykresy i wskaźniki (41)
  • Rejestry (45)
• Sprint (47)
  
  • Planowanie wydania (47)
  • Planowanie sprintu (48)
  • Codzienne spotkania Scruma (50)
  • Demo sprintu (51)
  • Retrospektywa sprintu (52)
  • Kalendarz Scruma (54)
• Zwinność w prawdziwym Å›wiecie (55)
  
  • Sztywność (55)
  • Brak testowalnoÅ›ci (56)
  • Wskaźniki (57)
• Podsumowanie (59)

Rozdział 2. Wprowadzenie do metodologii kanban (61)

• Kanban - szybki poczÄ…tek (62)
  
  • Radiator informacyjny (62)
• Ograniczanie pracy w trakcie (66)
  
  • Ochrona przed zmianÄ… (66)
  • Definiowanie "ukoÅ„czenia" (67)
• Ceremonie sterowane zdarzeniami (68)
• Klasy usÅ‚ug (69)
  
  • Umowy o gwarantowanym poziomie Å›wiadczenia usÅ‚ug (69)
  • Limity WIP dla klas usÅ‚ug (71)
  • Ludzie jako klasy usÅ‚ug (71)
• Analiza (72)
  
  • Czas dostarczenia i czas cyklu (72)
  • Kumulatywne diagramy przepÅ‚ywu (73)
• Podsumowanie (81)

CZĘŚĆ II. PODSTAWY TWORZENIA ADAPTYWNEGO KODU

Rozdział 3. Zależności i warstwy (85)

• ZależnoÅ›ci (86)
  
  • Prosty przykÅ‚ad (87)
  • ZależnoÅ›ci platformowe (90)
  • ZależnoÅ›ci zewnÄ™trzne (92)
  • Modelowanie zależnoÅ›ci za pomocÄ… grafu skierowanego (93)
• ZarzÄ…dzanie zależnoÅ›ciami (97)
  
  • Implementacje i interfejsy (97)
  • Zapach instrukcji new (98)
  • Alternatywne sposoby tworzenia obiektów (101)
  • RozwiÄ…zywanie zależnoÅ›ci (103)
  • ZarzÄ…dzanie zależnoÅ›ciami za pomocÄ… projektów NuGet (112)
• Warstwy (117)
  
  • Popularne wzorce warstwowania (118)
  • Zagadnienia przecinajÄ…ce (123)
  • Warstwowanie asymetryczne (124)
• Podsumowanie (126)

Rozdział 4. Interfejsy i wzorce projektowe (127)

• Czym jest interfejs? (127)
  
  • SkÅ‚adnia (128)
  • Jawna implementacja (130)
  • Polimorfizm (134)
• Wzorce tworzenia adaptywnego kodu (135)
  
  • Wzorzec Zerowy Obiekt (135)
  • Wzorzec Adapter (140)
  • Wzorzec Strategia (143)
• Dodatkowe funkcjonalnoÅ›ci (145)
  
  • Kacze typowanie (145)
  • Domieszki (149)
  • PÅ‚ynne interfejsy (153)
• Podsumowanie (155)

Rozdział 5. Testy (157)

• Testy jednostkowe (158)
  
  • Przygotuj, wykonaj, zweryfikuj (158)
  • Programowanie sterowane testami (162)
  • Bardziej zaawansowane testy (166)
• Wzorce testów jednostkowych (180)
  
  • Tworzenie elastycznych testów (180)
• Wzorzec Budowniczy testów jednostkowych (182)
  
  • Wzorzec Budowniczy (182)
  • Uwidacznianie przeznaczenia testu jednostkowego (183)
• Przede wszystkim testy (185)
  
  • Co to jest TDD? (185)
  • Wzorzec TDD (186)
  • Wzorzec TFD (187)
• Inne testy (187)
  
  • Piramida testów (188)
  • PrzeciwieÅ„stwa piramidy testów (189)
  • Diagram testowy (190)
• Testy profilaktyczne i lecznicze (192)
  
  • Jak zmniejszyć wskaźnik MTTR? (193)
• Podsumowanie (194)

Rozdział 6. Refaktoryzacja (195)

• Wprowadzenie do refaktoryzacji (195)
  
  • Zmiana istniejÄ…cego kodu (196)
  • Nowy typ konta (204)
• Agresywna refaktoryzacja (208)
  
  • Czerwone - zielone - refaktoryzacja... Przeprojektowanie (209)
• Adaptacja zastanego kodu (209)
  
  • Technika zÅ‚otego wzorca (210)
• Podsumowanie (216)

CZĘŚĆ III. SOLID-NY KOD

Rozdział 7. Zasada pojedynczej odpowiedzialności (219)

• Opis problemu (219)
  
  • Refaktoryzacja poprawiajÄ…ca czytelność kodu (222)
  • Refaktoryzacja zwiÄ™kszajÄ…ca abstrakcyjność kodu (226)
• Zasada pojedynczej odpowiedzialnoÅ›ci i wzorzec Dekorator (233)
  
  • Wzorzec Kompozyt (234)
  • Dekoratory predykatu (237)
  • Dekoratory warunkowe (240)
  • Leniwe dekoratory (241)
  • Dekoratory logujÄ…ce (242)
  • Dekoratory profilujÄ…ce (243)
  • Dekorowanie wÅ‚aÅ›ciwoÅ›ci i zdarzeÅ„ (246)
• Podsumowanie (247)

Rozdział 8. Zasada "otwarty/zamknięty" (249)

• Wprowadzenie do zasady "otwarty/zamkniÄ™ty" (249)
  
  • Definicja Meyera (249)
  • Definicja Martina (250)
  • Usuwanie bÅ‚Ä™dów (250)
  • "Åšwiadomość" kodu klienckiego (251)
• Punkty rozszerzeÅ„ (251)
  
  • Kod bez punktów rozszerzeÅ„ (251)
  • Metody wirtualne (252)
  • Metody abstrakcyjne (253)
  • Dziedziczenie interfejsu (254)
  • "Projektuj pod kÄ…tem dziedziczenia albo blokuj dziedziczenie" (254)
• Chroniona zmienność (255)
  
  • Przewidywana zmienność (255)
  • Stabilny interfejs (255)
  • WÅ‚aÅ›ciwa adaptywność (256)
  • Przewidywana zmienność a spekulatywne uogólnienie (256)
  • Potrzebujesz aż tylu interfejsów? (257)
• Podsumowanie (258)

Rozdział 9. Zasada podstawienia Liskov (259)

• Wprowadzenie do zasady podstawienia Liskov (259)
  
  • Oficjalna definicja zasady LSP (259)
  • ReguÅ‚y tworzÄ…ce zasadÄ™ LSP (260)
• Kontrakty (261)
  
  • Warunki poczÄ…tkowe (262)
  • Warunki koÅ„cowe (263)
  • Inwarianty (264)
  • ReguÅ‚y kontraktowe w zasadzie LSP (266)
  • Kontrakty kodu (272)
• Kowariancja i kontrawariancja (278)
  
  • Definicje (278)
  • ReguÅ‚y systemu typów w zasadzie LSP (284)
• Podsumowanie (287)

RozdziaÅ‚ 10. Segregacja interfejsów (289)

• PrzykÅ‚ad segregacji interfejsów (289)
  
  • Prosty interfejs CRUD (290)
  • ZapamiÄ™tywanie danych (295)
  • Dekorowanie wielu interfejsów (298)
• Tworzenie kodu klienckiego (300)
  
  • Wiele implementacji, wiele instancji (301)
  • Jedna implementacja, jedna instancja (303)
  • Antywzorzec "interfejsowa mieszanka" (304)
• Dzielenie interfejsów (304)
  
  • Wymagania kodu klienckiego (304)
  • Wymagania architektury aplikacji (310)
  • Interfejsy z pojedynczymi metodami (314)
• Podsumowanie (315)

Rozdział 11. Odwracanie zależności (317)

• Planowanie zależnoÅ›ci (317)
  
  • Antywzorzec Åšwita (318)
  • Wzorzec Schody (320)
• PrzykÅ‚ad abstrakcyjnego projektu (321)
  
  • Abstrakcje (322)
  • Konkretne polecenia (322)
  • WyodrÄ™bnianie funkcjonalnoÅ›ci (325)
  • Ulepszony kod kliencki (329)
  • Abstrakcje obsÅ‚ugujÄ…ce zapytania (332)
  • Dalsze abstrakcje (333)
• Podsumowanie (334)

CZĘŚĆ IV. STOSOWANIE ADAPTYWNYCH TECHNIK

Rozdział 12. Wstrzykiwanie zależności (337)

• Skromne poczÄ…tki (337)
  
  • Aplikacja Lista zadaÅ„ (340)
  • Tworzenie grafu obiektów (342)
• Nie tylko proste wstrzykiwanie (358)
  
  • Antywzorzec Lokalizator UsÅ‚ug (358)
  • Wzorzec Nielegalne Wstrzykiwanie (361)
  • KorzeÅ„ kompozycji (363)
  • Konwencje zamiast konfiguracji (368)
• Podsumowanie (371)

RozdziaÅ‚ 13. Sprzężenie, spójność, wspóÅ‚zależność (373)

• Sprzężenie i spójność kodu (373)
  
  • Sprzężenie (373)
  • Spójność (374)
• WspóÅ‚zależność (375)
  
  • Nazwa (376)
  • Typ (377)
  • Znaczenie (377)
  • Algorytm (378)
  • Pozycja (379)
  • Kolejność wykonania (379)
  • Czas (379)
  • Wartość (379)
  • Tożsamość (380)
  • OkreÅ›lanie stopnia wspóÅ‚zależnoÅ›ci (380)
  • Lokalność (380)
  • Nieoficjalna wspóÅ‚zależność (380)
  • WspóÅ‚zależność statyczna i dynamiczna (381)
• Podsumowanie (381)

DODATKI

Dodatek. Adaptywne narzędzia (385)

• Kontrola kodu źródÅ‚owego w systemie Git (385)
  
  • Tworzenie kopii repozytorium (387)
  • PrzeÅ‚Ä…czenie na innÄ… gałąź (388)
• CiÄ…gÅ‚a integracja (388)

Skorowidz (391)