Programmazione Elixir

Panoramica: Questa lezione introduce Elixir come linguaggio funzionale centrato sulla trasformazione dei dati piuttosto che sulla mutazione dello stato. Gli studenti impareranno a muoversi nell'ambiente Elixir (IEx), a compilare ed eseguire script, e a padroneggiare il Pattern Matching — il meccanismo fondamentale che Elixir utilizza per l'associazione delle variabili e il flusso di controllo.

Risultati dell'Apprendimento:

• Confrontare il modello di trasformazione dei dati di Elixir con la programmazione tradizionale basata sullo stato.
• Configurare la shell interattiva di Elixir (IEx) ed eseguire codice Elixir tramite script e compilazione.
• Applicare l'operatore di confronto (=), l'operatore pin (^) e il carattere jolly (_) per destrutturare e validare i dati.

Panoramica: Questa lezione esplora la filosofia fondamentale di Elixir: l'immutabilità. Gli studenti impareranno come Elixir tratta i dati come entità immutabili, i vantaggi prestazionali di questo approccio e i vari tipi predefiniti — dai semplici tipi valore come atomi e intervalli ai collezionatori complessi come mappe e binari. La lezione si conclude con un'approfondita analisi dello scope delle variabili e dell'espressione potente with.

Risultati dell'Apprendimento:

• Spiegare le implicazioni teoriche e pratiche dell'immutabilità sulle prestazioni e sulla gestione della memoria.
• Identificare e utilizzare i tipi predefiniti di Elixir, inclusi tipi Value, System e Collection.
• Applicare le regole di ambito delle variabili e l'espressione with per gestire trasformazioni dati complesse.

Panoramica: Questa lezione esplora il cuore della programmazione in Elixir: la trasformazione funzionale. Copre il passaggio da funzioni anonime e chiusure a moduli strutturati e funzioni nominali. Gli studenti impareranno a sfruttare il pattern matching, la ricorsione e l'operatore pipe per creare codice conciso, leggibile e mantenibile, interagendo con la VM Erlang sottostante.

Risultati dell'Apprendimento:

• Creare e invocare funzioni anonime usando sia la notazione standard che quella di cattura (&).
• Implementare funzioni nominali all'interno di moduli usando pattern matching e ricorsione per gestire logiche complesse.
• Applicare clausole di guardia e parametri predefiniti per controllare il flusso di esecuzione delle funzioni.

Panoramica: Questa lezione copre i meccanismi fondamentali delle liste di Elixir attraverso la ricorsione, con particolare attenzione al pattern "Testa e Coda" per elaborare e costruire dati. Si sposta verso strutture dati complesse — Mappe, Structs e Liste di Parole Chiave — fornendo un quadro decisionale per scegliere la struttura giusta e tecniche avanzate per manipolare dati annidati usando il modulo Access e la teoria dei tipi di Elixir.

Risultati dell'Apprendimento:

• Deconstruire e Costruire Liste: Usare il pattern testa/coda per navigare e costruire strutture ricorsive di liste.
• Implementare Modelli di Ordine Superiore: Creare funzioni personalizzate map e reduce per trasformare o aggregare dati di liste.
• Selezionare le Strutture Dati Adatte: Distinguere tra Mappe, Structs e Liste di Parole Chiave in base alle esigenze di prestazioni, ordine e integrità dei dati.

Panoramica: Questa lezione esplora l'approccio duplice al processing delle raccolte in Elixir: il modulo Enum avido e il modulo Stream pigro e componibile. Fornisce inoltre un'analisi approfondita della trasformazione dei dati tramite comprehension e dei meccanismi interni delle stringhe di Elixir, distinguendo tra liste di caratteri (tra apici singoli) e binari (tra apici doppi). Gli studenti impareranno a elaborare strutture dati complesse, a gestire dati infiniti e a eseguire estrazioni a livello bit.

Risultati dell'Apprendimento:

• Differenziare tra valutazione avida e pigra durante il processing delle raccolte.
• Utilizzare le comprehension su liste con generatori e filtri multipli per trasformare dati ed estrarre informazioni a livello bit.
• Distinguere tra stringhe tra apici singoli (liste di caratteri) e stringhe tra apici doppi (binari) e applicare il modulo corretto (List vs. String) per la manipolazione.

Panoramica: Questa lezione guida gli sviluppatori dalla scrittura di funzioni isolate in Elixir alla creazione, verifica e monitoraggio di applicazioni professionali. Copre strutture di controllo avanzate (case, cond), il ciclo di vita di un progetto Mix (dalla struttura della directory ai file eseguibili CLI) e l'insieme di strumenti professionali usati per il debug, il testing basato su proprietà e il monitoraggio del server.

Risultati dell'Apprendimento:

• Implementare logiche di ramificazione complesse usando case, cond e il trattamento delle eccezioni.
• Strutturare progetti Elixir usando Mix, gestire dipendenze esterne come HTTPoison e Poison, e configurare ambienti applicativi.
• Sviluppare suite di test robuste utilizzando ExUnit, DocTest e il testing basato su proprietà con StreamData.

Panoramica: Questa lezione esplora il passaggio da applicazioni Elixir a processo singolo a sistemi distribuiti. Copre i meccanismi di gestione dei messaggi, la persistenza dei processi tramite loop ricorsivi tail, e la gestione robusta del ciclo di vita dei processi tramite collegamenti e monitoraggi. Infine, introduce il modello di distribuzione della VM Erlang, insegnando come connettere nodi, proteggerli con cookie e gestire I/O su una rete.

Risultati dell'Apprendimento:

• Implementare processi stati persistenti usando ricorsione tail e timeout di messaggio.
• Costruire alberi di processi resilienti usando collegamenti (spawn_link) e monitoraggi (spawn_monitor).
• Configurare e connettere nodi distribuiti usando convenzioni di denominazione, cookie di sicurezza e registrazione globale dei processi.

Panoramica: Questa lezione presenta il framework Open Telecom Platform (OTP) nell'ecosistema Elixir, con particolare attenzione al comportamento GenServer e ai pattern di Supervisore. Gli studenti impareranno a costruire processi server robusti e stateful, a differenziare tra comunicazione sincrona e asincrona e a implementare alberi di supervisione tolleranti agli errori che gestiscono automaticamente il ciclo di vita dei processi.

Risultati dell'Apprendimento:

• Definire i componenti principali di OTP e implementare il ciclo di vita standard dei callback GenServer.
• Differenziare e implementare modelli di messaggi sincroni (call) e asincroni (cast).
• Configurare e distribuire un Supervisore per monitorare i processi worker e mantenere la resilienza del sistema in caso di fallimenti.

Panoramica: Questa lezione passa dai singoli GenServers alla progettazione e distribuzione di applicazioni OTP complesse e multicomponenti. Copre la progettazione architetturale del "Duper", un trovatore di file duplicati, i meccanismi delle specifiche di applicazione OTP e tecniche di distribuzione avanzate, inclusi aggiornamenti caldi tramite Distillery. Inoltre, esplora alternative semplificate per la gestione degli stati come Tasks e Agents, fornendo un quadro per scegliere lo strumento giusto in base alle esigenze di concorrenza.

Risultati dell'Apprendimento:

• Analizzare i requisiti applicativi usando il framework a cinque domande per identificare punti focali e caratteristiche di runtime.
• Costruire un'applicazione OTP multiservert (Duper) utilizzando server specializzati (Results, PathFinder, Gatherer) e Supervisori Dinamici.
• Eseguire rilasci di codice e aggiornamenti caldi tramite Distillery, inclusa la migrazione degli stati tramite il callback code_change.

Panoramica: Questa lezione esplora l'estensibilità avanzata di Elixir, concentrando l'attenzione su come manipolare il codice come dati tramite metaprogrammazione e macro. Gli studenti impareranno a ottenere polimorfismo usando Protocolli e Comportamenti, strutturare sistemi su larga scala con progetti Umbrella e implementare un'elaborata gestione degli errori. Infine, la lezione copre l'aggiunta di uno strato di analisi statica usando il sistema dei tipi di Elixir e Dialyzer per garantire la correttezza del codice.

Risultati dell'Apprendimento:

• Padronizzare l'uso di quote e unquote per inserire e manipolare blocchi di codice all'interno delle macro.
• Implementare Protocolli e Comportamenti personalizzati per creare strutture di codice polimorfiche e riutilizzabili.
• Costruire progetti Umbrella multi-applicazione e applicare Specifiche di Tipo formali al codice dinamico Elixir.