Деталі електронної книги

Scala od podszewki

Scala od podszewki

Joshua Suereth D.

Eлектронна книга

Scala to słowo, które ostatnio nie schodzi z ust programistów Javy. Pod tą nazwą kryje się język łączący światy programowania funkcyjnego i obiektowego. Jego ogromną zaletą jest działanie w oparciu o wirtualną maszynę Javy. Pozwala to między innymi na bezproblemową komunikację i współdzielenie kodu między oboma językami. James Gosling, twórca Javy, zapytany o to, jakiego języka oprogramowania działającego w ten sposób użyłby obecnie (gdyby nie mógł wykorzystać Javy), odparł bez zastanowienia: „Scala!”. To chyba najlepszy dowód na to, że ten język wart jest Twojego czasu!

Dzięki tej książce opanujesz Scalę szybko i bezboleśnie, więc będziesz mógł wykorzystać jej zalety już w najbliższym projekcie. W trakcie lektury poznasz składnię, fundamentalne zasady tworzenia oprogramowania w Scali oraz konwencje kodowania w tym języku. W kolejnych rozdziałach dowiesz się, czym są niejawne widoki, jakie typy danych masz do dyspozycji i jakie są ich ograniczenia. Co jeszcze? Integracja Scali z Javą to niezwykle istotny temat, dający Ci pole do popisu! Ponadto poznasz wzorce stosowane w programowaniu funkcyjnym. Słowo wstępne do tej niezwykłej książki napisał sam Martin Odersky - twórca języka Scala! Niniejsza książka jest najlepszym kompendium wiedzy na temat programowania w tym języku. Musisz ją mieć!

Poznaj:

  • konwencje obowiązujące w Scali
  • składnię języka
  • najlepsze wzorce projektowe stosowane w programowaniu funkcyjnym
  • potencjał języka Scala!

Poznaj i wykorzystaj potęgę programowania funkcyjnego!

  • Słowo wstępne (7)
  • Przedmowa (9)
  • Podziękowania (11)
  • O książce (13)

Rozdział 1. Scala: język mieszany (17)

  • 1.1. Programowanie funkcyjne i obiektowe w jednym (18)
    • 1.1.1. Koncepty funkcyjne (20)
    • 1.1.2. Analiza konceptów funkcyjnych w Google Collections (22)
  • 1.2. Statyczne typowanie a ekspresywność kodu (23)
    • 1.2.1. Zamiana stron (24)
    • 1.2.2. Wnioskowanie na temat typów (24)
    • 1.2.3. Uproszczona składnia (25)
    • 1.2.4. Wartości i konwersje domniemane (26)
    • 1.2.5. Słowo kluczowe implicit (27)
  • 1.3. Wygodna współpraca z JVM (28)
    • 1.3.1. Java w Scali (28)
    • 1.3.2. Scala w Javie (29)
    • 1.3.3. Zalety JVM (30)
  • 1.4. Podsumowanie (31)

Rozdział 2. Podstawowe zasady (33)

  • 2.1. Eksperymenty w środowisku REPL (33)
    • 2.1.1. Programowanie sterowane eksperymentami (34)
    • 2.1.2. Obejście zachłannego parsowania (36)
    • 2.1.3. Elementy języka niedostępne w REPL (37)
  • 2.2. Myślenie wyrażeniami (38)
    • 2.2.1. Unikanie instrukcji return (39)
    • 2.2.2. Modyfikowalność (41)
  • 2.3. Obiekty niemodyfikowalne (43)
    • 2.3.1. Równoważność obiektów (44)
    • 2.3.2. Współbieżność (48)
  • 2.4. None zamiast null (51)
    • 2.4.1. Zaawansowane techniki wykorzystania klasy Option (52)
  • 2.5. Równoważność polimorficzna (55)
    • 2.5.1. Przykład: biblioteka obsługująca kalendarz (55)
    • 2.5.2. Polimorficzna implementacja metody equals (57)
  • 2.6. Podsumowanie (59)

Rozdział 3. Parę słów na temat konwencji kodowania (61)

  • 3.1. Unikanie konwencji pochodzących z innych języków (62)
    • 3.1.1. Porażka z blokami kodu (63)
  • 3.2. Wiszące operatory i wyrażenia w nawiasach (66)
  • 3.3. Znaczące nazwy zmiennych (67)
    • 3.3.1. Unikanie w nazwach znaku $ (68)
    • 3.3.2. Parametry nazwane i wartości domyślne (71)
  • 3.4. Oznaczanie przesłaniania metod (73)
  • 3.5. Adnotacje optymalizacyjne (78)
    • 3.5.1. Optymalizacja tableswitch (79)
    • 3.5.2. Optymalizacja wywołań ogonowych (81)
  • 3.6. Podsumowanie (84)

Rozdział 4. Obiektowość (85)

  • 4.1. W ciele obiektu lub cechy - tylko kod inicjalizujący (86)
    • 4.1.1. Opóźniona inicjalizacja (86)
    • 4.1.2. Wielokrotne dziedziczenie (87)
  • 4.2. Puste implementacje metod abstrakcyjnych w cechach (89)
  • 4.3. Kompozycja może obejmować dziedziczenie (93)
    • 4.3.1. Kompozycja i dziedziczenie razem (96)
    • 4.3.2. Klasyczne konstruktory... z niespodzianką (97)
  • 4.4. Wydzielenie interfejsu abstrakcyjnego do postaci osobnej cechy (99)
    • 4.4.1. Interfejsy, z którymi można porozmawiać (101)
    • 4.4.2. Nauka płynąca z przeszłości (102)
  • 4.5. Określanie typów zwracanych przez publiczne API (103)
  • 4.6. Podsumowanie (105)

Rozdział 5. Domniemane wartości i widoki podstawą ekspresywnego kodu (107)

  • 5.1. Słowo kluczowe implicit (108)
    • 5.1.1. Identyfikatory (dygresja) (109)
    • 5.1.2. Zakres i wiązania (111)
    • 5.1.3. Wyszukiwanie wartości domniemanych (115)
  • 5.2. Wzmacnianie klas za pomocą domniemanych widoków (119)
  • 5.3. Parametry domniemane i domyślne (124)
  • 5.4. Ograniczanie zakresu encji domniemanych (130)
    • 5.4.1. Przygotowywanie encji domniemanych do zaimportowania (131)
    • 5.4.2. Parametry i widoki domniemane bez podatku od importu (133)
  • 5.5. Podsumowanie (137)

Rozdział 6. System typów (139)

  • 6.1. Typy (140)
    • 6.1.1. Typy i ścieżki (141)
    • 6.1.2. Słowo kluczowe type (143)
    • 6.1.3. Typy strukturalne (144)
  • 6.2. Ograniczenia typów (151)
  • 6.3. Parametry typu i typy wyższego rzędu (153)
    • 6.3.1. Ograniczenia parametrów typu (153)
    • 6.3.2. Typy wyższego rzędu (155)
  • 6.4. Wariancja (156)
    • 6.4.1. Zaawansowane adnotacje wariancji (160)
  • 6.5. Typy egzystencjalne (163)
    • 6.5.1. Formalna składnia typów egzystencjalnych (165)
  • 6.6. Podsumowanie (167)

Rozdział 7. Łączenie typów z wartościami i widokami domniemanymi (169)

  • 7.1. Ograniczenia kontekstu i ograniczenia widoku (170)
    • 7.1.1. Kiedy stosować domniemane ograniczenia typu? (171)
  • 7.2. Dodawanie typów do parametrów domniemanych (172)
    • 7.2.1. Manifesty (172)
    • 7.2.2. Korzystanie z manifestów (173)
    • 7.2.3. Ograniczenia typu (175)
    • 7.2.4. Wyspecjalizowane metody (177)
  • 7.3. Klasy typu (178)
    • 7.3.1. FileLike jako klasa typu (181)
    • 7.3.2. Zalety klas typu (184)
  • 7.4. Egzekucja warunkowa z użyciem systemu typów (185)
    • 7.4.1. Heterogeniczne listy typowane (187)
    • 7.4.2. Cecha IndexedView (190)
  • 7.5. Podsumowanie (196)

Rozdział 8. Wybór odpowiedniej kolekcji (197)

  • 8.1. Wybór odpowiedniego rodzaju kolekcji (198)
    • 8.1.1. Hierarchia kolekcji (198)
    • 8.1.2. Traversable (200)
    • 8.1.3. Iterable (203)
    • 8.1.4. Seq (204)
    • 8.1.5. LinearSeq (205)
    • 8.1.6. IndexedSeq (207)
    • 8.1.7. Set (208)
    • 8.1.8. Map (208)
  • 8.2. Kolekcje niemodyfikowalne (210)
    • 8.2.1. Vector (210)
    • 8.2.2. List (212)
    • 8.2.3. Stream (213)
  • 8.3. Kolekcje modyfikowalne (216)
    • 8.3.1. ArrayBuffer (217)
    • 8.3.2. Nasłuchiwanie zdarzeń zmiany kolekcji za pomocą domieszek (217)
    • 8.3.3. Synchronizacja z użyciem domieszek (218)
  • 8.4. Zmiana czasu ewaluacji za pomocą widoków i kolekcji równoległych (218)
    • 8.4.1. Widoki (219)
    • 8.4.2. Kolekcje równoległe (221)
  • 8.5. Pisanie metod, które można wykorzystać na wszystkich typach kolekcji (223)
    • 8.5.1. Optymalizacja algorytmów dla różnych typów kolekcji (226)
  • 8.6. Podsumowanie (229)

Rozdział 9. Aktorzy (231)

  • 9.1. Kiedy stosować aktorów? (232)
    • 9.1.1. Zastosowanie aktorów do wyszukiwania (232)
  • 9.2. Typowane, przezroczyste referencje (235)
    • 9.2.1. Realizacja algorytmu rozprosz-zgromadź przy użyciu OutputChannel (236)
  • 9.3. Ograniczanie błędów do stref (240)
    • 9.3.1. Strefy błędu w przykładzie rozprosz-zgromadź (240)
    • 9.3.2. Ogólne zasady obsługi awarii (243)
  • 9.4. Ograniczanie przeciążeń za pomocą stref planowania (244)
    • 9.4.1. Strefy planowania (245)
  • 9.5. Dynamiczna topologia aktorów (247)
  • 9.6. Podsumowanie (251)

Rozdział 10. Integracja Scali z Javą (253)

  • 10.1. Różnice językowe pomiędzy Scalą a Javą (254)
    • 10.1.1. Różnice w opakowywaniu typów prostych (255)
    • 10.1.2. Widoczność (259)
    • 10.1.3. Nieprzekładalne elementy języka (260)
  • 10.2. Uwaga na domniemane konwersje (263)
    • 10.2.1. Tożsamość i równoważność obiektów (263)
    • 10.2.2. Łańcuchy domniemanych widoków (265)
  • 10.3. Uwaga na serializację w Javie (267)
    • 10.3.1. Serializacja klas anonimowych (269)
  • 10.4. Adnotowanie adnotacji (271)
    • 10.4.1. Cele adnotacji (272)
    • 10.4.2. Scala i pola statyczne (273)
  • 10.5. Podsumowanie (274)

Rozdział 11. Wzorce w programowaniu funkcyjnym (277)

  • 11.1. Teoria kategorii w informatyce (278)
  • 11.2. Funktory i monady oraz ich związek z kategoriami (281)
    • 11.2.1. Monady (284)
  • 11.3. Rozwijanie funkcji i styl aplikacyjny (286)
    • 11.3.1. Rozwijanie funkcji (286)
    • 11.3.2. Styl aplikacyjny (288)
  • 11.4. Monady jako przepływy pracy (291)
  • 11.5. Podsumowanie (295)

Skorowidz (297)

  • Назва: Scala od podszewki
  • Автор: Joshua Suereth D.
  • Оригінальна назва: Scala in Depth
  • Переклад: Justyna Walkowska
  • ISBN: 978-83-246-6062-9, 9788324660629
  • Дата видання: 2013-07-02
  • Формат: Eлектронна книга
  • Ідентифікатор видання: scalao
  • Видавець: Helion