Go da zero: installazione, workspace e primo programma per sviluppatori backend

Hai letto che Go è veloce, compilato e perfetto per backend moderni. Ma quando apri il terminale, ti ritrovi con errori tipo command not found: go o go: cannot find main module. Ecco, è proprio da lì che partiamo noi di Meteora Web — dal problema concreto di farti arrivare a scrivere il tuo primo programma Go senza perdere tempo in chiacchiere. Non ti serve esperienza con Go, ma se hai già usato Python, Node o Java, ti sentirai subito a casa. In questa guida non parliamo di concorrenza, goroutine o channel: la base prima della base. Installazione pulita, workspace sensato, primo programma funzionante. In 20 minuti hai il tuo ambiente Go operativo e sai esattamente cosa stai facendo.

Perché installare Go (e non solo 'seguire la guida')

Chi viene da linguaggi interpretati tipo PHP o Python spesso sottovaluta l'importanza di un compilatore. Go è compilato: ogni volta che lanci go build ottieni un singolo eseguibile statico. Niente dipendenze runtime, niente 'ma sul server non funziona'. Noi di Meteora Web lo usiamo per servizi critici proprio per questo motivo: un binario da copiare sul server e via. Lo stesso vale per il workspace: se capisci come Go organizza i file, non ti perdi mai. E se sbagli, il compilatore te lo dice subito, non a runtime come in JavaScript.

Installazione: scegli la tua strada (e controllala)

Il metodo ufficiale è il più sicuro: scarica l'archivio da go.dev/dl/ e segui le istruzioni per il tuo sistema. Noi però consigliamo di usare un version manager anche su macchina locale: con gvm (Go Version Manager) o con lo strumento integrato go install puoi passare da una versione all'altra in pochi secondi. Per noi che lavoriamo su più progetti clienti, è essenziale.

Linux / macOS con gvm

bash <(curl -s -S -L https://raw.githubusercontent.com/moovweb/gvm/master/binscripts/gvm-installer)
source ~/.gvm/scripts/gvm
gvm install go1.22.2
gvm use go1.22.2 --default
go version

Windows con installer MSI

Scarica il .msi da go.dev, esegui, riavvia il terminale. Poi verifica con go version. Se vuoi più controllo, usa scoop: scoop bucket add versions; scoop install go.

Verifica dell'installazione

go env GOROOT GOPATH GOMODCACHE

Se tutto è corretto, vedrai i percorsi senza errori. Attenzione a GOPATH: con le versioni moderne (Go 1.11+) non è più obbligatorio impostarlo a mano. Noi lo lasciamo puntare a $HOME/go e usiamo i moduli per ogni progetto.

Workspace: moduli, non più cartelle magiche

Prima di Go 1.11 eri obbligato a tenere tutto il codice dentro GOPATH/src. Oggi non più: ogni progetto è un modulo Go indipendente, con il suo file go.mod. Questa è la svolta che rende Go gestibile come PHP o Node. Creare un workspace è semplicissimo:

mkdir ~/projects/go-first
cd ~/projects/go-first
go mod init meteora/hello

Il comando go mod init crea un file go.mod con il nome del modulo (es. meteora/hello). Quel nome può essere qualsiasi cosa, meglio se un URL o un percorso univoco per evitare conflitti quando pubblicherai il pacchetto. Noi di Meteora Web usiamo sempre la forma dominio/cliente/nome-progetto.

La struttura minima di un progetto Go

~/projects/go-first/
├── go.mod
├── main.go
└── ... altri file .go

Niente node_modules, niente vendor a caso. Ogni file .go appartiene a un package, e il punto di ingresso è il package main con la funzione func main().

Primo programma: Hello, METEORA!

Ora che l'ambiente è pronto, scriviamo qualcosa di concreto. Crea main.go dentro la cartella del progetto:

package main

import "fmt"

func main() {
	fmt.Println("Ciao da Meteora Web — Go è operativo!")
}

Esegui con go run . (il punto indica il modulo corrente) oppure go run main.go. Vedrai il messaggio stampato. Ora compila l'eseguibile statico:

go build -o ciao
./ciao   # su Linux/macOS; su Windows: ciao.exe

Hai ottenuto un singolo file binario — nessuna dipendenza esterna, nessun runtime da installare. Puoi copiarlo su un server e gira così com'è. Questo è il superpotere di Go.

Errori comuni e come evitarli

• Errore: package main is not a package — ti sei dimenticato package main all'inizio del file.
• Errore: undefined: fmt.Println — hai scritto Println ma non hai importato "fmt". Oppure hai importato ma usato fmt in due package diversi.
• Errore: no required module provides package — non hai fatto go mod init nella directory del progetto.
• Attenzione: go run main.go funziona se c'è solo main.go. Se hai più file, usa go run .

Workspace avanzato: più moduli e dipendenze (cenni)

Per chi è già avvezzo, Go gestisce le dipendenze con go get e il file go.sum. Non serve un package manager esterno. Esempio per aggiungere una dipendenza:

go get rsc.io/quote/v4

E poi nel codice:

import "rsc.io/quote/v4"

func main() {
	fmt.Println(quote.Go())
}

Ma per ora, concentrati sul modulo singolo. Capito questo, il resto è scalabile.

Strumenti pratici per il tuo flusso di lavoro

• go fmt — formatta automaticamente il codice. Fallo sempre prima di fare commit.
• go vet — analisi statica per bug comuni.
• go test — esegue i test (file *_test.go).
• gofmt e golint (non ufficiale ma molto usato).

Noi di Meteora Web abbiamo integrato go fmt e go vet nel nostro flusso CI/CD. Impara a usarli subito, ti faranno risparmiare ore di debugging.

Perché il workspace è importante per le PMI italiane

Spesso vediamo sviluppatori che installano Go alla 'veloce', finiscono con più versioni in conflitto, percorsi sbagliati, moduli non inizializzati. Poi spendono un'ora a capire perché go run non trova il main. Il problema non è Go: è la mancanza di metodo. Noi, che veniamo da anni di contabilità e partita doppia, sappiamo che un ambiente riproducibile è come un bilancio in ordine: tutto torna. Per questo dedichiamo tempo a configurare il workspace una volta sola e bene. Poi il codice scorre.

In sintesi — cosa fare adesso

1. Installa Go con il metodo ufficiale o con gvm. Verifica con go version.
2. Crea un modulo: mkdir mio-progetto && cd mio-progetto && go mod init mio/dominio.
3. Scrivi il tuo primo programma in main.go con package main e func main.
4. Esegui con go run . e compila con go build.
5. Aggiungi al tuo flusso di lavoro go fmt e go vet.

Se vuoi approfondire la gestione del codice con Git, abbiamo una guida pratica su Git per principianti che si sposa perfettamente con questo setup. Buon coding.