IL BLOG DEGLI RHCE ITALIANI

Il linguaggio Go – seconda parte

Andrea Manzini

HEY! HO! LET’S GO!

11 novembre 2009, con un post dal titolo di una famosa canzone dei Ramones, Google annunciava ufficialmente la nascita di un nuovo linguaggio di programmazione open source, denominato proprio “Go”.

Il linguaggio di programmazione Go è un progetto open source di google per rendere più produttivi i programmatori. Nell’intenzione dei loro creatori, Go è conciso, espressivo, efficiente e pulito. Una volta installato, il programmatore ha subito a disposizione una ‘cassetta degli attrezzi’ ben fornita. Ad esempio solo scrivendo

$ go

ci appare l’elenco dei comandi disponibili:

build       compile packages and dependencies
clean       remove object files and cached files
doc         show documentation for package or symbol
env         print Go environment information
bug         start a bug report
fix         update packages to use new APIs
fmt         gofmt (reformat) package sources
generate    generate Go files by processing source
get         download and install packages and dependencies
install     compile and install packages and dependencies
list        list packages
run         compile and run Go program
test        test packages
tool        run specified go tool
version     print Go version
vet         report likely mistakes in packages

Vediamo dunque che il compilatore Go che abbiamo installato comprende anche documentazione, gestore dei pacchetti, build automation, test, installer, e molto altro!

Nello scorso articolo abbiamo elencato le principali caratteristiche del linguaggio ed abbiamo installato il compilatore, provando subito il classico “Hello, World” ; ora e’ il momento di mettersi all’opera. Anzichè perdersi in lunghe descrizioni sulla sintassi, per rispettare la filosofia di Go ho pensato di preparare dei programmi didattici, commentandoli insieme così da prendere subito confidenza.

Il primo programma è molto semplice; chiunque abbia rudimenti di un altro linguaggio C-like capirà subito di cosa si tratta

package main

import (
    "fmt"
    "time"
)

func scrivi(n int) {
    fmt.Println(n)
    time.Sleep(1 * time.Second)
}

func main() {
    for i := 1; i <= 10; i++ {
	scrivi(i)
    }
    time.Sleep(1 * time.Second)
}

Vediamo rapidamente come è composto il programma: subito dopo la dichiarazione del package, abbiamo 2 direttive import, raggruppate dentro una parentesi: in questo modo diciamo a Go che abbiamo intenzione di usare alcune funzioni di queste librerie. Di seguito una dichiarazione: la funzione scrivi accetta un parametro n, di tipo intero e non restituisce alcun valore; l’unica cosa che fa è stampare a video il numero che riceve e aspettare un secondo prima di ritornare. Notiamo già alcune cose, ad esempio che in Go il tipo delle variabili va messo dopo l’identificativo, a differenza di altri linguaggi come C, C# o Java… E che finalmente non serve più mettere il punto-e-virgola alla fine di ogni istruzione! Quante volte ce lo siamo dimenticati ?

Abbiamo infine la nostra main, il cuore del programma: con un ciclo for da 1 a 10, chiamiamo 10 volte la funzione “scrivi”; al termine del ciclo il programma si ferma per un secondo di attesa e poi termina.

Salviamo il programma in un file (ad esempio contanumeri.go) e prima di lanciare il nostro programma, proviamo a digitare

$ go fmt contanumeri.go

il sorgente verrà automaticamente “formattato” , ovvero indentato con la spaziatura e le parentesi giuste per rispettare le linee guida del linguaggio. Ora compiliamo con

$ go build contanumeri.go 

e lanciamo l’eseguibile risultante, per ottenere l’ovvio risultato dei numeri in fila da 1 a 10.

$ time ./contanumeri
1
2
3
4
5
6
7
8
9
10

real    0m11,006s
user    0m0,004s
sys     0m0,003s

Niente di sconvolgente, ma abbiamo fatto qualche passo avanti: imparare Go non è affatto difficile!

Con questo sorgente possiamo fare un esperimento interessante: prendiamo le righe con time.Sleep e le commentiamo…

package main

import (
    "fmt"
    "time"
)

func scrivi(n int) {
    fmt.Println(n)
    //time.Sleep(1 * time.Second)
}

func main() {
    for i := 1; i <= 10; i++ {
	scrivi(i)
    }
    //time.Sleep(1 * time.Second)
}

compilando il codice, avremo un messaggio di errore. Dove sta il problema ?

$ go build contanumeri.go
.\contanumeri.go:5: imported and not used: "time"

Il nostro sorgente contiene infatti una direttiva “import” per usare un package, ma di fatto non lo sta usando: questo causa un errore di compilazione in Go ed e’ un comportamento voluto: in Go si vuole forzare il programmatore alla pulizia, all’essenzialità e all’efficienza del codice: un programma che include un package per non utilizzarlo non viene neppure compilato.

Ora togliamo il commento alle righe di prima e proviamo una delle caratteristiche più potenti di Go: abbiamo visto che la funzione “scrivi” è (artificialmente, nel nostro caso) piuttosto lenta: impiega ben un secondo ad essere eseguita. In tutto infatti il programma occupa il nostro pc per circa 11 secondi. Grazie a Go, possiamo lanciare in parallelo tante copie di “scrivi” che gireranno in modo indipendente; il bello è che per far questo ci basterà modificare UNA sola riga …

package main

import (
    "fmt"
    "time"
)

func scrivi(n int) {
    fmt.Println(n)
    time.Sleep(1 * time.Second)
}

func main() {
    for i := 1; i <= 10; i++ {
	go scrivi(i)
    }
    time.Sleep(1 * time.Second)
}

in pratica abbiamo aggiunto l’istruzione go prima di invocare la funzione; in questo modo ogni esecuzione della funzione “scrivi” inizia in un thread parallelo, e il programma dopo aver avviato il thread può proseguire con le istruzioni successive senza aspettare che la funzione finisca. Di fatto questo si traduce in 10 “goroutine” eseguite contemporaneamente, lo dimostra anche il nostro output che non è più così ordinato, ma notiamo che il programma ora impiega 1 secondo in totale contro gli 11 di prima!

$ go build contanumeri.go
$ time ./contanumeri
5
4
2
3
8
9
6
10
1
7

real    0m1,003s
user    0m0,000s
sys     0m0,004s

E se volessimo invece i numeri tutti in fila ? Go mette a disposizione del programmatore un tipo speciale di oggetti, detti “channels”, per “incanalare” i dati e far comunicare tra di loro le goroutine; ma tratteremo questo costrutto in un prossimo articolo. Come al solito, prima di concludere lascio ai lettori un link per approfondire e far pratica con Go, in attesa della prossima puntata! Go By Example è un pratico tutorial passo-passo che si può seguire direttamente dal browser, e consiste in una serie di programmini di difficoltà crescente ma ben commentati riga per riga, in modo da capire ed apprendere la sintassi del linguaggio e le sue caratteristiche.

Info about author

Andrea Manzini

Prenota subito il tuo corso ufficiale Red Hat

GUARDA I CORSI