Scala od podszewki

01-08-2014, 15:54
Aukcja w czasie sprawdzania była zakończona.

Cena kup teraz: 33 zł

Użytkownik ksiazka_z_pasja

numer aukcji: 4387709302

Miejscowość Gliwice

Koniec: 01-08-2014, 15:25

Dodatkowe informacje:
Stan: Nowy
Okładka: miękka
Rok wydania (xxxx): 2013
Kondycja: bez śladów używania
Tematyka: C++

Mercurius Gliwice Sp. z o.o.
ul. Prymasa S. Wyszyńskiego 14 b
44-100 Gliwice
pn - pt 10.00 - 18.00
sb 10.00 - 14.00

e-mail:
[zasłonięte]@ksiegarniagliwice.pl
tel. 32 [zasłonięte] 19
fax. 32 [zasłonięte] 22

Bank PKO BP
12 1020 [zasłonięte] 2[zasłonięte]4010002 [zasłonięte] 027277

Po wylicytowaniu przedmiotu koniecznie wypełnij formularz dostawy, jeśli chcesz zmienić adres dostawy - zrób to właśnie tutaj.

Do zakupionych książek dostaniesz paragon (na życzenie fakturę VAT), gwarantujące Ci rozpatrzenie reklamacji.

Kontaktując się z nami, zawsze używaj swojego nicka, pozwoli to nam szybciej zająć się Twoją sprawą.

Każdą przesyłkę starannie pakujemy w tekturowe pudełko albo kopertę ochronną, tak aby w stanie nienaruszonym dotarła do odbiorcy.

Za przesyłkę płacisz raz.
Oszczędź na kosztach wysyłki,
połącz zamówienia z:

ksiazka_z_pasja
ksiazka_gliwice
MercuriusGliwice

Scala od podszewki

Josuha Suereth

wydawnictwo: Helion
rok wydania: 2013
stron: 304
format: 168 x 237
oprawa: miękka

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!

SPIS TREŚCI:

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)

Połącz zakupy z 3 kont!

Od lat sprzedajemy na kontach ksiazka_z_pasja,

ksiazka_gliwice oraz MercuriusGliwice

Łącząc zakupy z naszych kont, za przesyłkę płacisz tylko raz!