📍 Article principal du parcours : Go (Golang) : le guide complet pour débuter
Ce tutoriel fait partie du parcours « Go de zéro ». Pour la vue d’ensemble, lisez d’abord le guide principal.

Installer Go et lancer son premier programme

Vous avez décidé d’apprendre Go, et la toute première question est terre à terre : comment fait-on tourner un programme ? Contrairement à Python ou PHP, Go n’est pas interprété ligne par ligne — il se compile en un fichier exécutable. Cela change la manière de travailler, et c’est justement ce qui rend Go agréable une fois la chaîne d’outils en place. À la fin de ce tutoriel, vous aurez installé Go, créé un vrai projet structuré, et produit votre premier binaire qui démarre en quelques millisecondes.

On ne va pas afficher un « Hello World » anonyme. On pose la première pierre de GareBook, le système de réservation de places pour une gare routière qu’on construira tout au long du parcours. Dès cette étape, le programme affichera le message d’accueil de la gare.

🎯 Ce que vous allez apprendre

Installer la chaîne d’outils Go sur Windows, macOS ou Linux et vérifier qu’elle répond ;
Créer un projet Go propre avec son module (go.mod) ;
Écrire, lire et comprendre la structure minimale d’un programme Go ;
Distinguer go run (exécuter au vol) de go build (produire un binaire), et savoir quand utiliser l’un ou l’autre.

🛠️ Ce que vous allez construire

Un mini-programme garebook qui, lancé dans le terminal, affiche le message d’accueil de la gare et le nombre de villes desservies. C’est volontairement simple : l’objectif est de valider que tout fonctionne de bout en bout, du code source au binaire exécutable. C’est le socle sur lequel les tutoriels suivants ajouteront la logique métier.

Prérequis

Un ordinateur sous Windows 10/11, macOS ou Linux ;
Un terminal (PowerShell sur Windows, Terminal sur macOS/Linux) et savoir y taper une commande ;
Un éditeur de texte — Visual Studio Code est gratuit et possède une excellente extension Go ;
Niveau : débutant total accepté. Test express : si vous savez ouvrir un terminal et y taper cd pour changer de dossier, vous êtes prêt.
⏱️ Temps estimé : ~25 minutes.

Étape 1 — Installer Go et vérifier l’installation

Go se distribue sous forme d’un installateur officiel unique. On ne passe pas par vingt dépendances : on télécharge un paquet, on l’installe, et la commande go devient disponible partout dans le terminal. Rendez-vous sur la page de téléchargement officielle, go.dev/dl, et prenez la dernière version stable (Go 1.26 au moment d’écrire).

Windows : téléchargez le fichier .msi, double-cliquez, suivez l’assistant. Il ajoute Go au PATH automatiquement.
macOS : téléchargez le .pkg et installez-le, ou via Homebrew avec brew install go.
Linux : téléchargez l’archive .tar.gz et décompressez-la dans /usr/local (la procédure exacte est sur la page officielle).

Une fois l’installation terminée, fermez et rouvrez votre terminal (important : il doit recharger le PATH), puis vérifiez :

go version

Vous devriez voir s’afficher quelque chose comme go version go1.26.0 windows/amd64 — le numéro de version, le système et l’architecture. Si le terminal répond « commande introuvable », c’est presque toujours que le PATH n’a pas été rechargé : fermez complètement le terminal et rouvrez-en un neuf. Tant que go version ne répond pas, inutile d’aller plus loin.

✅ Point d’étape — go version affiche un numéro. Vérifiez aussi go env GOPATH : il indique où Go range ses fichiers de travail. Si les deux répondent, votre chaîne d’outils est opérationnelle.

Étape 2 — Créer le projet et son module

En Go, un projet n’est pas juste un dossier avec des fichiers : c’est un module, identifié par un nom et décrit par un fichier go.mod. Ce fichier liste le nom du module, la version de Go utilisée, et plus tard les dépendances externes. Le créer est la première chose à faire dans tout nouveau projet. Commençons par fabriquer le dossier et y entrer :

# Créer le dossier du projet et s'y placer
mkdir garebook
cd garebook

# Initialiser le module Go
go mod init garebook

La commande go mod init garebook crée un fichier go.mod contenant le nom du module et la version de Go. Ouvrez-le, il ressemble à ceci :

module garebook

go 1.26.0

Pour un vrai projet destiné à être partagé, on nomme souvent le module d’après son adresse de dépôt, par exemple github.com/awa-diallo/garebook. Pour apprendre en local, un nom court comme garebook suffit parfaitement. Ce fichier go.mod est le centre de gravité du projet : toutes les commandes Go que vous lancerez depuis ce dossier sauront qu’elles travaillent sur le module GareBook.

✅ Point d’étape — Le fichier go.mod existe dans votre dossier et contient la ligne module garebook. Pour vérifier d’un coup d’œil : cat go.mod sur macOS/Linux, ou type go.mod sur Windows.

Étape 3 — Écrire le premier programme

Place au code. Tout programme Go exécutable a la même ossature : il appartient au package main et contient une fonction main qui sert de point d’entrée. C’est cette fonction que Go appelle quand on lance le programme. Créez un fichier main.go à la racine du projet avec ce contenu :

package main

import "fmt"

func main() {
	villes := 4
	fmt.Println("Bienvenue à GareBook — réservation de places")
	fmt.Printf("Gare routière en service. %d villes desservies.\n", villes)
}

Décortiquons ligne par ligne, parce que chaque mot compte :

package main déclare que ce fichier appartient au package principal — celui qui produit un exécutable.
import "fmt" charge le package fmt de la bibliothèque standard, qui gère l’affichage formaté.
func main() est la fonction qui s’exécute au démarrage. Pas d’arguments, pas de valeur de retour.
villes := 4 déclare une variable et lui donne la valeur 4. Le := dit à Go « crée cette variable et devine son type » — ici, un entier.
fmt.Println affiche une ligne ; fmt.Printf affiche avec un format, où %d est remplacé par l’entier et \n est un retour à la ligne.

Notez l’absence de point-virgule en fin de ligne : Go les ajoute pour vous. Et si votre éditeur a l’extension Go, sauvegarder le fichier va automatiquement le reformater avec gofmt — l’indentation par tabulations, l’alignement, tout est standardisé. Il n’y a aucun débat de style en Go, et c’est reposant.

Étape 4 — Exécuter, puis compiler

Il y a deux façons de faire tourner ce code, et comprendre la différence est essentiel. La première, go run, compile et exécute en une seule commande sans laisser de fichier — idéale pendant le développement, quand on teste sans arrêt :

go run .

Le point désigne « le package du dossier courant ». En une seconde, vous devriez voir s’afficher :

Bienvenue à GareBook — réservation de places
Gare routière en service. 4 villes desservies.

La seconde façon, go build, produit un véritable binaire autonome que vous pouvez copier et lancer n’importe où, sans Go installé sur la machine cible. C’est ce qu’on déploie en production :

# Compiler le binaire
go build

# Le lancer (Windows)
.\garebook.exe

# Le lancer (macOS / Linux)
./garebook

go build crée un fichier exécutable nommé d’après le module (garebook ou garebook.exe). Ce fichier est complet : il contient le runtime Go et tout votre code. Vous pouvez l’envoyer sur un serveur qui n’a jamais vu Go, il tournera. C’est là tout l’intérêt d’un langage compilé, et le tutoriel de déploiement exploitera pleinement cette propriété.

✅ Point d’étape — go run . affiche les deux lignes d’accueil, et go build a créé un binaire que vous lancez directement. Si go run renvoie une erreur de compilation, relisez le message : Go pointe le fichier et la ligne exacte du problème.

Étape 5 — Vérifier que tout est en place

Avant de clore, faisons un dernier contrôle de salubrité du projet. La commande go vet analyse votre code à la recherche d’erreurs suspectes que le compilateur laisse passer, et go fmt garantit le formatage standard :

go vet ./...
go fmt ./...

Le ./... signifie « ce package et tous ses sous-packages ». Si go vet ne dit rien, c’est bon signe : aucun problème détecté. Votre projet GareBook a maintenant la bonne structure : un go.mod, un main.go, et un binaire qui se construit proprement. Vous êtes prêt à lui donner une vraie logique métier dans le prochain tutoriel.

🐞 Pièges fréquents

Symptôme / erreur	Cause probable	Correctif
`'go' n'est pas reconnu en tant que commande`	Le `PATH` n’a pas été rechargé après l’installation	Fermez complètement le terminal et rouvrez-en un neuf. Sous Windows, déconnectez/reconnectez la session si besoin
`go.mod file not found in current directory`	Vous lancez une commande Go hors du dossier du module	Placez-vous dans le dossier `garebook` avec `cd`, ou (re)faites `go mod init`
`expected 'package', found 'EOF'` ou erreur de package	Le fichier ne commence pas par `package main`	La première ligne de code doit être `package main`
`imported and not used: "fmt"`	Vous importez un package sans vous en servir	Utilisez-le, ou retirez la ligne `import`. Go interdit les imports inutiles
Le binaire ne se lance pas (« autorisation refusée » sous Linux)	Le fichier n’a pas le droit d’exécution	`chmod +x garebook` puis `./garebook`

🌍 Adaptation au contexte ouest-africain

Le téléchargement de Go pèse une soixantaine de mégaoctets (l’installation occupe davantage une fois décompressée sur le disque). Avec une connexion lente ou facturée au volume, faites-le une bonne fois, idéalement sur un réseau correct (bureau, fibre d’un ami, cybercafé), puis gardez le fichier d’installation. Une fois Go installé, vous n’avez plus besoin d’Internet pour compiler et lancer vos programmes : tout se passe en local. C’est un avantage net sur les environnements qui retéléchargent des paquets à chaque build.

Si votre machine est modeste, rassurez-vous : la chaîne d’outils Go est légère et compile vite, même sur un ordinateur d’entrée de gamme. Et pour expérimenter sans rien installer du tout — sur un poste partagé ou un téléphone — l’environnement officiel go.dev/play exécute du Go directement dans le navigateur.

✅ Récapitulatif

Vous venez de poser les fondations. Vous savez désormais installer Go et vérifier l’installation avec go version, créer un projet en initialisant son module avec go mod init, écrire la structure minimale d’un programme (package main + func main), et surtout distinguer go run qui exécute au vol de go build qui produit le binaire de production. Le projet GareBook démarre, affiche son accueil, et se compile sans erreur. Tout le reste du parcours s’appuie sur cette base.

🧾 Aide-mémoire

Commande	Rôle
`go version`	Affiche la version installée — vérifie que Go répond
`go mod init <nom>`	Crée le module et le fichier `go.mod`
`go run .`	Compile et exécute le package courant, sans laisser de binaire
`go build`	Produit un binaire exécutable autonome
`go fmt ./...`	Reformate le code au standard Go
`go vet ./...`	Détecte les erreurs suspectes non bloquantes
`go env`	Affiche la configuration de l’environnement Go

💪 À vous de jouer

Modifiez main.go pour qu’il affiche aussi le nom de la ville où se trouve la gare (par exemple « Gare de Thiès ») à partir d’une seconde variable de type string. Bonus : faites afficher le prix moyen d’un billet à l’aide d’une variable float64 et du verbe de format %.0f pour l’afficher sans décimale.

Voir une solution

package main

import "fmt"

func main() {
	villes := 4
	ville := "Thiès"
	prixMoyen := 3500.0 // en francs CFA

	fmt.Println("Bienvenue à GareBook — réservation de places")
	fmt.Printf("Gare de %s, %d villes desservies.\n", ville, villes)
	fmt.Printf("Prix moyen d'un billet : %.0f FCFA\n", prixMoyen)
}

Ici ville est une string (déduite du texte entre guillemets) et prixMoyen un float64 (déduit du .0). Le verbe %.0f affiche un flottant sans chiffre après la virgule.

Tutoriels frères

Les bases de la syntaxe Go — la suite directe : variables, types, fonctions.
Structs, slices, maps et erreurs — pour structurer vos données dès que le programme grandit.

Pour aller plus loin

🔝 Retour au guide principal : Go (Golang) : le guide complet pour débuter
Documentation officielle d’installation : go.dev/doc/install
Prochain tutoriel suggéré : Les bases de la syntaxe Go

FAQ

Quelle version de Go installer ?
Toujours la dernière stable depuis go.dev/dl (Go 1.26 actuellement). Les versions récentes sont rétrocompatibles : votre code d’aujourd’hui tournera sur les versions futures.

Dois-je définir un GOPATH comme dans les vieux tutoriels ?
Non. Depuis l’arrivée des modules, vous travaillez où vous voulez sur votre disque. Le GOPATH existe encore pour le cache et les outils, mais vous n’avez plus à y placer vos projets.

Quelle différence entre go run et go build ?
go run compile et lance dans la foulée sans garder de fichier — pratique pour itérer. go build écrit un binaire réutilisable sur le disque — c’est ce qu’on déploie.

Faut-il VS Code obligatoirement ?
Non, n’importe quel éditeur convient. Mais l’extension Go de VS Code (autocomplétion, formatage à la sauvegarde, détection d’erreurs en direct) accélère beaucoup l’apprentissage.

Mots-clés : installer Go, go mod init, premier programme Go, go run, go build, package main, débuter Golang.