C'est quoi Go ?
Go (aussi appelé Golang) est un langage de programmation créé par Google en 2009. Trois ingénieurs légendaires l'ont conçu : Robert Griesemer, Rob Pike et Ken Thompson : ce dernier étant aussi le co-créateur d'Unix et du langage C.
Leur frustration ? Les langages existants étaient soit rapides mais compliqués (C++), soit simples mais lents (Python). Go est né pour résoudre ce dilemme : la vitesse du C avec la simplicité de Python.
Go est un langage compilé : votre code est transformé en un exécutable natif, sans interpréteur. Résultat : des programmes qui démarrent en millisecondes et consomment peu de mémoire.
Pourquoi apprendre Go ?
Les outils qui font tourner l'infrastructure moderne sont écrits en Go :
- Docker : les conteneurs qui ont révolutionné le déploiement
- Kubernetes : l'orchestrateur de conteneurs utilisé par Netflix, Spotify, Airbnb
- Terraform : l'infrastructure as code
- Hugo : le générateur de sites statiques le plus rapide
Go est le langage du cloud. Si vous voulez construire des API rapides, des microservices, des outils CLI ou travailler dans le DevOps, Go est incontournable.
Et surtout : Go a 25 mots-clés. Vingt-cinq. Python en a 35, JavaScript en a 64, Java en a 50. Moins de mots-clés = moins de choses à apprendre = moins de bugs.
Votre premier programme
Tout programme Go commence par la même structure :
Ce programme importe "fmt" et "strings", mais n'utilise jamais strings. Il déclare aussi une variable locale x := 5 sans jamais s'en servir. Avant de dérouler : en Go, est-ce qu'un import ou une variable locale inutilisés provoquent un simple avertissement, ou autre chose ?
Voir la réponse
Ce n'est pas un avertissement : c'est une erreur de compilation. Le programme ne compile pas du tout. Go affiche imported and not used pour un package superflu, et declared and not used pour une variable locale jamais lue. C'est un choix volontaire de conception : Go refuse le code mort pour garder les fichiers propres et éviter les imports qui traînent. En pratique, on retire l'import dès qu'on ne s'en sert plus (les outils goimports et gofmt le font automatiquement) ; pour une variable temporairement inutile, on peut utiliser l'identifiant blanc _.
package main
import "fmt"
func main() {
fmt.Println("Bonjour le monde !")
}Décryptons ligne par ligne :
package main: déclare que c'est un programme exécutable (pas une bibliothèque)import "fmt": importe le packagefmt(format) pour afficher du textefunc main(): la fonction d'entrée, le point de départ de votre programmefmt.Println(): affiche une ligne dans le terminal
go run et go build
Deux commandes essentielles pour travailler avec Go :
# Compiler et exécuter directement (développement)
go run main.go
# Compiler en un exécutable (production)
go build -o monprogramme main.go
./monprogrammego run est pratique pendant le développement : il compile et exécute en une seule commande. go build crée un fichier exécutable autonome que vous pouvez distribuer : aucune installation de Go nécessaire sur la machine cible.
C'est une différence fondamentale avec Python ou JavaScript : un programme Go compilé est un fichier unique qui tourne partout sans dépendances.
Un projet Go = un module. Avant d'écrire du code, on initialise un module avec go mod init exemple.com/monprojet : ça crée un fichier go.mod qui déclare le nom du projet et ses dépendances. Le code s'organise ensuite en packages (un par dossier, déclarés par package nom) qu'on importe par leur chemin. go mod tidy ajuste les dépendances automatiquement.
What is Go?
Go (also called Golang) is a programming language created by Google in 2009. Three legendary engineers designed it: Robert Griesemer, Rob Pike, and Ken Thompson — the latter being the co-creator of Unix and the C language.
Their frustration? Existing languages were either fast but complicated (C++), or simple but slow (Python). Go was born to solve this dilemma: the speed of C with the simplicity of Python.
Go is a compiled language — your code is transformed into a native executable, no interpreter needed. Result: programs that start in milliseconds and use little memory.
Why learn Go?
The tools that power modern infrastructure are written in Go:
- Docker — the containers that revolutionized deployment
- Kubernetes — the container orchestrator used by Netflix, Spotify, Airbnb
- Terraform — infrastructure as code
- Hugo — the fastest static site generator
Go is the language of the cloud. If you want to build fast APIs, microservices, CLI tools, or work in DevOps, Go is essential.
And most importantly: Go has 25 keywords. Twenty-five. Python has 35, JavaScript has 64, Java has 50. Fewer keywords = less to learn = fewer bugs.
Your first program
Every Go program starts with the same structure:
This program imports "fmt" and "strings", but never uses strings. It also declares a local variable x := 5 without ever reading it. Before scrolling down: in Go, does an unused import or unused local variable produce a simple warning, or something else?
See the answer
It is not a warning: it is a compilation error. The program does not compile at all. Go outputs imported and not used for a superfluous package, and declared and not used for a local variable that is never read. This is a deliberate design choice: Go refuses dead code to keep files clean and prevent stale imports. In practice, you remove an import as soon as you stop using it (the tools goimports and gofmt do this automatically); for a temporarily unused variable, you can use the blank identifier _.
package main
import "fmt"
func main() {
fmt.Println("Hello world!")
}Let's break it down line by line:
package main— declares this is an executable program (not a library)import "fmt"— imports thefmt(format) package to display textfunc main()— the entry function, the starting point of your programfmt.Println()— prints a line to the terminal
package main
import "fmt"
func main() {
fmt.Println("Hello world!")
}go run and go build
Two essential commands for working with Go:
# Compile and run directly (development)
go run main.go
# Compile to an executable (production)
go build -o myprogram main.go
./myprogramgo run is handy during development — it compiles and runs in one command. go build creates a standalone executable you can distribute — no Go installation needed on the target machine.
This is a fundamental difference from Python or JavaScript: a compiled Go program is a single file that runs anywhere with no dependencies.
A Go project = a module. Before writing code, you initialize a module with go mod init example.com/myproject: it creates a go.mod file declaring the project name and its dependencies. Code is then organized into packages (one per folder, declared with package name) imported by their path. go mod tidy adjusts dependencies automatically.
Go ne s'exécute pas dans le navigateur. Pour tester vos programmes sans rien installer, utilisez le Go Playground officiel :
🎯 Pratique
S'entraîner (clique pour ouvrir) :
✨ Prompt IA
Copiez ce prompt dans Claude ou ChatGPT :
Explique-moi les différences entre Go, Python et JavaScript. Pour chaque langage, donne un cas d'usage idéal et un programme Hello World.
💬 Ré-explique sans regarder
Sans relire la réponse de l'IA : avec tes mots, pourquoi un programme Go compilé tourne sur une machine qui n'a même pas Go installé, alors qu'un script Python a besoin d'un interpréteur ?
go build traduit ton code source en un exécutable natif (du code machine que le processeur comprend directement), avec tout le nécessaire embarqué dedans. Le fichier produit ne dépend de rien : pas de runtime à installer, pas d'interpréteur. Python, lui, livre du code source que l'interpréteur python doit lire et exécuter à la volée : sans cet interpréteur sur la machine, le script ne démarre pas.🧠 Rappel libre
Sans remonter dans la leçon : par quelle ligne commence tout programme Go exécutable, et que fait go run de plus que go build ?
package main, puis définit la fonction d'entrée func main(). go build se contente de compiler en un exécutable autonome ; go run fait les deux d'un coup, il compile et exécute aussitôt (pratique en développement, sans laisser de binaire derrière).Vous savez lancer un programme Go avec go run. Place maintenant à la matière première : on déclare des variables avec :=, on rencontre le compilateur strict qui refuse une variable inutilisée, et on touche aux pointeurs avec les opérateurs & et *.
Leçon 2 : Variables et types →