Corso di formazione Imparare la programmazione Go

1. Introduzione a Go

• Che cos'è Go (Golang)?
• Storia e filosofia di progettazione di Go
• Go come linguaggio di programmazione per il web e i sistemi
• Caratteristiche principali:
  • Tipi statici
  • Semplicità e leggibilità
  • Compilazione rapida
  • Concorrenza integrata
  • Raccolta del rifiuto (garbage collection)
  • Compilazione multipiattaforma
• Casi d'uso comuni di Go
• Vantaggi e limiti di Go
• Confronto tra Go e C/C++, JavaScript, Ruby, Python e Java
• Comprendere l'ecosistema Go
• Panoramica della libreria standard Go
• Moduli Go e gestione delle dipendenze
• Anatomia di un'applicazione Go
• Pratica pratica (Hands-on): Esaminare ed eseguire un semplice programma Go

2. Configurazione dell'ambiente di sviluppo Go

• Installazione di Go
• Comprensione della toolchain Go
• Configurazione delle variabili di ambiente
• Scelta di un IDE o editor di codice
• Utilizzo della riga di comando con Go
• Creazione di uno spazio di lavoro Go
• Comprensione della struttura del progetto Go
• Inizializzazione di un progetto con Go Modules
• Utilizzo di go mod init
• Gestione delle dipendenze con go get
• Aggiornamento e ispezione delle dipendenze
• Formattazione del codice sorgente con gofmt
• Esecuzione dei programmi con go run
• Compilazione delle applicazioni con go build
• Installazione delle applicazioni Go
• Compilazione incrociata delle applicazioni
• Pratica pratica (Hands-on): Creare e configurare un progetto Go all'interno di un container

3. Variabili, costanti e tipi in Go

• Dichiarazione delle variabili
• Tipi espliciti rispetto a tipi inferiti
• Dichiarazioni brevi di variabili
• Costanti
• Valori zero
• Portata e durata delle variabili
• Tipi di dati primitivi:
  • Interi
  • Numeri in virgola mobile
  • Numeri complessi
  • Booleani
  • Stringhe
• Conversioni di tipi
• Lavoro con Unicode e UTF-8
• Runes e byte
• Assegnazione multipla di variabili
• Comprensione della sicurezza dei tipi
• Esercizio: Costruire un piccolo programma di elaborazione dati da riga di comando

4. Operatori ed espressioni

• Operatori aritmetici
• Operatori di confronto
• Operatori logici
• Operatori di assegnazione
• Incremento e decremento
• Priorità degli operatori
• Calcoli con interi e numeri in virgola mobile
• Evitare comuni errori di conversione dei tipi
• Esercizio: Implementare calcoli e logica di validazione

5. Date, orari e formattazione

• Utilizzo del pacchetto time
• Creazione e manipolazione delle date
• Recupero dell'ora corrente
• Fusi orari e posizioni
• Parsing di date e orari
• Formattazione di date e orari
• Calcolo delle durate
• Lavoro con timestamp Unix
• Gestione dei timeout
• Esercizio: Aggiungere timestamp e calcoli delle durate a un'applicazione

6. Array, slice, mappe e strutture (structs)

Array

• Dichiarazione degli array
• Inizializzazione degli array
• Percorso degli array
• Array multidimensionali

Slice

• Comprensione delle slice rispetto agli array
• Creazione delle slice
• Aggiunta di elementi
• Copia delle slice
• Lunghezza e capacità delle slice
• Creazione di slice da altre slice
• Più comuni errori con le slice

Mappe

• Creazione delle mappe
• Aggiunta e rimozione di voci
• Verifica dell'esistenza di una chiave
• Percorso delle mappe
• Mappe contenenti dati complessi

Strutture (Structs)

• Definizione delle strutture

• Campi delle strutture

• Inizializzazione delle strutture

• Strutture nidificate

• Strutture anonime

• Metodi delle strutture

• Tag JSON delle strutture

• Pratica pratica (Hands-on): Modellare utenti, prodotti e dati dell'applicazione utilizzando strutture, slice e mappe

7. Logica condizionale e cicli

• Istruzioni if
•  else e else if
• Dichiarazioni di variabili all'interno di condizioni
• Cicli for
• Cicli infiniti
• Condizioni di ciclo
•  break e continue
• Percorso con range
• Cicli nidificati
• Istruzioni switch
• Switch basati su espressioni
• Multipli casi
• Casi predefiniti
• Type switch
• Esercizio: Implementare logica di validazione ed elaborazione dell'applicazione

8. Funzioni

• Definizione delle funzioni
• Parametri delle funzioni
• Valori di ritorno
• Multipli valori di ritorno
• Valori di ritorno denominati
• Funzioni variadiche
• Funzioni anonime
• Valori di funzione
• Closure
• Ricorsione
• Passaggio di funzioni come argomenti
• Funzioni che restituiscono errori
• Progettazione di funzioni piccole e riutilizzabili
• Esercizio: Rifattorizzare il codice esistente in funzioni riutilizzabili

9. Pointer e concetti di memoria

• Che cos'è un pointer?
• Operatori di indirizzo e dereferencing
• Pointer e parametri delle funzioni
• Riceventi pointer
• Pointer a strutture
• Pointer nil
• Quando usare i pointer
• Semantica di valore rispetto alla semantica di riferimento
• Comprensione della gestione della memoria e della garbage collection in Go
• Errori comuni con i pointer
• Pratica pratica (Hands-on): Modificare i dati dell'applicazione utilizzando i pointer

10. Creazione di un'applicazione web in Go

• Panoramica delle capacità web di Go
• Introduzione al pacchetto net/http
• Creazione di un server HTTP
• Richieste e risposte HTTP
• Metodi HTTP
• URL delle richieste e parametri di query
• Header HTTP
• Codici di stato HTTP
• Fondamenti del routing
• Creazione di handler
• Gestione dei dati dei moduli
• Servizio di file statici
• Lavoro con template HTML
• Variabili dei template e strutture di controllo
• Strutturazione di un'applicazione web
• Pratica pratica (Hands-on): Costruire un server web di base in Go

11. Costruzione di un servizio web RESTful

• Fondamenti dell'architettura REST
• Progettazione di endpoint API
• GET, POST, PUT, PATCH e DELETE
• Lavoro con JSON
• Encoding e decoding di JSON
• Validazione delle richieste
• Codici di stato HTTP
• Risposte di errore
• Parametri di query e parametri di percorso
• Strutture delle risposte API
• Separazione degli handler dalla logica di business
• Pratica pratica (Hands-on): Costruire un'API REST CRUD

12. Runtime Go, compilazione e build del progetto

• Comprensione del compilatore Go
• Processo di build di Go
• go run
• go build
• go install
• go test
• Flag di build
• Configurazione specifica per ambiente
• Build per diversi sistemi operativi e architetture
• Produzione di binari standalone
• Gestione della configurazione dell'applicazione
• Esercizio: Compilare l'applicazione per più piattaforme

13. Lavorazione con file e web

• Apertura e chiusura dei file
• Lettura dei file
• Scrittura dei file
• Creazione di directory
• Metadati dei file
• I/O con buffer
• Lavoro con stream
• Lettura e scrittura di file JSON
• Client HTTP
• Effettuazione di richieste HTTP in uscita
• Gestione degli errori del client HTTP
• Timeout e cancellazione
• Elaborazione delle risposte API
• Pratica pratica (Hands-on): Recuperare dati da un'API esterna e salvarli localmente

14. Gestione degli errori e debug

• L'approccio di Go agli errori
• Restituzione di errori dalle funzioni
• Verifica degli errori
• Creazione di errori personalizzati
• Wrapping degli errori
• Aggiunta di contesto agli errori
•  errors.Is e errors.As
• Panic e recovery
• Quando usare panic
• Debug di problemi comuni in Go
• Logging dell'attività dell'applicazione
• Utilizzo degli strumenti di debug di Go
• Esercizio: Diagnosire e correggere errori applicativi introdotti deliberatamente

15. Interfacce e astrazione

• Che cos'è un'interfaccia?
• Implementazione implicita delle interfacce
• Definizione delle interfacce
• Valori delle interfacce
• Interfacce vuote / any
• Affermazioni di tipo
• Type switch
• Implementazioni tramite pointer rispetto a quelle tramite valore
• Progettazione di interfacce piccole
• Inversione delle dipendenze
• Uso delle interfacce per il testing
• Riduzione del coupling dell'applicazione
• Pratica pratica (Hands-on): Introdurre interfacce nell'applicazione web di esempio

16. Pacchetti e organizzazione del progetto

• Creazione dei pacchetti
• Convenzioni di denominazione dei pacchetti
• Identificatori esportati e non esportati
• Importazione dei pacchetti
• Inizializzazione dei pacchetti
• Organizzazione dei livelli dell'applicazione
• Pacchetti interni
• Gestione delle dipendenze con Go Modules
• Versionamento semantico
• Uso di pacchetti di terze parti
• Evitamento di dipendenze circolari
• Progettazione di progetti Go manutenibili
• Esercizio: Rifattorizzare l'applicazione in pacchetti separati

17. Concorrenza con Goroutine

• Che cos'è la concorrenza?
• Goroutine
• Avvio delle goroutine
• Comprensione dell'esecuzione concorrente leggera
• Sfide di sincronizzazione
• Stato condiviso
• Condizioni di race
• Utilizzo di sync.WaitGroup
• Mutex e mutex di lettura/scrittura
• Operazioni atomiche
• Pratica pratica (Hands-on): Convertire un compito sequenziale in un'elaborazione concorrente

18. Canali (Channels)

• Comprensione dei canali
• Invio e ricezione di valori
• Canali con buffer rispetto a canali senza buffer
• Comportamento bloccante
• Chiusura dei canali
• Percorso dei canali
• Canali direzionali
• Comunicazione basata su canali
• Istruzioni Select
• Timeout e cancellazione
• Pattern worker-pool
• Pattern produttore/consumatore
• Pratica pratica (Hands-on): Costruire un sistema di worker concorrente

19. Context e gestione delle richieste

• Perché i context sono importanti nelle applicazioni web
• context.Context
• Context con portata della richiesta
• Cancellazione
• Scadenze (Deadlines)
• Timeout
• Propagazione del context attraverso i livelli dell'applicazione
• Cancellazione di operazioni di database o HTTP
• Evitamento dell'uso improprio dei context
• Esercizio: Aggiungere cancellazione delle richieste e timeout all'applicazione web

20. Testing delle applicazioni Go

• Perché il testing automatico è importante
• Scrittura di unit test
• Pacchetto testing
• Funzioni di test
• Convenzioni di denominazione dei test
• Test guidati da tabelle
• Testing degli errori
• Testing degli handler HTTP
• Server di test HTTP
• Fixture di test
• Copertura dei test
• Benchmark
• Test di esempio
• Testing delle interfacce con mock o finte implementazioni
• Pratica pratica (Hands-on): Creare una suite di test per l'applicazione di esempio

21. Ottimizzazione delle prestazioni

• Comprensione delle prestazioni delle applicazioni Go
• Identificazione dei colli di bottiglia
• Prestazioni di CPU rispetto a quelle di memoria
• Strutture dati efficienti
• Riduzione delle allocazioni non necessarie
• Stringhe, byte e buffer
• Gestione delle goroutine
• Evitamento della concorrenza eccessiva
• Strategie di caching
• Considerazioni su database e rete
• Profiling delle applicazioni
• Benchmark e test delle prestazioni
• Utilizzo degli strumenti di profiling di Go
• Esercizio: Profilare e ottimizzare un'applicazione deliberatamente inefficiente

22. Sicurezza e buone pratiche per applicazioni web robuste

• Validazione degli input dell'utente
• Gestione sicura delle richieste HTTP
• Prevenzione delle vulnerabilità web comuni
• Gestione sicura degli errori
• Concetti di autenticazione e autorizzazione
• Gestione dei segreti e della configurazione
• Comunicazione HTTP sicura
• Evitamento di informazioni sensibili nei log
• Gestione e aggiornamento delle dipendenze
• Limiti delle risorse e timeout delle richieste
• Esercizio: Rivedere e rafforzare l'API di esempio

23. Logging e osservabilità delle applicazioni

• Fondamenti del logging
• Logging strutturato
• Livelli di log
• Logging delle richieste
• Logging degli errori
• Correlazione e ID delle richieste
• Monitoraggio del comportamento dell'applicazione
• Metriche di base
• Endpoint di verifica dello stato (health-check)
• Diagnosi dei problemi in produzione
• Pratica pratica (Hands-on): Aggiungere logging strutturato e health-check

24. Containerizzazione dell'applicazione Go

• Perché usare i container?
• Applicazioni Go e containerizzazione
• Scrittura di un Dockerfile
• Build multistage
• Costruzione di un'immagine di runtime minimale
• Gestione della configurazione tramite variabili di ambiente
• Rete del container
• Eposizione delle porte dell'applicazione
• Esecuzione dell'applicazione in un container
• Testing dell'applicazione containerizzata
• Pratica pratica (Hands-on): Confezionare l'applicazione Go di esempio come un container pronto per la produzione

25. Deployment

• Preparazione dell'applicazione per la produzione
• Build dei binari di produzione
• Configurazione dell'ambiente
• Deployment basato su container
• Architettura del deployment
• Proxy inversi
• Considerazioni su HTTPS/TLS
• Verifiche dello stato dell'applicazione
• Shutdown elegante
• Gestione dei segnali del sistema operativo
• Scaling delle applicazioni web Go
• Scaling orizzontale rispetto a quello verticale
• Risoluzione dei problemi di base del deployment
• Pratica pratica (Hands-on): Distribuire l'applicazione web di esempio

26. Progetto finale: Applicazione web Go completa

I partecipanti uniscono i concetti sviluppando un'applicazione completa.

Il progetto può includere:

• Inizializzazione del progetto con Go Modules
• Organizzazione dei pacchetti
• Routing HTTP
• Endpoint API REST
• Gestione di richieste e risposte JSON
• Validazione degli input
• Gestione degli errori
• Interfacce
• Elaborazione concorrente
• Comunicazione con API esterne
• Persistenza in file o database
• Test automatizzati
• Logging
• Considerazioni sulle prestazioni
• Containerizzazione
• Configurazione di produzione
• Deployment

27. Revisione e buone pratiche

• Revisione della sintassi fondamentale di Go
• Convenzioni di codifica Go
• Scrittura di Go idiomatico
• Mantenere il codice semplice
• Progettazione efficace dei pacchetti
• Buone pratiche di gestione degli errori
• Principi di progettazione delle interfacce
• Buone pratiche di concorrenza
• Strategie di testing
• Considerazioni sulle prestazioni
• Manutenibilità e leggibilità
• Errori comuni commessi dai nuovi sviluppatori Go
• Approcci consigliati per continuare lo sviluppo Go

28. Conclusione

• Revisione dei concetti chiave
• Revisione dell'applicazione web completata
• Domande e discussione
• Risoluzione dei problemi in scenari reali comuni
• Prossimi passi consigliati per lo sviluppo Go
• Ulteriori librerie Go e risorse dell'ecosistema
• Ulteriori opportunità per costruire servizi Go di livello produttivo