reklama - zainteresowany?

Rails. Sztuka programowania - Helion

Rails. Sztuka programowania
ebook
Autor: Edward Benson
Tytuł oryginału: The Art of Rails
Tłumaczenie: Rafał Jońca
ISBN: 978-83-246-8476-2
stron: 336, Format: ebook
Data wydania: 2013-08-26
Księgarnia: Helion

Cena książki: 32,45 zł (poprzednio: 57,95 zł)
Oszczędzasz: 44% (-25,50 zł)

Dodaj do koszyka Rails. Sztuka programowania

Tagi: Rails - Programowanie

  • 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!

Dodaj do koszyka Rails. Sztuka programowania

 

Osoby które kupowały "Rails. Sztuka programowania", wybierały także:

  • Ruby on Rails. Ćwiczenia
  • Programowanie w języku Ruby. Mikrousługi i konteneryzacja
  • Ruby on Rails. Od podstaw
  • Programowanie w języku Ruby. Mikrousługi i konteneryzacja
  • Rails. Receptury

Dodaj do koszyka Rails. Sztuka programowania

Spis treści

Rails. Sztuka programowania eBook -- 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)

Dodaj do koszyka Rails. Sztuka programowania

Code, Publish & WebDesing by CATALIST.com.pl



(c) 2005-2024 CATALIST agencja interaktywna, znaki firmowe należą do wydawnictwa Helion S.A.