Scala od podszewki

(ebook) (audiobook) (audiobook)

Autor:: Joshua Suereth D.

Promocja Przejdź

Scala od podszewki Joshua Suereth D. - okładka książki

Scala od podszewki Joshua Suereth D. - okładka audiobooka MP3

Scala od podszewki Joshua Suereth D. - okładka audiobooks CD

Obróć Zajrzyj do książki

Wydawnictwo:: Helion
Wydawnictwo:: Helion
Ocena:: 5.4/6 Opinie: 7
Stron:: 304
Druk:: oprawa miękka; PDF

Książka

49,00 zł

Powiadom mnie, gdy książka będzie dostępna

Ebook

~~49,00 zł~~ (-50%)
24,50 zł

Dodaj do koszyka lub Kup na prezent Kup 1-kliknięciem

Przenieś na półkę

Do przechowalni

Powiadom o dostępności audiobooka »

Czytaj fragment

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!

Ebooka przeczytasz na:

czytnikach Inkbook, Kindle, Pocketbook
i innych
systemach Windows, MacOS i innych

systemach Windows, Android, iOS, HarmonyOS
na dowolnych urządzeniach i aplikacjach obsługujących formaty: PDF, EPub, Mobi

Masz pytania? Zajrzyj do zakładki Pomoc »

Audiobooka posłuchasz:

w aplikacji Ebookpoint na Android, iOS, HarmonyOs
na systemach Windows, MacOS i innych

na dowolonych urządzeniach
i aplikacjach obsługujących format MP3
(pliki spakowane w ZIP)

Masz pytania? Zajrzyj do zakładki Pomoc »

Kurs Video zobaczysz:

Oceny i opinie klientów: Scala od podszewki Joshua Suereth D. (7)

6
(4)
5
(2)
4
(1)
3
(0)
2
(0)
1
(0)

5.4

6 potwierdzona zakupem i oceniona przez: Stanisław Iwaniuk, inżynier elektronik 2015-08-24

Książka jest przeznaczona tylko dla "zaawansowanych" programistów języka Scala. Gdy po raz pierwszy dwa miesiące temu próbowałem nauczyć się z niej języka Scala (pomimo, że znam C, C++, Python i trochę C#), to mnie odrzuciła, ponieważ nie byłem wstanie nic z niej zrozumieć, a jej czytanie męczyło mnie niczym analfabetę. Wynikało to z odmiennej filozofii, terminologii, składni oraz mechanizmów języka Scala. Autor tłumacząc przyjmuje założenie, że już od pewnego czasu programujesz w tym języku i znasz przynajmniej pobieżnie wszystkie jego podstawowe elementy. NIE MOŻNA SIĘ NAUCZYĆ JĘZYKA SCALA Z TEJ KSIĄŻKI, co potwierdza sam autor w przedmowie do nie, "Książka ta podejmuje temat w miejscu, gdzie porzucają go podręczniki dla początkujących.". Dlatego, aby "nauczyć" się języka zmuszony byłem skorzystać z fatalnie napisanej książki "Język programowania Scala", a jedynym jej atutem był język polski i opis dla początkujących, a wadą bardzo duży szum informacyjny oraz formatowanie i o dziwo brak ergonomii w treści i w formie - autor ewidentnie nie umie pisać książek. Po napisaniu kilku funkcji i "oswojeniu" się z językiem oraz przejrzeniu źródeł do kilku bibliotek i przeczytaniu na forach angielskojęzycznych o napotkanych problemach i "przekartkowaniu" kilkunastu książek po angielsku (pomimo bariery językowej) powstały dobre fundamenty do ... no właśnie do czego? Właśnie kilka dni temu po raz drugi sięgnąłem po tą książkę i nagle okazało się, że rozumiem wszystko co czytam, nawet skomplikowane tematy. Świetne tłumaczenie średnio zaawansowanych zagadnień oraz porządkowanie i systematyzowanie zdobytej dotychczas chaotycznej, doświadczalnej i angielskojęzycznej "wiedzy". Szczerze polecam tą książkę ale dopiero po oswojeniu się z językiem w przeciwnym razie możecie ją znienawidzić. Jest świetnym uzupełnieniem książki "Język programowania Scala", która odpowiada jedynie na pytanie "jak", a to stanowczo za mało, ta stara się odpowiadać również na pozostałe rodzące się pytania np. "dlaczego" (świetnie widać różnicę poziomu merytorycznego w obu książkach np przy opisie obiektów pakietowych), jednym słowem stara się uczyć myśleć w języku Scala. W planach Helion miała być wydana jeszcze jedna książka o języku Scala, jednak z jakiś powodów została zdjęta z grafika wydawniczego, dlatego obecnie z polskojęzycznych książek mamy tylko te dwie uzupełniające się wzajemnie pozycje oraz pewne lepsze lub gorsze opracowania zamieszczone w internecie.
6 oceniona przez: Lukasz, Lead Developer 2015-07-10

Książka tłumaczy średnio zaawansowane fragmenty Scali. To nie jest książka dla początkujących.
6 potwierdzona zakupem i oceniona przez: MR, Programista 2013-08-16

Książka jest bardzo dobra. Dla osób które coś o scali wiedzą, chciały by się dowiedzieć o jej możliwościach, zaletach i wadach to tak książka jest idealna. Ale nie oczekujecie że to jest książka która nauczy was języka. Nie o to w niej chodzi.
6 oceniona przez: Programista - lider zespłu 2013-07-13

Bardzo dobra książka! Szczególnie dla doświadczonych programistów, którzy co nieco o scali wiedzą. Jeśli dopiero zaczynasz poszukaj innej pozycji bo ta może cię zniechęcić poziomem.
5 oceniona przez: Coola, Developer 2013-10-12

Bardzo dobra i bardzo trudna. Nie dla początkujących programistów.
5 oceniona przez: Adam Busch, 2013-09-18

Książka w interesujący sposób porządkuje wiedzę o języku Scala. Zrozumienie trudnych na pierwszy rzut oka zagadnień ułatwia precyzyjny język, do którego jednak trzeba się przyzwyczaić. Nie wiem czy poleciłbym książkę osobom, które dopiero zaczynają swoją przygodę ze Scalą. Sądzę, że warto przed przystąpieniem do lektury poprogramować bez wnikania w teoretyczne aspekty języka, aby się z nim oswoić. Wtedy lektura książki może dać wiele frajdy, której kulminacją jest rozdział 7. Dobrze dobrane przykłady, cenne wskazówki, dodatkowy plus za rozdział o aktorach. Planuję już kolejne czytanie. Polecam
4 potwierdzona zakupem i oceniona przez: Jacek Piechota, programista 2013-06-18

Zaletą książki jest niewątpliwie to, że zajmuje się mało jeszcze znanym językiem. Dlatego jest ważna. Podstawową wadą książki jest to, że nie ma ani jednego słowa o tym jak uruchomić pierwszy program - typu 'Witaj Świecie' - z linii poleceń czy używając jakiegoś IDE, czyli właściwie najważniejszej rzeczy. Zdecydowanie więc nie nadaje się do nauki dla początkujących. Gdyby nie fakt, że takie informacje można znaleźć w Internecie - byłaby w zasadzie bezużyteczna. Takie informacje powinny być w książce. Książka dobrze opisuje język i jeśli przebrnie się przez pierwsze trudności można się z niej sporo nauczyć. Ale jednak - zbyt kocham Javę, żeby ją zastąpić jakimś - choćby najpiękniejszym - GMO.

więcej opinii

Szczegóły książki

Tytuł oryginału:: Scala in Depth
Tłumaczenie:: Justyna Walkowska
ISBN Książki drukowanej:: 978-83-246-5188-7, 9788324651887
Data wydania książki drukowanej:: 2013-06-07
ISBN Ebooka:: 978-83-246-6062-9, 9788324660629
Data wydania ebooka:: 2013-07-02 Data wydania ebooka często jest dniem wprowadzenia tytułu do sprzedaży i może nie być równoznaczna z datą wydania książki papierowej. Dodatkowe informacje możesz znaleźć w darmowym fragmencie. Jeśli masz wątpliwości skontaktuj się z nami sklep@helion.pl.
Format:: 168x237
Numer z katalogu:: 13404
Rozmiar pliku Pdf:: 4.7MB
Pobierz przykładowy rozdział PDF
Przykłady na ftp

Zgłoś erratę
Kategorie:
Programowanie » Java - Programowanie

Spis treści książki

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)

pokaż cały spis treści