Architektura Lean w projektach Agile (ebook)(audiobook)(audiobook)
- Wydawnictwo:
- Helion
- Wydawnictwo:
- Helion
- Ocena:
- 3.0/6 Opinie: 1
- Stron:
- 320
- Druk:
- oprawa miękka
- 3w1 w pakiecie:
-
PDFePubMobi

Opis książki
Czytaj fragment
Programuj i organizuj kod z metodyką Lean!
Tempo rozwoju aplikacji wymusza stosowanie elastycznych sposobów wytwarzania oprogramowania. Książka ta została poświęcona architekturze Lean, która usprawni ten proces dzięki nowatorskiemu podejściu. Wykorzystaj je i przygotuj swoją aplikację na zmiany funkcjonalne, by użytkownicy mogli w pełni wykorzystać jej potencjał!
W trakcie lektury zapoznasz się z duchem Agile i Lean oraz przydzielisz najważniejsze role członkom projektu. Po tym niezwykle interesującym wstępie rozpoczniesz pasjonującą podróż po świecie architektury Lean. Dowiesz się, czym jest system, jak podzielić projekt na części i wybrać jego styl. W kolejnych rozdziałach zorganizujesz swój kod i przetestujesz zaprojektowaną architekturę. Znajdziesz tu wiele przykładów, które w najlepszy sposób przedstawiają założenia i intencje architektury Lean, z dużym naciskiem na sam kod. To obowiązkowa lektura dla wszystkich programistów i projektantów systemów informatycznych.
Dzięki tej książce:
- poznasz filozofię Agile i Lean
- zbudujesz kod odporny na zmiany
- zrozumiesz paradygmat DCI
- poznasz współczesne metody wytwarzania oprogramowania!
Twój przewodnik po architekturze Lean!
Oprogramowanie dla ludzi
Nadszedł czas na zmiany — po 30 latach powstała architektura DCI, która uzupełnia wizję programowania obiektowego!
Architektura Lean dąży do przesunięcia paradygmatu — wykorzystuje nowoczesne podejście do projektowania oprogramowania uwzględniające nowe, orzeźwiające spojrzenie metodyk Agile i Lean. Książka w przystępny sposób przedstawia wymagania zwinnego oprogramowania oraz często ignorowane racje dotyczące wymagań i architektury. Opisuje techniki wykraczające poza modną koncepcję opowieści użytkowników i pokazuje, jak w lekki, przyrostowy sposób, zgodny z duchem Agile, wykorzystać w tworzeniu oprogramowania przypadki użycia. Autorzy szczegółowo opisali paradygmat architektury DCI (Dane, kontekst i interakcje) pokazując sukces architektury DCI w tych miejscach, gdzie zastosowanie samych tylko języków obiektowych nie pozwoliło zintegrować projektu oprogramowania z rozumieniem ogólnej struktury biznesu przez użytkowników końcowych.
Niniejsza książka nie jest jednak poświęcona wyłącznie metodologii, ale koncentruje się na kodzie i jest w niej mnóstwo przykładów kodu. W książce omówiono między innymi następujące zagadnienia: produkcję Agile, zaangażowanie interesariuszy, aspekty organizacji zespołu projektowego, implementację przykładu architektury DCI w Scali, Pythonie i Javie i frameworku Qi4J.
Znany ekspert architektury oprogramowania James Coplien oraz ekspert w dziedzinie wymagań Agile — Gertrud Bjornvig — dzielą się swoją wiedzą z Czytelnikami prezentując konkretne praktyki projektowe. Dzięki nim:
- Stworzysz oprogramowanie, które bazuje na modelach mentalnych użytkowników końcowych, a nie na metodologiach projektowania.
- Napiszesz oprogramowanie, które można bezpośrednio zweryfikować z wymaganiami dotyczącymi jego zachowania.
- Zorganizujesz pracę zespołu w taki sposób, że wszyscy interesariusze będą się wzajemnie wspierać.
- Lepiej przygotujesz się na zmiany funkcjonalne w kodzie tworząc stabilny kod dziedzinowy.
Architektura Lean w projektach Agile rzuca nowe światło na ważne aspekty wytwarzania oprogramowania, które zostały zmarginalizowane lub zapomniane w wyniku ruchu Agile — niniejsza książka pomoże Czytelnikom odnaleźć nową drogę.
Podobne produkty
-
Przygoda z elektroniką Przygoda z elektroniką
Paweł Borkowski
-
Czysty kod. Podręcznik dobrego programisty Czysty kod. Podręcznik dobrego programisty
Robert C. Martin
-
English 4 IT. Praktyczny kurs języka angielskie... English 4 IT. Praktyczny kurs języka angielskiego dla specjalistów IT i nie tylko
Beata Błaszczyk
-
Kwalifikacja INF.03. Tworzenie i administrowani... Kwalifikacja INF.03. Tworzenie i administrowanie stronami i aplikacjami internetowymi oraz bazami danych. Część 1. Projektowanie stron internetowych. Podręcznik do nauki zawodu technik informatyk i technik programista
Jolanta Pokorska
-
Czysta architektura. Struktura i design oprogra... Czysta architektura. Struktura i design oprogramowania. Przewodnik dla profesjonalistów
Robert C. Martin
-
Vue.js 2. Wprowadzenie dla profesjonalistów Vue.js 2. Wprowadzenie dla profesjonalistów
Adam Freeman
Podobne produkty
-
Wielkie umysły programowania. Jak myślą i pracu... Wielkie umysły programowania. Jak myślą i pracują twórcy najważniejszych języków
Federico Biancuzzi, Shane Warden
-
English 4 IT. Praktyczny kurs języka angielskie... English 4 IT. Praktyczny kurs języka angielskiego dla specjalistów IT i nie tylko
Beata Błaszczyk
-
Biblia copywritingu Biblia copywritingu
Dariusz Puzyrkiewicz
-
Kwalifikacja EE.08. Montaż i eksploatacja syste... Kwalifikacja EE.08. Montaż i eksploatacja systemów komputerowych, urządzeń peryferyjnych i sieci. Część 1. Urządzenia techniki komputerowej. Podręcznik do nauki zawodu technik informatyk
Tomasz Kowalski, Tomasz Orkisz
-
Przygoda z elektroniką Przygoda z elektroniką
Paweł Borkowski
-
Algorytmy Data Science. Siedmiodniowy przewodni... Algorytmy Data Science. Siedmiodniowy przewodnik. Wydanie II
David Natingga
Szczegóły książki
- Tytuł oryginału:
- Lean Architecture: for Agile Software Development
- Tłumaczenie:
- Radosław Meryk
- ISBN Książki drukowanej:
- 978-83-246-8672-8, 9788324686728
- Data wydania książki drukowanej:
- 2014-05-23
- ISBN Ebooka:
- 978-83-246-8673-5, 9788324686735
- Data wydania ebooka:
-
2014-05-23
Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@ebookpoint.pl.
- Format:
- 168x237
- Numer z katalogu:
- 19662
- Rozmiar pliku Pdf:
- 3.2MB
- Rozmiar pliku ePub:
- 4.4MB
- Rozmiar pliku Mobi:
- 4.4MB
- Pobierz przykładowy rozdział PDF
Spis treści
- 1.1. Podwaliny: Lean i Agile (19)
- 1.2. Architektura Lean i wytwarzanie funkcji zgodnie z metodyką Agile (22)
- 1.3. Produkcja Agile (24)
- 1.3.1. Agile bazuje na architekturze Lean (24)
- 1.3.2. Zakres systemów Agile (25)
- 1.3.3. Agile i DCI (26)
- 1.4. Książka w bardzo małej pigułce (27)
- 1.5. Lean i Agile: kontrastujące i uzupełniające (28)
- 1.5.1. Sekret Lean (30)
- 1.6. Utracone praktyki (30)
- 1.6.1. Architektura (31)
- 1.6.2. Obsługa zależności pomiędzy wymaganiami (31)
- 1.6.3. Podstawy użyteczności (31)
- 1.6.4. Dokumentacja (32)
- 1.6.5. Zdrowy rozsądek, myślenie i opieka (35)
- 1.7. O czym ta książka nie jest? (36)
- 1.8. Agile, Lean, Scrum i inne metodologie (37)
- 1.9. Rys historyczny (38)
- 2.1. Zaangażuj interesariuszy (41)
- 2.2. Zdefiniowanie problemu (43)
- 2.3. Czym system jest: podstawa formy (43)
- 2.4. Czym system jest: siła napędowa systemu (45)
- 2.5. Projekt i kodowanie (46)
- 2.6. Odliczanie: 3, 2, 1... (47)
- 3.1. Strumień wartości (49)
- 3.1.1. Użytkownicy końcowi i inni interesariusze jako kotwice strumienia wartości (50)
- 3.1.2. Architektura w ramach strumienia wartości (51)
- 3.1.3. Sekret Lean (52)
- 3.2. Najważniejsi interesariusze (54)
- 3.2.1. Użytkownicy docelowi (56)
- 3.2.2. Biznes (60)
- 3.2.3. Klienci (61)
- 3.2.4. Eksperci dziedzinowi (64)
- 3.2.5. Deweloperzy i testerzy (66)
- 3.3. Elementy procesu angażowania interesariuszy (68)
- 3.3.1. Od czego zacząć? (68)
- 3.3.2. Zaangażowanie klienta (70)
- 3.4. Sieć interesariuszy: eliminowanie marnotrawstwa czasu (71)
- 3.4.1. Linia produkcyjna czy rój? (71)
- 3.4.2. Pierwsza rzecz, którą należy zbudować (73)
- 3.4.3. Utrzymuj jedność zespołu (74)
- 3.5. Nie ma szybkich rozwiązań, ale jest nadzieja (75)
- 4.1. Jakie cechy Agile mają definicje problemów? (78)
- 4.2. Jakie cechy Lean mają definicje problemów? (78)
- 4.3. Dobre i złe definicje problemów (79)
- 4.4. Problemy i rozwiązania (81)
- 4.5. Proces definiowania problemów (82)
- 4.5.1. Ceń bardziej polowanie niż nagrodę (82)
- 4.5.2. Własność problemu (83)
- 4.5.3. Przerost funkcjonalności (84)
- 4.6. Definicje problemu, cele, czartery, wizje i zamierzenia (84)
- 4.7. Dokumentacja? (85)
- 5.1. Kilka niespodzianek o architekturze (88)
- 5.1.1. Co Lean ma z tym wspólnego? (90)
- 5.1.2. Co Agile ma wspólnego z architekturą? (91)
- 5.2. Pierwszy krok w projekcie: podział na części (94)
- 5.2.1. Pierwszy podział: forma dziedzinowa a forma behawioralna (95)
- 5.2.2. Drugi podział: prawo Conwaya (96)
- 5.2.3. Rzeczywista złożoność podziału systemu (98)
- 5.2.4. Wymiary złożoności (99)
- 5.2.5. Dziedziny. Wyjątkowy podział (99)
- 5.2.6. Wracamy do wymiarów złożoności (101)
- 5.2.7. Architektura i kultura (104)
- 5.2.8. Wnioski na temat prawa Conwaya (105)
- 5.3. Drugi krok w projekcie: wybór stylu projektu (105)
- 5.3.1. Struktura a podział (106)
- 5.3.2. Podstawy stylu: części stałe i zmienne (107)
- 5.3.3. Zaczynamy od oczywistych części wspólnych i różnic (108)
- 5.3.4. Części wspólne, różnice i zakres (111)
- 5.3.5. Jawne wyrażanie części wspólnych i różnic (113)
- 5.3.6. Najpopularniejszy styl: programowanie obiektowe (116)
- 5.3.7. Inne style w obrębie świata von Neumanna (118)
- 5.3.8. Języki dziedzinowe i generatory aplikacji (120)
- 5.3.9. Formy skodyfikowane: języki wzorców (123)
- 5.3.10. Oprogramowanie dostawców zewnętrznych i inne paradygmaty (124)
- 5.4. Dokumentacja? (127)
- 5.4.1. Słownik dziedziny (127)
- 5.4.2. Przenoszenie architektury (128)
- 5.5. Tło historyczne (128)
- 6.1. Krok trzeci: szkic kodu (131)
- 6.1.1. Abstrakcyjne klasy bazowe (132)
- 6.1.2. Warunki wstępne, warunki końcowe i asercje (136)
- 6.1.3. Skalowanie algorytmów: druga strona statycznych asercji (142)
- 6.1.4. Forma a dostępne usługi (143)
- 6.1.5. Rusztowanie (144)
- 6.1.6. Testowanie architektury (146)
- 6.2. Relacje w architekturze (149)
- 6.2.1. Typy relacji (149)
- 6.2.2. Testowanie relacji (150)
- 6.3. Programowanie obiektowe "po nowemu" (151)
- 6.4. Ile architektury? (153)
- 6.4.1. Równowaga pomiędzy BUFD a YAGNI (154)
- 6.4.2. Jeden rozmiar nie pasuje wszystkim (154)
- 6.4.3. Kiedy architektura jest gotowa? (156)
- 6.5. Dokumentacja? (156)
- 6.6. Tło historyczne (157)
- 7.1. Co system robi? (160)
- 7.1.1. Opowieści użytkowników: początek (160)
- 7.1.2. Wykorzystanie specyfikacji i przypadków użycia (161)
- 7.1.3. Pomoc należy się także programistom (162)
- 7.1.4. Kilometraż nie zawsze jest taki sam (163)
- 7.2. Kto będzie korzystać z naszego oprogramowania? (164)
- 7.2.1. Profile użytkowników (164)
- 7.2.2. Osoby (164)
- 7.2.3. Profile użytkowników czy osoby? (165)
- 7.2.4. Role użytkowników i terminologia (165)
- 7.3. Do czego użytkownicy chcą wykorzystać nasze oprogramowanie? (166)
- 7.3.1. Lista własności (166)
- 7.3.2. Diagramy przepływu danych (166)
- 7.3.3. Osoby i scenariusze (167)
- 7.3.4. Narracje (167)
- 7.3.5. Projektowanie aplikacji sterowane zachowaniami (167)
- 7.3.6. Teraz, gdy jesteśmy rozgrzani... (168)
- 7.4. Dlaczego użytkownicy chcą korzystać z naszego oprogramowania? (169)
- 7.5. Konsolidacja tego, co system robi (170)
- 7.5.1. Widok helikoptera (172)
- 7.5.2. Ustawianie sceny (177)
- 7.5.3. Odtwarzanie scenariusza słonecznego dnia (178)
- 7.5.4. Dodawanie interesujących rzeczy (183)
- 7.5.5. Od przypadków użycia do ról (191)
- 7.6. Podsumowanie (193)
- 7.6.1. Wsparcie przepływu pracy użytkowników (193)
- 7.6.2. Wsparcie dla testów blisko prac rozwojowych (193)
- 7.6.3. Wsparcie dla wydajnego podejmowania decyzji na temat funkcjonalności (194)
- 7.6.4. Wsparcie dla nowo powstających wymagań (odchyleń) (194)
- 7.6.5. Wsparcie dla planowania wydań (194)
- 7.6.6. Uzyskanie danych wejściowych do opracowania architektury (195)
- 7.6.7. Budowanie w zespole zrozumienia przedmiotu pracy (195)
- 7.7. "To zależy": kiedy przypadki użycia nie są dobre? (196)
- 7.7.1. Klasyczne programowanie obiektowe: architektury atomowych zdarzeń (196)
- 7.8. Testowanie użyteczności (197)
- 7.9. Dokumentacja? (198)
- 7.10. Tło historyczne (200)
- 8.1. Obraz z góry: wzorzec projektowy Model-View-Controller-User (201)
- 8.1.1. Czym jest program? (202)
- 8.1.2. Czym jest program Agile? (203)
- 8.1.3. MVC bardziej szczegółowo (204)
- 8.1.4. MVC-U: to nie koniec opowieści (205)
- 8.2. Forma i architektura systemów zdarzeń atomowych (208)
- 8.2.1. Obiekty dziedziny (208)
- 8.2.2. Role obiektów, interfejsy i Model (208)
- 8.2.3. Refleksje: przypadki użycia, architektury zdarzeń atomowych i algorytmy (211)
- 8.2.4. Przypadek specjalny: odwzorowanie ról obiektów na obiekty typu jeden do wielu (212)
- 8.3. Aktualizacja logiki dziedziny: rozwijanie metod, faktoryzacja i refaktoryzacja (212)
- 8.3.1. Tworzenie nowych klas i wypełnianie istniejących namiastek funkcji (213)
- 8.3.2. Powrót do przyszłości: po prostu stare, dobre programowanie obiektowe (215)
- 8.3.3. Narzędzia analizy i projektowania (215)
- 8.3.4. Faktoryzacja (216)
- 8.3.5. Uwaga na refaktoryzację (216)
- 8.4. Dokumentacja? (217)
- 8.5. Do czego te wszystkie artefakty? (217)
- 8.6. Tło historyczne (218)
- 9.1. Czasami inteligentne obiekty po prostu są niewystarczające (219)
- 9.2. DCI w pigułce (220)
- 9.3. Przegląd architektury DCI (221)
- 9.3.1. Części modelu mentalnego użytkownika końcowego, o których zapomnieliśmy (221)
- 9.3.2. Wprowadzenie ról obiektowych z metodami (223)
- 9.3.3. Sztuczki z cechami (225)
- 9.3.4. Klasy kontekstu: jedna w każdym przypadku użycia (226)
- 9.4. DCI na przykładzie (229)
- 9.4.1. Dane wejściowe do projektu (229)
- 9.4.2. Od przypadków użycia do algorytmów (230)
- 9.4.3. Bezmetodowe role obiektów: framework dla identyfikatorów (232)
- 9.4.4. Podział algorytmów pomiędzy role obiektowe z metodami (234)
- 9.4.5. Framework kontekstu (241)
- 9.4.6. Warianty i sztuczki w architekturze DCI (259)
- 9.5. Aktualizacja logiki dziedziny (261)
- 9.5.1. Porównanie DCI ze stylem architektury zdarzeń atomowych (261)
- 9.5.2. Szczególne aspekty logiki dziedzinowej w architekturze DCI (263)
- 9.6. Obiekty kontekstu w modelu mentalnym użytkownika końcowego: rozwiązanie odwiecznego problemu (265)
- 9.7. Do czego te wszystkie artefakty? (269)
- 9.8. Nie tylko C++: DCI w innych językach (272)
- 9.8.1. Scala (272)
- 9.8.2. Python (273)
- 9.8.3. C# (273)
- 9.8.4. ...a nawet w Javie (273)
- 9.8.5. Przykład z rachunkami w Smalltalku (274)
- 9.9. Dokumentacja? (274)
- 9.10. Tło historyczne (275)
- 9.10.1. DCI a programowanie aspektowe (275)
- 9.10.2. Inne podejścia (276)
O autorach (11)
Wstęp (13)
1. Wprowadzenie (19)
2 . Produkcja Agile w pigułce (41)
3. Zaangażowanie interesariuszy (49)
4. Definiowanie problemu (77)
5. Czym jest system? Część I. Architektura Lean (87)
6. Czym jest system? Część II. Kodowanie (131)
7. Co system robi: funkcje systemu (159)
8. Kodowanie: podstawowy montaż (201)
9. Kodowanie: architektura DCI (219)
10. Epilog (277)
A. Implementacja przykładu architektury DCI w Scali (279)
B. Przykład implementacji rachunków w Pythonie (283)
C. Przykład implementacji rachunków w C# (287)
D. Przykład implementacji rachunków w Ruby (291)
E. Qi4j (297)
F. Przykład implementacji rachunków w Squeaku (299)
Bibliografia (307)
Skorowidz (317)
Oceny i opinie klientów (1)
(0)
(0)
(0)
(1)
(0)
(0)
3 oceniona przez: kupmikawe, 2016-02-07