Książka jest NOWA,
w stanie IDEALNYM.
Niezależnie od ilości zakupionych książek płacisz tylko jednorazowy koszt wysyłki. Rails. Sztuka programowania
Wydawnictwo: Helion
- Jak osiągnąć największe korzyści z architektury MVC?
- Jak programować, korzystając z bloków?
- Jak tworzyć Web API?
Ruby on Rails przebojem wdarł się na rynek szkieletów aplikacji internetowych. Stworzony w architekturze MVC z wykorzystaniem popularnego języka Ruby, został entuzjastycznie przyjęty przez społeczność programistów. Główne założenia tego projektu to łatwość i przyjemność tworzenia kodu, a co za tym idzie -- szybkie i efektywne tworzenie aplikacji internetowych. Liczba rozwiązań, które powstały z wykorzystaniem tego szkieletu, świadczy o jego wysokiej jakości oraz znacząco wpływa na wzrost popularności samego języka Ruby.
Jeżeli ta książka znalazła się w Twoich rękach, to z pewnością powyższe wiadomości nie są Ci obce. Kierowana jest ona do programistów, którzy znają już Ruby on Rails i pragną pogłębić swoją wiedzę. Dzięki książce "Rails. Sztuka programowania" dowiesz się, jak organizować swój kod tak, aby osiągnąć najwyższą efektywność i zachować zgodność z ideą DRY (Don"t Repeat Yourself). Poznasz zasady zaawansowanego programowania w języku Ruby wraz z metaprogramowaniem oraz nauczysz się korzystać z programowania opartego na blokach. Ponadto zapoznasz się z wzorcami projektowymi dla technologii AJAX, interfejsami programistycznymi dla WWW, dekompozycją kodu HTML oraz nauczysz się w wydajny sposób rozwijać schemat bazy danych. Z pewnością zainteresuje Cię rozdział poświęcony programowaniu sterowanym zachowaniem. Te i wiele innych informacji znajdziesz w niniejszej książce, która wydaje się być obowiązkową dla każdego programisty Ruby on Rails!
- Cała prawda o aplikacjach internetowych
- Koncepcja Rails
- Architektura MVC
- Zarządzanie cyklem życia aplikacji
- Korzyści z zastosowania architektury MVC
- Zastosowanie technologii ActiveRecord
- Tworzenie Web API
- Wykorzystanie zasobów oraz obsługa żądań REST
- Zastosowanie formatów XML, RSS, RDF
- Sposoby ograniczania dostępu do API
- Wzorce zastosowań technologii AJAX
- Zasady programowania z wykorzystaniem bloków
- Mieszanie i łatanie klas
- Wykorzystanie dynamicznego kodu
- RSpec -- programowanie sterowane zachowaniem
- Cykl programowania
Opanuj sztukę programowania w Ruby on Rails!
Spis treści:
O autorze (11)
Podziękowania (13)
Wprowadzenie (15)
Rozdział 1. Rozwój nowego systemu witryn internetowych (21)
- Rails, sztuka i nowy internet (23)
- Sztuka i inżynieria (23)
- Nowe witryny WWW (24)
- Prawda o aplikacjach internetowych (25)
- Historia pacjenta - witryny internetowe (26)
- Od dokumentów do interfejsów (29)
- Upadek semantyki (30)
- Witajcie, aplikacje internetowe (33)
- Pojawienie się nowego podejścia (40)
Rozdział 2. Koncepcja Rails (41)
- W jednej części szkielet (43)
- Konfiguracja (43)
- Kod (45)
- Proces (46)
- W jednej części język (48)
- Modele w Rails (49)
- Zadania specyficzne dla stron WWW (51)
- JavaScript (52)
- Moduły dodatkowe (53)
- W dwóch częściach sposób myślenia (53)
- Witryny internetowe to aplikacje MVC (54)
- Aplikacje internetowe to ekosystemy (54)
- Konwencja ponad konfigurację (55)
- Małe założenie przebywa długą drogę (56)
- Kwestie estetyczne (57)
- Wyzwalające ograniczenia (58)
- Zbyt mocno się powtarzasz (60)
- Testowanie nie jest opcjonalne (62)
- Sieć to zbiór zasobów, a nie usług (63)
- Podsumowanie (64)
- Złoty środek nie istnieje (65)
- Optymizuj swój sposób kodowania, zanim przystąpisz do optymalizacji kodu (65)
Rozdział 3. Serwer jako aplikacja (67)
- Model-widok-kontroler w wersji skróconej (69)
- MVC i strony WWW (71)
- Proces projektowy MVC (72)
- Widok to specyfikacja (73)
- Przykład - portal społecznościowy dla kucharzy (74)
- Zarządzanie cyklem życia aplikacji (78)
- Myśl w sposób lekki, nie inżynieryjny (78)
- Myśl w sposób kontrolowany, a nie organiczny (79)
- Strzeż się operacji na otwartym sercu (79)
- Podsumowanie (80)
Rozdział 4. Osiągnięcie jak największych korzyści z M, V i C (81)
- Najlepsza dokumentacja interfejsów jest gratis (82)
- Model (83)
- Obiekty modeli powinny się nawzajem rozumieć (84)
- Użyj wyjątków, by zwiększyć czytelność kodu (86)
- Odwzorowanie z wierszy na obiekty (89)
- Asocjacje polimorficzne (90)
- Świat poza ActiveRecord (92)
- Widok (92)
- Problem zmiennej (93)
- JavaScript w stylu Rails (94)
- Fragmenty jako atomy i molekuły (95)
- Wybór odpowiednich fragmentów (97)
- Widok to nie tylko HTML (99)
- Kontroler (100)
- CRUD do wielokrotnego zastosowania (101)
- Rusztowanie w Rails to zbiór operacji CRUD (102)
- Obsługa akcji dwukrokowych (103)
- Kiedy przekazać prace na zewnątrz (106)
- Kiedy refaktoryzować (110)
- Podsumowanie (111)
Rozdział 5. Piękne interfejsy aplikacji (113)
- Dwa wielkie pomysły na Web API (115)
- Nowy adres URL - adresacja zagadnień, nie plików (115)
- Aplikacja to interfejs (117)
- Odwzorowania adresów (118)
- Anatomia wywołania Web API (121)
- Nakładanie API (121)
- Metoda respond_to (122)
- Zapis wyniku w formacie innym niż HTML (124)
- Dodanie własnych typów MIME (127)
- Rejestracja typów w Rails (128)
- Tworzenie własnego typu MIME (129)
- Ograniczanie dostępu do API w sposób zgodny z Rails (129)
- Uwierzytelnienie użytkownika (130)
- Algorytm ograniczający (131)
- Wprowadzenie ograniczeń za pomocą filtrów (132)
- Co z usługami SOAP i XML-RPC (133)
- Interfejs usługi (134)
- Implementacja usługi (135)
- Tworzenie struktur (136)
- Podsumowanie (137)
Rozdział 6. Zasoby i REST (139)
- Sieć zasobów (141)
- Identyfikacja zasobów (141)
- Mówienie o zasobach (142)
- Reprezentacja zasobów (142)
- REST (143)
- HTTP, czyli CRUD dla zasobów (144)
- Definiowanie aplikacji w kategorii zasobów (146)
- Komunikacja z klientem, czyli zasoby jako API (151)
- Inny sposób, czyli sieć to komputer (151)
- REST i Rails (153)
- Odwzorowanie zasobów w routerze (153)
- Ponieważ świat nie jest idealny, nadal potrzebujemy odwzorowań nazwanych (154)
- Automatycznie tworzone odwzorowania (156)
- Rusztowanie dla zasobów (158)
- Zagnieżdżone zasoby (158)
- Zasoby jako singletony czy zasoby tradycyjne (161)
- Podsumowanie (162)
Rozdział 7. Pięć stylów AJAX-a (163)
- Wielkie sekrety (165)
- Niekoniecznie AJAX stanowi najtrudniejszy element systemu (165)
- AJAX wymaga podjęcia trudnych decyzji projektowych (166)
- Nawet w Rails można zdecydować się na własną bibliotekę JavaScriptu (167)
- Pięć stylów AJAX-a (169)
- Styl pośrednika (171)
- Styl fragmentowy (173)
- Styl marionetkowy (175)
- Kompilacja do JavaScriptu (177)
- Styl bezpośredniej edycji w aplikacji (179)
- AJAX jako jeszcze jeden interfejs programistyczny (181)
- AJAX w stylu Rails (183)
- Kontroler ajaksowy ze stylem fragmentowym (i AJAX CRUD) (183)
- Kontrolery ajaksowe ze stylem marionetkowym (i RJS) (186)
- Elegancka degradacja (189)
- Cofanie się ze stylu fragmentowego (189)
- Wycofywanie się z bogatych interfejsów użytkownika (191)
- Podsumowanie (192)
Rozdział 8. Zabawa z blokami (193)
- Bloki jako sposób programowania (196)
- Porównanie metod, procedur i bloków (200)
- Metody (200)
- Procedury (204)
- Bloki (205)
- Przenoszenie się między blokami i procedurami (206)
- Duży eksperyment z zasięgiem (207)
- Eksperyment 1. - na bloki wpływa zmiana ich środowiska źródłowego (208)
- Eksperyment 2. - bloki mogą wpłynąć na środowisko, z którego się wywodzą (210)
- Wzorce blokowe i bloki w Rails (212)
- Iteracja (212)
- Programowanie aspektowe (214)
- Tworzenie danych wyjściowych w HTML-u i XML-u (218)
- Funkcje o podwójnym zastosowaniu (220)
- Wywołania zwrotne (220)
- Podsumowanie (222)
Rozdział 9. Mieszanie i łatanie klas (223)
- Dołączenia (225)
- Organizacja kodu w formie modułów (225)
- Metody w modułach (227)
- Dołączanie modułów do klas (228)
- Dołączenia w Rails (232)
- Małpie łatanie (236)
- Metoda eval - tyle drzwi do interpretera (237)
- Rodzeństwo metody eval (239)
- Dobra technika tworzenia łat (245)
- Podsumowanie (249)
Rozdział 10. Kod, który pisze kod (który pisze kod) (251)
- Jeszcze raz o dynamicznym kodzie i DSL (253)
- Makra piszące kod (254)
- Tworzenie metod w locie za pomocą define_method (254)
- Przykład użycia define_method - Pentagon i Kreml (255)
- Zasięg i define_method (257)
- Zastosowanie define_method w makrach Rails (258)
- Podsumowanie makr (260)
- Wywoływanie nieistniejących metod - obiekty dostosowujące się do sposobów korzystania z nich (261)
- Kilka prostych przykładów (262)
- Przykład - skrót dla Array.each (263)
- Uważaj na wyłapywanie wszystkiego (266)
- Wzorce metody method_missing (267)
- Implementacja wzorców method_missing (268)
- Obiekty sterowane danymi - tworzenie tłumacza komputerowego (272)
- Introspekcja (274)
- Zmienne i stałe (275)
- Metody (276)
- Moduły (277)
- Podsumowanie (278)
Rozdział 11. Jak przestałem się martwić i pokochałem schemat bazy danych (279)
- Bazy danych w aplikacjach internetowych - stos LAMP (280)
- Myślenie w kategoriach migracji (282)
- Tworzenie migracji (284)
- Przeprowadzanie migracji danych (286)
- Rozwój schematu w większym zespole (286)
- Populacja bazy danymi produkcyjnymi (288)
- Niewielkie zestawy danych - populacja danych w migracji (289)
- Zestawy danych średniej wielkości - pliki danych (290)
- Duże zestawy danych - pliki zrzutów bazy danych (291)
- Gdy baza danych nie wystarcza (293)
- Hierarchia obiektów modeli (293)
- Przechowywanie list, słowników i innych elementów (297)
- Własne funkcje pobierające i ustawiające (299)
- Podsumowanie (300)
Rozdział 12. RSpec - programowanie sterowane zachowaniem (301)
- Programowanie sterowane zachowaniem (303)
- RSpec - BDD dla Ruby on Rails (305)
- Cykl programowania specyfikacji (305)
- Pisanie specyfikacji (306)
- Implementacja przykładów (308)
- Dopasowania (309)
- Własne dopasowania (311)
- Przed i po (313)
- Przykładowy cykl programowania (314)
- Część 1. Tworzenie historyjki (314)
- Część 2. Tworzenie specyfikacji (315)
- Część 3. Inicjalizacja i napisanie prostego testu (316)
- Część 4. Tworzenie testów zachowań motywujących do pisania kodu (318)
- Część 5. Uzupełnianie implementacji testów zachowań (319)
- Ale to nie wszystko (321)
- Podsumowanie (322)
Skorowidz (323)
|
