Czysta architektura. Struktura i design oprogramowania. Przewodnik dla profesjonalistów - Robert C. Martin

Pierwsze linie kodu powstawały w połowie ubiegłego wieku. Komputery, na które tworzono te programy, w bardzo niewielkim stopniu przypominały współczesne maszyny. Niezależnie od upływu lat, postępu technologii i powstawania wymyślnych narzędzi, języków programowania czy frameworków pewne zasady tworzenia kodu pozostają niezmienne. Są takie same jak w czasie, gdy Alan Turing pisał pierwszy kod maszynowy w 1946 roku. Respektowanie tych zasad to warunek, że uzyska się oprogramowanie o czystej architekturze, czyli poprawne strukturalnie, łatwe w utrzymaniu i rozwijaniu, a przede wszystkim działające zgodnie z oczekiwaniami.

W tej książce w sposób jasny i bardzo interesujący przedstawiono uniwersalne zasady architektury oprogramowania wraz z szeregiem wskazówek dotyczących stosowania tych reguł w praktyce. Wyczerpująco zaprezentowano tu dostępne rozwiązania i wyjaśniono, dlaczego są one tak istotne dla sukcesu przedsięwzięcia. Publikacja jest wypełniona bardzo praktycznymi rozwiązaniami problemów, z którymi musi się mierzyć wielu programistów. Szczególnie cenne są uwagi dotyczące zapobiegania częstemu problemowi, jakim jest stopniowa utrata jakości kodu w miarę postępu projektu. Ta książka obowiązkowo powinna się znaleźć w podręcznej biblioteczce każdego architekta oprogramowania, analityka systemowego, projektanta i menedżera!

Z książki dowiesz się:

Do czego muszą dążyć architekci oprogramowania i w jaki sposób mogą osiągać te cele
Jak brzmią najważniejsze zasady projektowania oprogramowania związane z adresowaniem funkcji, separacją komponentów i zarządzaniem danymi
W jaki sposób paradygmaty oprogramowania wzmagają dyscyplinę pracy
Co podczas tworzenia oprogramowania jest więcej, a co jest mniej ważne
W jaki sposób implementować optymalne struktury dla sieci WWW, baz danych, konsoli i aplikacji osadzonych

Czysta architektura - doskonały kod!
Spis treści: Przedmowa (13)

Wstęp (17)

Podziękowania (21)

O autorze (23)

CZĘŚĆ I. WPROWADZENIE (25)

Rozdział 1. Czym są projekt i architektura? (27)

Cel? (28)
Studium przypadku (29)
Wnioski (35)

Rozdział 2. Opowieść o dwóch wartościach (37)

Zachowanie (38)
Architektura (38)
Ważniejsza wartość (39)
Macierz Eisenhowera (40)
Walka o architekturę (41)

CZĘŚĆ II. ZACZNIJ OD PODSTAW. PARADYGMATY OPROGRAMOWANIA (43)

Rozdział 3. Przegląd paradygmatów (45)

Programowanie strukturalne (46)
Programowanie obiektowe (46)
Programowanie funkcyjne (46)
Coś do przemyślenia (47)
Wnioski (47)

Rozdział 4. Programowanie strukturalne (49)

Dowód (50)
Ogłoszenie szkodliwości (52)
Dekompozycja funkcyjna (52)
Brak formalnych dowodów (53)
Metoda naukowa (53)
Testy (54)
Wnioski (55)

Rozdział 5. Programowanie obiektowe (57)

Hermetyzacja? (58)
Dziedziczenie? (61)
Polimorfizm? (63)
Wnioski (68)

Rozdział 6. Programowanie funkcyjne (69)

Kwadraty liczb całkowitych (70)
Niezmienność i architektura (71)
Podział zmienności (72)
Strumień zdarzeń (74)
Wnioski (75)

CZĘŚĆ III. REGUŁY PROJEKTOWE (77)

Rozdział 7. SRP - reguła jednej odpowiedzialności (81)

Symptom 1. Przypadkowa duplikacja (83)
Symptom 2. Złączenia (84)
Rozwiązania (85)
Wnioski (87)

Rozdział 8. Reguła otwarte-zamknięte (89)

Eksperyment myślowy (90)
Kontrola kierunku (94)
Ukrywanie informacji (94)
Wnioski (95)

Rozdział 9. Reguła otwarte-zamknięte (97)

Jak używać dziedziczenia? (98)
Problem z kwadratem i prostokątem (98)
Zasada LSP i architektura (99)
Przykład naruszenia zasady LSP (100)
Wnioski (101)

Rozdział 10. Zasada rozdzielania interfejsów (103)

Zasada ISP i język (105)
Zasada ISP i architektura (105)
Wnioski (106)

Rozdział 11. Zasada odwrócenia zależności (107)

Stabilne abstrakcje (108)
Fabryki (109)
Komponenty konkretne (110)
Wnioski (111)

CZĘŚĆ IV. ZASADY KOMPONENTÓW (113)

Rozdział 12. Komponenty (115)

Krótka historia komponentów (116)
Relokacje (119)
Konsolidatory (119)
Wnioski (121)

Rozdział 13. Spójność komponentów (123)

Zasada Reuse (Release Equivalence Principle) (124)
Zasada Common Closure Principle (125)
Zasada Common Reuse Principle (126)
Diagram napięć dla zasad spójności komponentów (127)
Wnioski (128)

Rozdział 14. Łączenie komponentów (131)

Zasada zależności niecyklicznych (132)
Projekt typu top-down (138)
Zasada stabilnych zależności (139)
Zasada stabilnych abstrakcji (144)
Wnioski (150)

CZĘŚĆ V. ARCHITEKTURA (151)

Rozdział 15. Czym jest architektura? (153)

Rozwój systemu (155)
Wdrożenia (155)
Działanie (156)
Konserwacja (157)
Zachowywanie dostępnych opcji (157)
Niezależność od urządzenia (159)
Spam (160)
Adresowanie fizyczne (162)
Wnioski (163)

Rozdział 16. Niezależność (165)

Przypadki użycia (166)
Działanie (166)
Rozwój (167)
Wdrożenia (167)
Otwarte opcje (168)
Oddzielanie warstw (168)
Rozdzielanie przypadków użycia (169)
Tryby rozdzielania (170)
Możliwość niezależnego rozwijania (171)
Niezależne wdrożenia (171)
Duplikacja (171)
Tryby rozdzielania (ponownie) (172)
Wnioski (174)

Rozdział 17. Granice. Wyznaczanie linii (175)

Dwie smutne historie (176)
FitNesse (179)
Jakie linie rysować i kiedy to robić? (181)
A co z wejściem i wyjściem? (183)
Architektura wtyczek (184)
A jednak wtyczki (185)
Wnioski (187)

Rozdział 18. Anatomia granic (189)

Przekraczanie granic (190)
Straszliwy monolit (190)
Instalowanie komponentów (192)
Wątki (193)
Procesy lokalne (193)
Usługi (194)
Wnioski (194)

Rozdział 19. Zasady i poziomy (195)

Poziomy (196)
Wnioski (199)

Rozdział 20. Reguły biznesowe (201)

Encje (202)
Przypadki użycia (203)
Modele żądania i odpowiedzi (205)
Wnioski (206)

Rozdział 21. Krzycząca architektura (207)

Motyw architektury (208)
Cel architektury (208)
A co z siecią WWW? (209)
Framework to narzędzie, a nie styl życia (209)
Testowanie architektury (210)
Wnioski (210)

Rozdział 22. Czysta architektura (211)

Zasada zależności (213)
Typowy scenariusz (217)
Wnioski (218)

Rozdział 23. Prezentery i skromne obiekty (219)

Wzorzec projektowy skromny obiekt (220)
Prezentery i widoki (220)
Testowanie i architektura (221)
Bramy do baz danych (221)
Mapowanie danych (222)
Serwisy (222)
Wnioski (223)

Rozdział 24. Granice częściowe (225)

Pomiń ostatni krok (226)
Granice jednowymiarowe (227)
Fasady (227)
Wnioski (228)

Rozdział 25. Warstwy i granice (229)

Hunt the Wumpus (230)
Czysta architektura? (231)
Przekraczanie strumieni (234)
Dzielenie strumieni (234)
Wnioski (236)

Rozdział 26. Komponent Main (239)

Najważniejszy detal (240)
Wnioski (243)

Rozdział 27. Serwisy, duże i małe (245)

Architektura serwisów? (246)
Zalety serwisów? (246)
Problem z kotkami (248)
Pomogą nam obiekty (249)
Serwisy bazujące na komponentach (251)
Sprawy ogólnosystemowe (251)
Wnioski (253)

Rozdział 28. Granice testów (255)

Testy jako komponenty systemu (256)
Projekt ułatwiający testy (257)
API testujące (257)
Wnioski (259)

Rozdział 29. Czysta architektura osadzona (261)

Test n-App-stawienia (264)
Problem docelowego sprzętu (266)
Wnioski (276)

CZĘŚĆ VI. SZCZEGÓŁY (277)

Rozdział 30. Baza danych jest szczegółem (279)

Relacyjne bazy danych (280)
Dlaczego systemy baz danych są takie powszechne? (280)
A gdyby nie było dysków? (282)
Szczegóły (282)
A co z wydajnością? (283)
Anegdota (283)
Wnioski (284)

Rozdział 31. Sieć WWW jest szczegółem (285)

Wieczne wahadło (286)
Rezultat (288)
Wnioski (289)

Rozdział 32. Frameworki są szczegółem (291)

Autorzy frameworków (292)
Małżeństwo asymetryczne (292)
Ryzyko (293)
Rozwiązanie (294)
Teraz ogłaszam was... (294)
Wnioski (295)

Rozdział 33. Studium przypadku. Sprzedaż filmów (297)

Produkt (298)
Analiza przypadków użycia (298)
Architektura komponentów (300)
Zarządzanie zależnościami (301)
Wnioski (302)

Rozdział 34. Zaginiony rozdział (303)

Pakowanie w warstwy (304)
Pakowanie według funkcji (306)
Porty i adaptery (306)
Pakowanie według komponentów (310)
Diabeł tkwi w szczegółach implementacji (314)
Organizacja a hermetyzacja (315)
Inne sposoby rozdzielania (318)
Wnioski. Zaginiona porada (319)

DODATKI (321)

Dodatek A. Archeologia architektury (323)

System księgowości Union (324)
Cięcie laserowe (331)
Monitorowanie odlewów aluminium (334)
4-TEL (335)
Komputer SAC (340)
Język C (344)
BOSS (346)
pCCU (347)
DLU/DRU (349)
VRS (351)
Elektroniczny recepcjonista (353)
System wysyłania serwisantów (355)
Clear Communications (358)
ROSE (360)
Egzamin na architekta (363)
Wnioski (365)

Posłowie (367)

Skorowidz (371)
O autorze: Robert C. Martin (Wujek Bob) jest programistą od 1970 roku. Jest uznanym mówcą na konferencjach całego świata. Napisał między innymi książki Mistrz czystego kodu. Kodeks postępowania profesjonalnych programistów (Helion, 2013) oraz UML for Java Programmers (Prentice Hall, 2003). Oprócz tego Martin opublikował setki artykułów, rozpraw i wpisów na blogach. Działał jako redaktor naczelny magazynu „The C++ Report” i był pierwszym przewodniczącym organizacji Agile Alliance. Założył i prowadzi międzynarodową firmę Object Mentor Inc., skupiającą doświadczonych programistów i menedżerów specjalizujących się we wspomaganiu firm w realizacji trudnych projektów.