.:$$:.
Poznaj nowoczesną metodykę wytwarzania oprogramowania w C#
- Jak stosować w praktyce zasady zwinnego wytwarzania oprogramowania?
- W jaki sposób wykorzystywać w projekcie diagramy UML?
- Jak korzystać z wzorców projektowych?
W związku ze stale rosnącymi oczekiwaniami użytkowników oprogramowania produkcja systemów informatycznych wymaga dziś korzystania z usystematyzowanych metod zarządzania. Projekt informatyczny, przy którym nie używa się sensownej metodologii wytwarzania, jest skazany na porażkę -- przekroczenie terminu, budżetu i niespełnienie wymagań funkcjonalnych. Kierowanie projektem zgodnie z określonymi zasadami również nie gwarantuje sukcesu, lecz znacznie ułatwia jego osiągnięcie. Na początku roku 2001 grupa ekspertów zawiązała zespół o nazwie Agile Alliance. Efektem prac tego zespołu jest metodologia zwinnego wytwarzania oprogramowania -- Agile.
Książka "Agile. Programowanie zwinne: zasady, wzorce i praktyki zwinnego wytwarzania oprogramowania w C#" to podręcznik metodologii Agile przeznaczony dla twórców oprogramowania korzystających z technologii .NET. Dzięki niemu poznasz podstawowe założenia i postulaty twórców Agile i nauczysz się stosować je w praktyce. Dowiesz się, jak szacować terminy i koszty, dzielić proces wytwarzania na iteracje i testować produkt. Zdobędziesz wiedzę na temat refaktoryzacji, diagramów UML, testów jednostkowych i wzorców projektowych. Przeczytasz także o publikowaniu kolejnych wersji oprogramowania.
- Techniki programowania ekstremalnego
- Planowanie projektu
- Testowanie i refaktoryzacja
- Zasady zwinnego programowania
- Modelowanie oprogramowania za pomocą diagramów UML
- Stosowanie wzorców projektowych
- Projektowanie pakietów i komponentów
Przekonaj się, ile czasu i pracy zaoszczędzisz,
stosując w projektach metodologię Agile.
Słowo wstępne (17)Przedmowa (21)
Podziękowania (31)
O autorach (33)
Część I Wytwarzanie zwinne (35)
Rozdział 1. Praktyki programowania zwinnego (37)
- Agile Alliance (38)
- Programiści i ich harmonijna współpraca jest ważniejsza od procesów i narzędzi (39)
- Działające oprogramowanie jest ważniejsze od wyczerpującej dokumentacji (40)
- Faktyczna współpraca z klientem jest ważniejsza od negocjacji zasad kontraktu (41)
- Reagowanie na zmiany jest ważniejsze od konsekwentnego realizowania planu (42)
- Podstawowe zasady (43)
- Konkluzja (46)
- Bibliografia (47)
- Praktyki programowania ekstremalnego (50)
- Cały zespół (50)
- Opowieści użytkownika (50)
- Krótkie cykle (51)
- Testy akceptacyjne (52)
- Programowanie w parach (53)
- Wytwarzanie sterowane testami (TDD) (54)
- Wspólna własność (54)
- Ciągła integracja (55)
- Równe tempo (56)
- Otwarta przestrzeń pracy (56)
- Gra planistyczna (57)
- Prosty projekt (57)
- Refaktoryzacja (59)
- Metafora (59)
- Konkluzja (61)
- Bibliografia (61)
- Wstępne poznawanie wymagań (64)
- Dzielenie i scalanie opowieści użytkownika (65)
- Planowanie wydań (66)
- Planowanie iteracji (66)
- Definiowanie warunków zakończenia projektu (67)
- Planowanie zadań (67)
- Iteracje (69)
- Śledzenie postępu (69)
- Konkluzja (70)
- Bibliografia (71)
- Wytwarzanie sterowane testami (74)
- Przykład projektu poprzedzonego testami (75)
- Izolacja testów (76)
- Eliminowanie powiązań (78)
- Testy akceptacyjne (79)
- Wpływ testów akceptacyjnych na architekturę oprogramowania (81)
- Konkluzja (82)
- Bibliografia (82)
- Prosty przykład refaktoryzacji
- generowanie liczb pierwszych (84)
- Testy jednostkowe (86)
- Refaktoryzacja (87)
- Ostatnie udoskonalenia (93)
- Konkluzja (97)
- Bibliografia (98)
- Gra w kręgle (100)
- Konkluzja (146)
- Przegląd reguł gry w kręgle (147)
Rozdział 7. Czym jest projektowanie zwinne? (153)
- Symptomy złego projektu (154)
- Symptomy złego projektu, czyli potencjalne źródła porażek (154)
- Sztywność (155)
- Wrażliwość (155)
- Nieelastyczność (156)
- Niedostosowanie do rzeczywistości (156)
- Nadmierna złożoność (156)
- Niepotrzebne powtórzenia (157)
- Nieprzejrzystość (157)
- Dlaczego oprogramowanie ulega degradacji (158)
- Program Copy (159)
- Przykład typowego scenariusza (159)
- Przykład budowy programu Copy w ramach projektu zwinnego (163)
- Konkluzja (166)
- Bibliografia (166)
- Definiowanie odpowiedzialności (170)
- Oddzielanie wzajemnie powiązanych odpowiedzialności (171)
- Trwałość (171)
- Konkluzja (172)
- Bibliografia (172)
- Omówienie zasady otwarte-zamknięte (174)
- Aplikacja Shape (177)
- Przykład naruszenia zasady OCP (177)
- Przykład pełnej zgodności z zasadą otwarte-zamknięte (180)
- Przewidywanie zmian i "naturalna" struktura (181)
- Przygotowywanie punktów zaczepienia (182)
- Stosowanie abstrakcji do jawnego zamykania oprogramowania dla zmian (184)
- Zapewnianie zamknięcia z wykorzystaniem techniki sterowania przez dane (185)
- Konkluzja (187)
- Bibliografia (187)
- Naruszenia zasady podstawiania Liskov (190)
- Prosty przykład (190)
- Przykład mniej jaskrawego naruszenia zasady LSP (192)
- Przykład zaczerpnięty z rzeczywistości (199)
- Wyodrębnianie zamiast dziedziczenia (205)
- Heurystyki i konwencje (208)
- Konkluzja (209)
- Bibliografia (209)
- Podział na warstwy (212)
- Odwracanie relacji własności (213)
- Zależność od abstrakcji (215)
- Prosty przykład praktycznego znaczenia zasady DIP (216)
- Odkrywanie niezbędnych abstrakcji (217)
- Przykład aplikacji Furnace (219)
- Konkluzja (221)
- Bibliografia (221)
- Zanieczyszczanie interfejsów (223)
- Odrębne klasy klienckie oznaczają odrębne interfejsy (225)
- Interfejsy klas kontra interfejsy obiektów (227)
- Separacja przez delegację (227)
- Separacja przez wielokrotne dziedziczenie (229)
- Przykład interfejsu użytkownika bankomatu (230)
- Konkluzja (237)
- Bibliografia (237)
- Diagramy klas (243)
- Diagramy obiektów (244)
- Diagramy sekwencji (245)
- Diagramy współpracy (246)
- Diagramy stanów (246)
- Konkluzja (247)
- Bibliografia (247)
- Po co modelować oprogramowanie? (249)
- Po co budować modele oprogramowania? (250)
- Czy powinniśmy pracować nad rozbudowanymi projektami przed przystąpieniem do kodowania? (251)
- Efektywne korzystanie z diagramów języka UML (251)
- Komunikacja z innymi programistami (252)
- Mapy drogowe (253)
- Dokumentacja wewnętrzna (255)
- Co powinniśmy zachowywać, a co można wyrzucać do kosza? (255)
- Iteracyjne udoskonalanie (257)
- Najpierw zachowania (257)
- Weryfikacja struktury (259)
- Wyobrażenie o kodzie (261)
- Ewolucja diagramów (262)
- Kiedy i jak rysować diagramy (264)
- Kiedy przystępować do tworzenia diagramów, a kiedy rezygnować z dalszego rysowania ich (264)
- Narzędzia CASE (265)
- A co z dokumentacją? (266)
- Konkluzja (267)
- Wprowadzenie (270)
- Zdarzenia specjalne (271)
- Superstany (272)
- Pseudostan początkowy i końcowy (274)
- Stosowanie diagramów skończonych maszyn stanów (274)
- Konkluzja (276)
- Migawka (278)
- Obiekty aktywne (279)
- Konkluzja (283)
- Pisanie przypadków użycia (286)
- Przebiegi alternatywne (287)
- Co jeszcze? (288)
- Prezentowanie przypadków użycia na diagramach (288)
- Konkluzja (290)
- Bibliografia (290)
- Wprowadzenie (292)
- Obiekty, linie życia, komunikaty i inne konstrukcje (292)
- Tworzenie i niszczenie obiektów (293)
- Proste pętle (295)
- Przypadki i scenariusze (295)
- Pojęcia zaawansowane (298)
- Pętle i warunki (298)
- Komunikaty, których przesyłanie wymaga czasu (300)
- Komunikaty asynchroniczne (302)
- Wiele wątków (307)
- Obiekty aktywne (308)
- Wysyłanie komunikatów do interfejsów (309)
- Konkluzja (310)
- Wprowadzenie (312)
- Klasy (312)
- Asocjacje (313)
- Relacje dziedziczenia (314)
- Przykładowy diagram klas (315)
- Omówienie szczegółowe (318)
- Stereotypy klas (318)
- Klasy abstrakcyjne (319)
- Właściwości (320)
- Agregacja (321)
- Kompozycja (322)
- Liczność (323)
- Stereotypy asocjacji (324)
- Klasy zagnieżdżone (326)
- Klasy asocjacji (326)
- Kwalifikatory asocjacji (327)
- Konkluzja (328)
- Bibliografia (328)
- Ekspres do kawy Mark IV Special (330)
- Specyfikacja (330)
- Popularne, ale niewłaściwe rozwiązanie (333)
- Nieprzemyślana abstrakcja (336)
- Poprawione rozwiązanie (337)
- Implementacja modelu abstrakcyjnego (343)
- Zalety projektu w tej formie (358)
- Implementacja projektu obiektowego (366)
- Bibliografia (366)
- Uproszczona specyfikacja systemu listy płac (368)
- Ćwiczenie (369)
- Przypadek użycia nr 1 - dodanie danych nowego pracownika (369)
- Przypadek użycia nr 2 - usunięcie danych pracownika (370)
- Przypadek użycia nr 3 - wysłanie karty czasu pracy (370)
- Przypadek użycia nr 4 - wysłanie raportu o sprzedaży (370)
- Przypadek użycia nr 5 - wysłanie informacji o opłacie na rzecz związku zawodowego (371)
- Przypadek użycia nr 6 - zmiana szczegółowych danych pracownika (371)
- Przypadek użycia nr 7 - wygenerowanie listy płatności na dany dzień (372)
- Proste polecenia (374)
- Transakcje (377)
- Fizyczny podział kodu (378)
- Czasowy podział kodu (379)
- Metoda Undo (379)
- Wzorzec projektowy Active Object (380)
- Konkluzja (386)
- Bibliografia (386)
- Wzorzec projektowy Template Method (388)
- Błędne zastosowanie wzorca Template Method (392)
- Sortowanie bąbelkowe (392)
- Wzorzec projektowy Strategy (396)
- Konkluzja (402)
- Bibliografia (402)
- Wzorzec projektowy Facade (404)
- Wzorzec projektowy Mediator (405)
- Konkluzja (407)
- Bibliografia (408)
- Wzorzec projektowy Singleton (410)
- Zalety (412)
- Wady (412)
- Wzorzec Singleton w praktyce (413)
- Wzorzec projektowy Monostate (415)
- Zalety (417)
- Wady (417)
- Wzorzec Monostate w praktyce (417)
- Konkluzja (423)
- Bibliografia (423)
- Omówienie (425)
- Konkluzja (429)
- Bibliografia (429)
- Uproszczona specyfikacja (432)
- Analiza przez omówienie przypadku użycia (433)
- Dodanie danych nowego pracownika (434)
- Usunięcie danych pracownika (436)
- Wysłanie karty czasu pracy (436)
- Wysłanie raportu o sprzedaży (437)
- Wysłanie informacji o opłacie na rzecz związku zawodowego (438)
- Zmiana szczegółowych danych pracownika (439)
- Wygenerowanie listy płac na dany dzień (441)
- Refleksja - identyfikacja abstrakcji (443)
- Wynagrodzenia wypłacane pracownikom (444)
- Harmonogram wypłat (444)
- Formy wypłat (446)
- Przynależność związkowa (446)
- Konkluzja (447)
- Bibliografia (447)
- Transakcje (450)
- Dodawanie danych pracowników (450)
- Usuwanie danych pracowników (456)
- Karty czasu pracy, raporty o sprzedaży i składki na związki zawodowe (458)
- Zmiana danych pracowników (466)
- Co ja najlepszego zrobiłem? (477)
- Wynagradzanie pracowników (480)
- Wynagradzanie pracowników etatowych (483)
- Wynagradzanie pracowników zatrudnionych w systemie godzinowym (486)
- Program główny (498)
- Baza danych (499)
- Konkluzja (500)
- O tym rozdziale (501)
- Bibliografia (502)
Rozdział 28. Zasady projektowania pakietów i komponentów (505)
- Pakiety i komponenty (506)
- Zasady spójności komponentów - ziarnistość (507)
- Zasada równoważności wielokrotnego użycia i wydawania (REP) (507)
- Zasada zbiorowego wielokrotnego stosowania (CRP) (509)
- Zasada zbiorowego zamykania (CCP) (510)
- Podsumowanie problemu spójności komponentów (511)
- Zasady spójności komponentów - stabilność (511)
- Zasada acyklicznych zależności (ADP) (511)
- Zasada stabilnych zależności (SDP) (519)
- Zasada stabilnych abstrakcji (SAP) (525)
- Konkluzja (530)
- Problem zależności (534)
- Statyczna kontra dynamiczna kontrola typów (536)
- Fabryki wymienne (537)
- Wykorzystywanie fabryk do celów testowych (538)
- Znaczenie fabryk (540)
- Konkluzja (540)
- Bibliografia (540)
- Notacja i struktura komponentów (542)
- Stosowanie zasady zbiorowego zamykania (CCP) (544)
- Stosowanie zasady równoważności wielokrotnego użycia i wydawania (REP) (546)
- Wiązanie komponentów i hermetyzacja (549)
- Mierniki (551)
- Stosowanie mierników dla aplikacji płacowej (553)
- Fabryki obiektów (556)
- Przebudowa granic spójności (558)
- Ostateczna struktura pakietów (559)
- Konkluzja (561)
- Bibliografia (561)
- Polecenia kompozytowe (565)
- Liczność albo brak liczności (566)
- Konkluzja (566)
- Zegar cyfrowy (568)
- Wzorzec projektowy Observer (589)
- Modele (590)
- Zarządzanie zasadami projektowania obiektowego (591)
- Konkluzja (592)
- Bibliografia (593)
- Wzorzec projektowy Abstract Server (596)
- Wzorzec projektowy Adapter (598)
- Forma klasowa wzorca Adapter (599)
- Problem modemu - adaptery i zasada LSP (599)
- Wzorzec projektowy Bridge (604)
- Konkluzja (607)
- Bibliografia (607)
- Wzorzec projektowy Proxy (610)
- Implementacja wzorca Proxy (615)
- Podsumowanie (630)
- Bazy danych, oprogramowanie pośredniczące i inne gotowe interfejsy (631)
- Wzorzec projektowy Table Data Gateway (634)
- Testowani`e konstrukcji TDG w pamięci (642)
- Test bram DB (643)
- Stosowanie pozostałych wzorców projektowych łącznie z bazami danych (646)
- Konkluzja (648)
- Bibliografia (648)
- Wzorzec projektowy Visitor (650)
- Wzorzec projektowy Acyclic Visitor (654)
- Zastosowania wzorca Visitor (660)
- Wzorzec projektowy Decorator (668)
- Wzorzec projektowy Extension Object (674)
- Konkluzja (686)
- Bibliografia (686)
- Zagnieżdżone wyrażenia switch-case (688)
- Wewnętrzny zasięg zmiennej stanu (691)
- Testowanie akcji (692)
- Zalety i wady (692)
- Tabele przejść (693)
- Interpretacja tabeli przejść (694)
- Zalety i wady (695)
- Wzorzec projektowy State (696)
- Wzorzec State kontra wzorzec Strategy (699)
- Zalety i wady (699)
- Kompilator maszyny stanów (SMC) (700)
- Plik Turnstile.cs wygenerowany przez kompilator SMC i pozostałe pliki pomocnicze (703)
- Zastosowania skończonej maszyny stanów (709)
- Wysokopoziomowa polityka działania graficznych interfejsów użytkownika (GUI) (709)
- Sterowanie interakcją z interfejsem GUI (711)
- Przetwarzanie rozproszone (712)
- Konkluzja (713)
- Bibliografia (714)
- Budowa bazy danych (716)
- Słaby punkt dotychczasowego projektu (716)
- Dodawanie danych nowych pracowników (719)
- Transakcje (732)
- Odczytywanie danych o pracownikach (738)
- Co jeszcze zostało do zrobienia? (753)
- Interfejs (758)
- Implementacja (759)
- Budowa okna (770)
- Okno główne systemu płacowego (778)
- Pierwsza odsłona (791)
- Konkluzja (792)
- Bibliografia (792)
- Rufus Inc. - Project Kickoff (793)
- Rupert Industries - Project Alpha (793)
Skorowidz (827)