Zwiększ elastyczność swojego kodu dzięki wzorcom projektowym!

• Jak rozpocząć przygodę z językiem Ruby?
• Jak wykorzystać drzemiące w nim możliwości?
• Jak zwiększyć elastyczność tworzonego kodu za pomocą wzorców projektowych?

• Podstawy programowania w języku Ruby
• Zastosowanie wzorców - takich jak Observer, Composite, Iterator, Command i wiele innych
• Wykorzystanie technik metaprogramowania do tworzenia obiektów niestandardowych
• Wykorzystanie wyrażeń regularnych
• Użycie języków dziedzinowych
• Sposób instalacji języka Ruby

Spis treści:

• Banda Czworga (32)
  
• Wzorce dla wzorców (33)
  
  • Oddzielaj elementy zmienne od elementów stałych (33)
  • Programuj pod kątem interfejsu, nie implementacji (34)
  • Stosuj kompozycję zamiast dziedziczenia (36)
  • Deleguj, deleguj i jeszcze raz deleguj (40)
  • Czy dane rozwiązanie rzeczywiście jest niezbędne (41)
• Czternaście z dwudziestu trzech (43)
  
• Wzorce projektowe w języku Ruby? (45)

• Interaktywny język Ruby (48)
  
• Przywitaj się ze światem (48)
  
• Zmienne (51)
  
• Typy Fixnum i Bignum (52)
  
• Liczby zmiennoprzecinkowe (53)
  
• W języku Ruby nie ma typów prostych (54)
  
• Kiedy brakuje obiektów... (55)
  
• Prawda, fałsz i nil (55)
  
• Decyzje, decyzje (57)
  
• Pętle (58)
  
• Więcej o łańcuchach (60)
  
• Symbole (63)
  
• Tablice (63)
  
• Tablice mieszające (65)
  
• Wyrażenia regularne (65)
  
• Nasza pierwsza klasa (66)
  
• Operacje na zmiennych egzemplarzy (68)
  
• Obiekt pyta: Kim jestem? (70)
  
• Dziedziczenie, podklasy i nadklasy (71)
  
• Opcje argumentów (72)
  
• Moduły (73)
  
• Wyjątki (76)
  
• Wątki (77)
  
• Zarządzanie odrębnymi plikami z kodem źródłowym (78)
  
• Podsumowanie (79)

• Jak stawić czoło typowym problemom (84)
  
• Izolowanie elementów zachowujących dotychczasową formę (85)
  
• Odkrywanie wzorca projektowego Template Method (88)
  
• Metody zaczepienia (89)
  
• Gdzie się właściwie podziały wszystkie te deklaracje? (92)
  
• Typy, bezpieczeństwo i elastyczność (93)
  
• Testy jednostkowe nie mają charakteru opcjonalnego (95)
  
• Używanie i nadużywanie wzorca projektowego Template Method (97)
  
• Szablony w praktycznych zastosowaniach (98)
  
• Podsumowanie (99)

• Deleguj, deleguj i jeszcze raz deleguj (102)
  
• Współdzielenie danych przez kontekst i strategię (104)
  
• Jeszcze raz o kaczym typowaniu (106)
  
• Obiekty Proc i bloki kodu (107)
  
• Krótka analiza kilku prostych strategii (111)
  
• Używanie i nadużywanie wzorca projektowego Strategy (112)
  
• Wzorzec Strategy w praktycznych zastosowaniach (113)
  
• Podsumowanie (114)

• Trzymamy rękę na pulsie (117)
  
• Jak skuteczniej trzymać rękę na pulsie? (119)
  
• Wyodrębnianie mechanizmu umożliwiającego obserwację (122)
  
• Stosowanie bloków kodu w roli obserwatorów (125)
  
• Odmiany wzorca projektowego Observer (126)
  
• Używanie i nadużywanie wzorca projektowego Observer (127)
  
• Wzorzec Observer w praktycznych zastosowaniach (129)
  
• Podsumowanie (130)

• Całość i części (134)
  
• Tworzenie kompozytów (136)
  
• Doskonalenie implementacji wzorca Composite z wykorzystaniem operatorów (140)
  
• A może tablica w roli kompozytu? (141)
  
• Kłopotliwe różnice (141)
  
• Wskaźniki w obie strony (142)
  
• Używanie i nadużywanie wzorca projektowego Composite (143)
  
• Kompozyty w praktycznych zastosowaniach (145)
  
• Podsumowanie (147)

• Iteratory zewnętrzne (149)
  
• Iteratory wewnętrzne (152)
  
• Iteratory wewnętrzne kontra iteratory wewnętrzne (153)
  
• Niezrównany moduł Enumerable (154)
  
• Używanie i nadużywanie wzorca projektowego Iterator (156)
  
• Iteratory w praktycznych zastosowaniach (158)
  
• Podsumowanie (161)

• Eksplozja podklas (164)
  
• Prostsze rozwiązanie (165)
  
• Stosowanie bloków kodu w roli poleceń (166)
  
• Rejestrowanie poleceń (167)
  
• Wycofywanie operacji za pomocą wzorca Command (170)
  
• Kolejkowanie poleceń (173)
  
• Używanie i nadużywanie wzorca projektowego Command (174)
  
• Wzorzec projektowy Command w praktycznych zastosowaniach (175)
  
  • Migracje w ramach interfejsu ActiveRecord (175)
  • Madeleine (176)
• Podsumowanie (179)

• Adaptery programowe (182)
  
• Minimalne niedociągnięcia (184)
  
• Czy alternatywą może być adaptowanie istniejących klas? (186)
  
• Modyfikowanie pojedynczych obiektów (187)
  
• Adaptować czy modyfikować? (188)
  
• Używanie i nadużywanie wzorca projektowego Adapter (190)
  
• Adaptery w praktycznych zastosowaniach (190)
  
• Podsumowanie (191)

• Rozwiązaniem są pośrednicy (194)
  
• Pośrednik ochrony (196)
  
• Pośrednicy zdalni (197)
  
• Pośrednicy wirtualni jako środek rozleniwiający (198)
  
• Eliminacja najbardziej uciążliwych elementów implementacji pośredników (200)
  
  • Metody i przekazywanie komunikatów (201)
  • Metoda method_missing (202)
  • Wysyłanie komunikatów (203)
  • Bezbolesne implementowanie pośredników (203)
• Używanie i nadużywanie pośredników (206)
  
• Wzorzec Proxy w praktycznych zastosowaniach (207)
  
• Podsumowanie (208)

• Dekoratory: lekarstwo na brzydki kod (212)
  
• Dekoracja formalna (217)
  
• Jak uprościć model delegacji zadań (218)
  
• Dynamiczna alternatywa dla wzorca projektowego Decorator (219)
  
  • Opakowywanie metod (219)
  • Dekorowanie za pomocą modułów (220)
• Używanie i nadużywanie wzorca projektowego Decorator (221)
  
• Dekoratory w praktycznych zastosowaniach (222)
  
• Podsumowanie (223)

• Jeden obiekt, dostęp globalny (225)
  
• Zmienne i metody klasowe (226)
  
  • Zmienne klasowe (226)
  • Metody klasowe (227)
• Pierwsza próba opracowania singletonu w Ruby (228)
  
  • Zarządzanie jedynym obiektem (229)
  • Upewnianie się, że istnieje tylko jeden (230)
• Moduł Singleton (231)
  
• Singletony leniwe i chciwe (232)
  
• Konstrukcje alternatywne względem klasycznego singletonu (232)
  
  • Zmienne globalne jako singletony (232)
  • Klasy jako singletony (233)
  • Moduły jako singletony (235)
• Pasy bezpieczeństwa kontra kaftan bezpieczeństwa (236)
  
• Używanie i nadużywanie wzorca projektowego Singleton (237)
  
  • Czy singletony nie są przypadkiem zwykłymi zmiennymi globalnymi? (237)
  • Właściwie iloma singletonami dysponujemy? (238)
  • Singletony i niezbędna wiedza (238)
  • Eliminowanie utrudnień związanych z testowaniem (240)
• Singletony w praktycznych zastosowaniach (241)
  
• Podsumowanie (242)

• Inny rodzaj kaczego typowania (244)
  
• Powrót wzorca projektowego Template Method (246)
  
• Sparametryzowane metody wytwórcze (248)
  
• Klasy to po prostu obiekty (251)
  
• Złe wieści: nasz program podbił świat (252)
  
• Grupowe tworzenie obiektów (253)
  
• Klasy to po prostu obiekty (raz jeszcze) (255)
  
• Korzystanie z nazw (257)
  
• Używanie i nadużywanie wzorców fabryk (258)
  
• Wzorce fabryk w praktycznych zastosowaniach (258)
  
• Podsumowanie (260)

• Budowa komputerów (264)
  
• Klasy budowniczych polimorficznych (267)
  
• Klasy budowniczych mogą też zapewnić bezpieczeństwo tworzenia obiektów (270)
  
• Klasy budowniczych wielokrotnego użytku (270)
  
• Lepsza implementacja budowniczych z wykorzystaniem magicznych metod (271)
  
• Używanie i nadużywanie wzorca projektowego Builder (272)
  
• Klasy budowniczych w praktycznych zastosowaniach (273)
  
• Podsumowanie (274)

• Język dostosowany do realizowanego zadania (276)
  
• Konstruowanie interpretera (277)
  
• Interpreter odnajdywania plików (279)
  
  • Odnajdywanie wszystkich plików (279)
  • Wyszukiwanie plików według nazw (280)
  • Wielkie pliki i pliki zapisywalne (281)
  • Bardziej złożone operacje wyszukiwania z uwzględnieniem logicznej negacji, koniunkcji i alternatywy (282)
• Tworzenie drzewa AST (284)
  
  • Prosty analizator składniowy (284)
  • Interpreter bez analizatora składniowego? (286)
  • Analiza składniowa danych języka XML czy YAML? (287)
  • Generowanie złożonych analizatorów składniowych za pomocą narzędzia Racc (288)
  • A może wykorzystać analizator samego języka Ruby? (288)
• Używanie i nadużywanie wzorca projektowego Interpreter (289)
  
• Interpretery w praktycznych zastosowaniach (290)
  
• Podsumowanie (291)

• Języki dziedzinowe (296)
  
• Język DSL kopii zapasowej (297)
  
• Czy to plik z danymi? Nie, to program! (297)
  
• Budowa języka PackRat (299)
  
• Łączenie opracowanych dotychczas elementów w jedną całość (300)
  
• Krytyczne spojrzenie na język PackRat (301)
  
• Doskonalenie języka PackRat (302)
  
• Używanie i nadużywanie wewnętrznych języków DSL (305)
  
• Wewnętrzne języki DSL w praktycznych zastosowaniach (305)
  
• Podsumowanie (307)

• Obiekty szyte na miarę metoda po metodzie (310)
  
• Obiekty niestandardowe tworzone moduł po module (312)
  
• Wyczarowywanie zupełnie nowych metod (313)
  
• Rzut okiem na wewnętrzną strukturę obiektu (317)
  
• Używanie i nadużywanie metaprogramowania (318)
  
• Metaprogramowanie w praktycznych zastosowaniach (319)
  
• Podsumowanie (322)

• Interfejs użytkownika dobry dla... programistów (325)
  
  • Przewidywanie przyszłych potrzeb (326)
  • Oszczędźmy użytkownikom powtarzania swojej woli (326)
  • Udostępnianie szablonów (327)
• Bramka wiadomości (327)
  
• Wybór adaptera (329)
  
• Ładowanie klas (331)
  
• Dodanie prostych zabezpieczeń (333)
  
• Ułatwianie użytkownikowi wejścia w świat naszego oprogramowania (335)
  
• Podsumowanie przykładu bramki wiadomości (336)
  
• Używanie i nadużywanie wzorca projektowego Convention Over Configuration (337)
  
• Wzorzec Convention Over Configuration w praktycznych zastosowaniach (338)
  
• Podsumowanie (339)

• Instalacja Ruby w systemie Microsoft Windows (347)
  
• Instalacja Ruby w systemie Linux i pozostałych systemach wywodzących się z systemu UNIX (348)
  
• System Mac OS X (348)

• Wzorce projektowe (349)
  
• Ruby (350)
  
• Wyrażenia regularne (352)
  
• Blogi i witryny internetowe (352)