Odporność na błędy jest istotnym elementem konstruowania oprogramowania o znaczeniu krytycznym. Język Elixir pozwala na tworzenie szybkich i niezawodnych aplikacji, niezależnie od tego, czy tworzysz duże systemy rozproszone, zestaw usług backendowych, czy prostą aplikację webową. Przejrzysta składnia Elixira oraz sposób myślenia nastawiony na programowanie funkcyjne, sprawiają, że Twoje oprogramowanie jest łatwe w zapisie, odczycie i utrzymaniu. Elixir w akcji uczy, jak budować aplikacje rozproszone o jakości produkcyjnej, przy użyciu języka Elixir. Autor przedstawia ten wysoce skuteczny język na przykładach podkreślających korzyści płynące z funkcyjnego i współbieżnego programowania za pomocą Elixira. Przekonasz się, że framework OTP może znacznie zredukować ilość nużącej, niskopoziomowej pracy z kodem. Poznasz również praktyczne metody stosowania współbieżności, ucząc się jak rozpraszać gotowy system, między wieloma maszynami. Książka jest przeznaczona dla programistów posiadających wiedzę z zakresu aplikacji klienta/serwera na poziomie średniozaawansowanym oraz znających takie języki programowania jak Java, C# czy Ruby. Nie jest wymagana znajomość Elixira.

Osoby które kupowały "Elixir w akcji", wybierały także:

• Zosta 149,00 zł, (44,70 zł -70%)
• Metoda dziel i zwyci 89,00 zł, (26,70 zł -70%)
• Matematyka. Kurs video. Teoria dla programisty i data science 399,00 zł, (119,70 zł -70%)
• Design Thinking. Kurs video. My 129,00 zł, (38,70 zł -70%)
• Konwolucyjne sieci neuronowe. Kurs video. Tensorflow i Keras w rozpoznawaniu obraz 149,00 zł, (44,70 zł -70%)

Spis treści

Elixir w akcji eBook -- spis treści

• Okładka
• Strona tytułowa
• Strona redakcyjna
• Spis treści
• przedmowa
• podziękowania
• o książce
• o autorze
• ilustracja na okładce
• 1. Pierwsze kroki
  • 1.1. O Erlangu
    • 1.1.1. Wysoka dostępność
    • 1.1.2. Współbieżność Erlanga
      • Odporność na błędy
      • Skalowalność
      • Rozproszenie
      • Czas reakcji
    • 1.1.3. Systemy serwerowe
    • 1.1.4. Platforma programistyczna
  • 1.2. O Elixirze
    • 1.2.1. Uproszczenie kodu
    • 1.2.2. Składanie funkcji
    • 1.2.3. Szersza perspektywa
  • 1.3. Wady
    • 1.3.1. Prędkość
    • 1.3.2. Ekosystem
• 2. Podstawy
  • 2.1. Interaktywna powłoka
  • 2.2. Praca ze zmiennymi
  • 2.3. Organizacja kodu
    • 2.3.1. Moduły
    • 2.3.2. Funkcje
    • 2.3.3. Arność funkcji
    • 2.3.4. Widoczność funkcji
    • 2.3.5. Importy i aliasy
    • 2.3.6. Atrybuty modułu
      • Specyfikacje typów
    • 2.3.7. Komentarze
  • 2.4. Rozumienie systemu typów
    • 2.4.1. Liczby
    • 2.4.2. Atomy
      • Aliasy
      • Atomy jako wartości logiczne
      • Wartości nil i truthy
    • 2.4.3. Krotki
    • 2.4.4. Listy
      • Definicja listy rekurencyjnej
    • 2.4.5. Niemutowalność
      • Modyfikowanie krotek
      • Modyfikowanie list
      • Korzyści
    • 2.4.6. Mapy
      • Mapy dynamicznie zmieniające rozmiar
      • Dane strukturalne
    • 2.4.7. Ciągi binarne i ciągi bitowe
    • 2.4.8. Ciągi znaków
      • Stringi binarne
      • Listy znaków
    • 2.4.9. Funkcja jako typy pierwszoklasowe
      • Domknięcia
    • 2.4.10. Inne wbudowane typy
    • 2.4.11. Typy wyższego rzędu
      • Range
      • Listy asocjacyjne
      • MapSet
      • Czasy i daty
    • 2.4.12. Listy IO
  • 2.5. Operatory
  • 2.6. Makra
  • 2.7. Rozumienie czasu uruchomienia
    • 2.7.1. Moduły i funkcje w czasie uruchomienia
      • Nazwy modułów i atomy
      • Moduły Erlanga
      • Dynamiczne wywoływanie funkcji
    • 2.7.2. Wystartowanie środowiska uruchomieniowego
      • Interaktywna powłoka
      • Używanie skryptów
      • Narzędzie mix
• 3. Przepływ sterowania
  • 3.1. Dopasowanie wzorców
    • 3.1.1. Operator dopasowujący
    • 3.1.2. Dopasowanie krotek
    • 3.1.3. Dopasowywanie stałych
    • 3.1.4. Zmienne we wzorcach
    • 3.1.5. Dopasowywanie list
    • 3.1.6. Dopasowywanie map
    • 3.1.7. Dopasowywanie ciągów bitowych i ciągów bajtowych
      • Dopasowywanie ciągów binarnych
    • 3.1.8. Dopasowania złożone
    • 3.1.9. Ogólne zachowanie
  • 3.2. Dopasowanie do funkcji
    • 3.2.1. Funkcje wielowarunkowe
    • 3.2.2. Strażnicy
    • 3.2.3. Lambdy wielowarunkowe
  • 3.3. Instrukcje warunkowe
    • 3.3.1. Rozgałęzianie z funkcjami wielowarunkowymi
    • 3.3.2. Klasyczne konstrukcje rozgałęziania
      • If oraz unless
      • Instrukcje warunkowe
      • Case
    • 3.3.3. Specjalna forma with
  • 3.4. Pętle i iteracje
    • 3.4.1. Iteracja z rekurencją
    • 3.4.2. Wywołanie ogonowe
      • Rozpoznawanie wywołań ogonowych
      • Ćwiczenie
    • 3.4.3. Funkcje wyższego rzędu
      • Reduce
    • 3.4.4. Składanie list
    • 3.4.5. Strumienie
      • Ćwiczenie
• 4. Abstrakcje danych
  • 4.1. Tworzenie abstrakcji za pomocą modułów
    • 4.1.1. Podstawowa abstrakcja
    • 4.1.2. Łączenie abstrakcji
    • 4.1.3. Strukturyzacja danych za pomocą map
    • 4.1.4. Abstrakcje za pomocą struktur
      • Struktury a Mapy
      • Rekordy
    • 4.1.5. Transparentność danych
  • 4.2. Praca z danymi hierarchicznymi
    • 4.2.1. Generowanie ID
    • 4.2.2. Aktualizacja wpisów
      • Zabawa z dopasowywaniem wzorców
    • 4.2.3. Niemutowalne hierarchiczne aktualizacje
      • Dostępni pomocnicy
      • Ćwiczenie: usuwanie wpisu
    • 4.2.4. Aktualizacje iteracyjne
    • 4.2.5. Ćwiczenie: importowanie z pliku
  • 4.3. Polimorfizm z protokołami
    • 4.3.1. Podstawy protokołów
    • 4.3.2. Implementacja protokołu
    • 4.3.3. Protokoły wbudowane
      • Collectable lista zadań
• 5. Podstawy współbieżności
  • 5.1. Współbieżność w BEAM
  • 5.2. Praca z procesami
    • 5.2.1. Tworzenie procesów
    • 5.2.2. Przekazywanie wiadomości
      • Algorytm receive
      • Wysyłanie synchroniczne
      • Zbieranie wyników kwerendy
  • 5.3. Procesy serwerów stanowych
    • 5.3.1. Procesy serwera
      • Procesy serwera są sekwencyjne
    • 5.3.2. Utrzymywanie stanu procesu
    • 5.3.3. Stan mutowalny
      • Refaktoryzacja pętli
    • 5.3.4. Stany złożone
      • Podejście współbieżne a podejście funkcyjne
    • 5.3.5. Procesy rejestrowane
  • 5.4. Dyskusja na temat czasu uruchomienia
    • 5.4.1. Proces jest sekwencyjny
    • 5.4.2. Nieograniczone skrzynki pocztowe procesu
    • 5.4.3. Współbieżność współdzielenia niczego (shared-nothing concurrency)
    • 5.4.4. Działanie dyspozytora
• 6. Procesy serwera generycznego
  • 6.1. Tworzenie procesu serwera generycznego
    • 6.1.1. Podłączanie się pod moduły
    • 6.1.2. Implementowanie kodu generycznego
    • 6.1.3. Zastosowanie magazynu danych par
    • 6.1.4. Wsparcie dla żądań asynchronicznych
    • 6.1.5. Ćwiczenie: refaktoryzacja serwera zadań
  • 6.2. Wykorzystanie GenServer
    • 6.2.1. Zachowania (behaviours) OTP
    • 6.2.2. Podłączanie się do GenServer
    • 6.2.3. Obsługa żądań
    • 6.2.4. Obsługa wiadomości
    • 6.2.5. Pozostałe cechy GenServer
      • Sprawdzanie czasu kompilacji
      • Rejestracja nazw
      • Zatrzymywanie serwera
    • 6.2.6. Cykl życia procesu
    • 6.2.7. Procesy zgodne z OTP
    • 6.2.8. Ćwiczenie: serwer zadań zasilany GenServer
• 7. Tworzenie współbieżnego systemu
  • 7.1. Praca z mix
  • 7.2. Zarządzanie wieloma listami zadań
    • 7.2.1. Implementowanie pamięci podręcznej
    • 7.2.2. Pisanie testów
    • 7.2.3. Analiza zależności procesu
  • 7.3. Utrwalanie danych
    • 7.3.1. Kodowanie i utrwalanie
    • 7.3.2. Używanie bazy danych
      • Przechowywanie danych
      • Odczyt danych
    • 7.3.3. Analiza systemu
    • 7.3.4. Podejmowanie kroków względem wąskiego gardła
      • Współbieżna obsługa żądań
      • Ograniczanie współbieżności poprzez pulę
    • 7.3.5. Ćwiczenie: pula procesów i synchronizacja
  • 7.4. Dyskusja na temat procesów
• 8. Podstawy odporności na błędy
  • 8.1. Błędy czasu uruchomienia
    • 8.1.1. Typy błędów
    • 8.1.2. Obsługa błędów
  • 8.2. Błędy w systemach współbieżnych
    • 8.2.1. Łączenie procesów
      • Przechwytywanie wyjść
    • 8.2.2. Monitory
  • 8.3. Nadzorcy (supervisor)
    • 8.3.1 Przygotowanie istniejącego kodu
    • 8.3.2 Uruchamianie procesu nadzorcy
    • 8.3.3 Specyfikacja dzieci
    • 8.3.4 Opakowanie nadzorcy
    • 8.3.5 Korzystanie z modułu wywołania zwrotnego
    • 8.3.6 Łączenie wszystkich procesów
    • 8.3.7 Częstotliwość restartów
• 9. Izolowanie skutków błędów
  • 9.1. Drzewa nadzorców
    • 9.1.1 Oddzielanie luźno powiązanych elementów
    • 9.1.2 Rozbudowane wykrywanie procesów
    • 9.1.3 Krotka via
    • 9.1.4 Rejestracja procesów roboczych bazy danych
    • 9.1.5 Nadzór nad procesami roboczymi baz danych
    • 9.1.6 Organizacja drzewa nadzorców
      • Procesy zgodne z OTP
      • Zamykanie procesów
      • Unikanie restartów procesu
      • Strategie restartów
  • 9.2. Dynamiczne uruchamianie procesów
    • 9.2.1. Rejestracja serwerów ToDO
    • 9.2.2. Nadzór dynamiczny
    • 9.2.3. Wyszukiwanie serwerów zadań
    • 9.2.4. Stosowanie tymczasowej strategii restartu
    • 9.2.5. Testowanie systemu
  • 9.3. Daj mu się wywalić
    • 9.3.1. Procesy, które nie powinny ulegać awarii
    • 9.3.2. Obsługa oczekiwanych błędów
    • 9.3.3. Zachowanie stanu
• 10. Poza granicami GenServer
  • 10.1. Zadania (tasks)
    • 10.1.1. Zadania oczekujące
    • 10.1.2. Zadania nieoczekujące
  • 10.2. Agenci (agents)
    • 10.2.1. Podstawowe zastosowania
    • 10.2.2. Agenci i współbieżność
    • 10.2.3. Serwer zadań oparty na agencie
    • 10.2.4. Ograniczenia agentów
  • 10.3. Tabele ETS
    • 10.3.1. Podstawowe operacje
    • 10.3.2. Magazyn danych par klucz/wartość oparty na ETS
    • 10.3.3. Pozostałe operacje ETS
      • Wzorce dopasowania
      • Inne przypadki zastosowania ETS
      • Poza ETS
    • 10.3.4. Ćwiczenie: rejestr procesów
• 11. Praca z komponentami
  • 11.1. Aplikacje OTP
    • 11.1.1. Tworzenie aplikacji za pomocą narzędzia mix
    • 11.1.2. Zachowanie aplikacji
    • 11.1.3. Uruchomienie aplikacji
    • 11.1.4. Biblioteki jako aplikacje
    • 11.1.5. Tworzenie aplikacji to-do
    • 11.1.6. Struktura folderu aplikacji
      • Środowiska projektów mix
      • Struktura skompilowanego kodu
  • 11.2. Praca z zależnościami
    • 11.2.1. Dodawanie zależności
    • 11.2.2. Adaptacja puli
    • 11.2.3. Wizualizacja systemu
  • 11.3. Tworzenie serwera WWW
    • 11.3.1. Wybór zależności
    • 11.3.2. Uruchamianie serwera
    • 11.3.3. Obsługa żądań
    • 11.3.4. Rozprawianie o systemie
      • Wydajność
      • Wywołania a rzuty (call vs cast)
  • 11.4. Konfiguracja aplikacji
    • 11.4.1. Środowisko aplikacji
    • 11.4.2. Zmienna konfiguracja
    • 11.4.3. Kwestie skryptu konfiguracji
• 12. Tworzenie systemu rozproszonego
  • 12.1. Prymitywy rozproszenia
    • 12.1.1. Uruchomienia klastra
    • 12.1.2. Komunikacja między węzłami
    • 12.1.3. Odnajdywanie procesów
      • Grupy procesów
    • 12.1.4. Łącza i monitory
    • 12.1.5. Inne usługi rozproszenia
  • 12.2. Tworzenie klastra odpornego na błędy
    • 12.2.1. Kompozycja klastra
    • 12.2.2. Rozproszona pamięć podręczna zadań
      • Odnajdywanie serwerów zadań
      • Alternatywna metoda odnajdywania procesów
    • 12.2.3. Implementacja replikowanej bazy danych
    • 12.2.4. Testowanie systemu
    • 12.2.5. Wykrywanie partycji
    • 12.2.6. Systemy wysokiej niezawodności
  • 12.3. Kwestie sieciowe
    • 12.3.1. Nazwy węzłów
    • 12.3.2. Ciasteczka
    • 12.3.3. Węzły ukryte
    • 12.3.4. Zapory sieciowe
      • Bezpieczeństwo
• 13. Uruchamianie systemu
  • 13.1. Uruchomienie systemu przy użyciu narzędzi Elixira
    • 13.1.1. Stosowanie komend mix i elixir
    • 13.1.2. Uruchamianie skryptów
    • 13.1.3. Kompilacja na potrzeby produkcji
  • 13.2. Wydania OTP
    • 13.2.1. Tworzenie wydania za pomocą destylarni (distillery)
    • 13.2.2. Stosowanie wydania
    • 13.2.3. Zawartość wydania
      • Skompilowane binaria
      • Konfiguracje
      • Spakowany pakiet wydania
      • Precyzyjny montaż wydania
  • 13.3. Analiza zachowań systemu
    • 13.3.1. Debugowanie
    • 13.3.2. Logowanie
    • 13.3.3. Interakcja z systemem
    • 13.3.4. Śledzenie