Używamy cookies, aby ułatwić korzystanie z Portalu. Możesz określić warunki przechowywania, dostępu do plików cookies w Twojej przeglądarce. Dowiedz się więcej.
strona główna Strona główna | Nowości | Promocje | Zapowiedzi Twoje konto | Zarejestruj | Schowek | Kontakt | Pomoc
mapa działów
Szukaj: szukanie zaawansowane
Koszyk
Książki \ Programowanie

Czysta architektura. Struktura i design oprogramowania. Przewodnik dla profesjonalistów Język: 1

978-83-283-4225-5

Cena Brutto: 67.00

Cena netto: 63.81

Ilość:
Wersja: Drukowana
Autor Robert C. Martin
Liczba_stron 386
Wydawnictwo Helion
Oprawa miękka
Data_Wydania 2018-05-11

Czysta architektura

Struktura i design oprogramowania. Przewodnik dla profesjonalistów


Pierwsze linie kodu powstawały pół wieku temu. 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


    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)

powrót
 
Produkty Podobne
Agile. Retrospektywy w zarządzaniu standardami
Programowanie w ASP.NET Core
C++17 STL. Receptury
Programowanie strukturalne
Rozwijanie mikrousług w Pythonie. Budowa, testowanie, instalacja i skalowanie
Agile. Rusz głową!
Bardziej efektywny C#. 50 sposobów ulepszenia języka C#
Programowanie wieloplatformowe z C++ i wxWidgets 3
React Native. Tworzenie aplikacji mobilnych w języku JavaScript. Wydanie II
Inżynieria niezawodnych baz danych. Projektowanie systemów odpornych na błędy
Więcej produktów