Je tiens à remercier BiM , hornetbzz et dourouc05 qui m'ont aidé dans la rédaction de cet article.

Go est un projet open source distribué sous licence BSD. Cet article explique comment récupérer les fichiers sources, les compiler sur votre machine et les exécuter.

Il y a deux manières distinctes d'expérimenter Go. Cet article se concentre sur le compilateur gc Go et les outils (6g, 8g etc.). Pour savoir comment utiliser gccgo, un compilateur traditionnel utilisant GCC, référez-vous à la documentation officielle "Setting up and using gccgo".

L'environnement de compilation de Go dépend de 3 variables d'environnement que vous devez définir dans votre .bashrc (ou équivalent) ainsi qu'une dernière variable optionnelle :

• $GOROOT : Le répertoire principal où vous avez placé Go. Typiquement c'est $HOME/go mais cela peut être n'importe quel répertoire.
• $GOOS et $GOARCH : Le nom du système d'exploitation cible et son architecture. Les choix pour $GOOS sont linux , freebsd , darwin (Mac OS X 10.5 ou 10.6) et nacl (Native Client, un port incomplet). Les choix pour $GOARCH sont amd64 (64-bit x86, le port le plus mature), 386 (32-bit x86) et arm (32-bit ARM, un port incomplet).
• $GOBIN (variable optionnelle) : Le répertoire où seront installés les fichiers binaires. Par défaut c'est $HOME/bin. Après l'installation, you devriez ajouter ce dossier à votre $PATH . Notez que $GOARCH et $GOOS identifient l'environnement cible et non l'environnement sur lequel vous développez. Vous êtes toujours multi-plateformes en ce qui concerne la compilation.

Définissez ces variables dans votre .bashrc. Par exemple :

export GOROOT=$HOME/go
export GOARCH=amd64
export GOOS=linux

Vérifiez-les en listant toutes vos variables d'environnement.

$ env | grep '^GO'

Les combinaisons valides de $GOOS et $GOARCH sont :

• darwin + 386
• darwin + amd64
• freebsd + 386
• freebsd + amd64
• linux + 386
• linux + amd64
• linux + arm
• nacl + 386

Les compilateurs Go supportent deux systèmes d'exploitation (Linux et Mac OS X) et 3 jeux d'instructions. Les versions pour Linux et Mac sont toutes les deux complètement opérationnelles à part le port ARM qui ne tourne pas sous OS X (pour le moment).

Il y a d'importantes différences de qualité entre les compilateurs pour les différentes architectures.

• amd64 (a.k.a. x86-64); 6g,6l,6c,6a
  L'implémentation la plus mature. Le compilateur a un optimiseur effectif (processus optimisant l'utilisation du registre) et génère du "bon code" (bien que gccgo peut faire notablement mieux certaines fois).
• 386 (a.k.a. x86 or x86-32); 8g,8l,8c,8a
  Comparable au port amd64. Pas aussi éprouvé mais il devrait être presque aussi stable.
• arm (a.k.a. ARM); 5g,5l,5c,5a
  Quelques bugs connus mais il est éprouvé. Testé avec QEMU et un téléphone sous android. Excepté pour les interfaces de traitement de bas niveau sur le système d'exploitation, le support d'exécution est le même pour tous les ports et inclue un "mark-and-sweep garbage collector", un système efficace de découpage des tableaux et des chaînes, le support des piles segmentées et une solide implémentation des routines Go.

Référez-vous à la documentation officielle sur gccgo ( setting up and using gccgo ) pour les détails concernant le compilateur et l'environnement.

Si vous n'avez pas installé Mercurial (vous n'avez pas la commande hg) :

$ sudo easy_install mercurial

Cette commande fonctionne sur la plupart des systèmes. Sur Ubuntu, vous devriez essayer apt-get install python-setuptools python-dev en premier lieu. Si cela échoue, visitez la page de téléchargement de Mercurial .

Assurez-vous que le dossier $GOROOT n'existe pas ou est vide. Puis extrayez le dépôt :

$ hg clone -r release https://go.googlecode.com/hg/ $GOROOT

Go est écrit en C. Pour le compiler, vous devez avoir installé GCC, les librairies standards C, le générateur/parseur Bison, make, awk et l'éditeur de texte ed. Sur OS X, ils peuvent être installés avec Xcode.

Sur Linux, faites :

$ sudo apt-get install bison gcc libc6-dev ed gawk make

(ou la commande équivalente selon votre distribution Linux).

Pour compiler la distribution Go, faites :

$ cd $GOROOT/src
$ ./all.bash

Si tout se déroule correctement, le script affichera :

--- cd ../test
N known bugs; 0 unexpected bugs

Où N est un nombre qui varie d'une version à l'autre.

Supposons un fichier file.go, pour le compiler :

$ 6g file.go

6g est le compilateur Go pour amd64. Il écrira le fichier de sortie file.6. Le '6' identifie les fichiers pour l'architecture amd64. Les identifiants pour 386 et arm sont respectivement '8' et '5'. Si vous souhaitez compiler pour du 386, vous devrez utiliser 8g et le fichier de sortie sera file.8.

Pour lier le fichier :

$ 6l file.6

Ensuite, lancez-le :

$ ./6.out

Voici un exemple complet :

$ cat >hello.go <<EOF
package main
 
import "fmt"
 
func main() {
	fmt.Printf("hello, world\n")
}
EOF
$ 6g hello.go
$ 6l hello.6
$ ./6.out
hello, world
$

Il n'y a pas besoin de lister les dépendances de hello.6 (dans ce cas le package fmt) dans la ligne de commande 6l. Le linkeur les retrouve automatiquement en lisant hello.6.

Pour compiler des programmes plus complexes, vous voudrez probablement utiliser un Makefile. Il y a des exemples dans $GOROOT/src/cmd/godoc/ et $GOROOT/src/pkg/*/. L'article officiel concernant la contribution au projet Go donne plus de détails sur les processus de compilation/test de programmes Go.

Les nouvelles versions sont annoncées sur la mailing list Go Nuts. Pour mettre à jour votre version de Go :

$ cd $GOROOT/src
$ hg pull
$ hg update release
$ make all

Pour de l'aide en temps réel, il devrait y avoir des utilisateurs ou des développeurs sur #go-nuts sur le Freenode du serveur IRC.

La mailing list officielle de discussion sur le langage Go est Go Nuts .

Les bugs peuvent êtres reportés sur le trackeur Go .

Pour ceux qui souhaitent rester informés du développement il y a une autre mailing list, golang-checkins qui reçoit un message résumé à chaque modification du dépôt de Go.