Le moyen le plus rapide d'apprendre Go en 2026

La plupart des feuilles de route pour développeurs Go reposent sur des impressions. Elles listent tous les frameworks avec lesquels quelqu'un a un jour livré un package main et appellent ça un parcours d'apprentissage. Celle-ci part d'ailleurs : fin 2025, 5 379 développeurs Go en activité ont dit à l'équipe Go à quoi ils utilisent réellement Go, comment ils le déploient et ce qui leur pose problème. La feuille de route ci-dessous suit ces données.

Si vous commencez Go en 2026, lisez ceci avant de passer trois semaines sur Gin.

En bref

• Sautez les contenus d'« introduction à la programmation ». Ouvrez le Tour of Go et pratiquez la toolchain (go run, go build, go mod) jusqu'à pouvoir compiler et lancer un programme Go depuis un terminal sans y réfléchir.
• Lisez Effective Go tôt. 33 % des répondants à l'enquête citent « s'assurer que notre code Go suit les bonnes pratiques et les idiomes » comme leur frustration n° 1, devant tout manque de fonctionnalité.
• Construisez les deux types de projets que 73-74 % des développeurs Go en activité livrent réellement : des outils en ligne de commande et des services API/RPC.
• Apprenez net/http et la bibliothèque standard avant tout framework. Vous pourrez ajouter un framework plus tard si un projet en a besoin.
• Ensuite, la concurrence : goroutines, channels, annulation via context. Écrivez des tests au fur et à mesure.
• L'équipe Go ne publie pas de feuille de route « officielle », alors méfiez-vous un peu de quiconque prétend en avoir une. Ce guide s'appuie plutôt sur l'enquête, la documentation Go et les concepteurs du langage.
• Vous voulez le parcours complet ? La feuille de route interactive de LevelUpGo vous mène du hello world jusqu'aux applications en production.

flowchart LR
    A["Stage 1<br/>Toolchain + Tour of Go"] --> B["Stage 2<br/>Effective Go + Idioms"] --> C["Stage 3<br/>Concurrency"]
    D["Stage 4<br/>CLI + HTTP service"] --> E["Stage 5<br/>Testing + Standard library"] --> F["Stage 6<br/>Frameworks (only when needed)"]

Les six étapes de la feuille de route, avec les frameworks à la fin.

Ce que 5 379 développeurs Go ont dit à l'équipe Go en 2025

L'équipe Go mène chaque année une enquête auprès des développeurs. Les résultats 2025, publiés en janvier 2026, ont recueilli 7 070 réponses, dont 5 379 ont passé l'étape de nettoyage des données. 87 % des répondants sont des développeurs professionnels, et 82 % utilisent Go dans leur emploi principal. (source)

Ces chiffres de l'enquête déterminent l'ordre de tout ce qui suit :

xychart-beta
    title "What Go developers build, 2025 survey"
    x-axis ["CLIs", "API services", "Libraries", "Cloud infra", "ML tools"]
    y-axis "Percent of respondents" 0 --> 100
    bar [74, 73, 49, 33, 11]

Les CLI et les services API arrivent en tête avec une large avance. Construisez-en un de chaque avant de choisir un framework.

Étape 1 : la toolchain et votre premier programme

La séquence officielle « Getting Started » de l'équipe Go est volontairement courte : installer Go, lancer un hello world, comprendre la commande go, écrire un module. (source)

Familiarisez-vous avec trois choses avant tout le reste :

1. La commande go. go run, go build, go install, go fmt, go test, go mod. Inutile de mémoriser les options, mais vous devez savoir quelle commande utiliser.
2. Les modules. go mod init <name> crée go.mod, et l'ajout d'imports met à jour go.sum pour vous. Les workspaces multi-modules existent, mais vous n'en aurez pas besoin avant un moment.
3. A Tour of Go. Russ Cox l'a écrit, et l'équipe Go le recommande comme première ressource interactive. Faites tous les exercices.

Un premier programme ressemble à ceci :

example.gogo
package main

import "fmt"

func main() {
    fmt.Println("hello, go")
}

Lancez-le sans étape de build :

example.gogo
$ go run main.go
hello, go

Vous n'avez pas besoin de configurer un pipeline de build avant de pouvoir exécuter quelque chose. La plupart des petits programmes Go restent aussi simples.

Étape 2 : Effective Go (l'étape que la plupart des feuilles de route ignorent)

Effective Go est cité en permanence, mais peu de gens le lisent tôt. L'équipe Go le qualifie de « lecture indispensable pour tout nouveau programmeur Go », et il est gratuit sur le site officiel.

33 % des développeurs Go en activité citent « s'assurer que notre code Go suit les bonnes pratiques et les idiomes Go » comme leur principale frustration. C'est plus que les « fonctionnalités manquantes du langage » (28 %) et les « modules fiables » (26 %). La syntaxe est la partie facile. La partie difficile, c'est d'écrire du code que les autres développeurs Go lisent et reconnaissent comme du Go normal.

Lisez-le après le Tour et avant tout framework. En une cinquantaine de pages denses, il couvre le nommage, la gestion des erreurs, les interfaces, la concurrence et le formatage.

Voici le genre de chose qu'il enseigne, la manière standard de gérer une erreur :

example.gogo
file, err := os.Open(path)
if err != nil {
    return fmt.Errorf("open %s: %w", path, err)
}
defer file.Close()

L'erreur est vérifiée immédiatement. L'envelopper avec %w préserve la chaîne, si bien que l'appelant peut toujours l'inspecter avec errors.Is et errors.As. Le nettoyage passe par un defer plutôt que par un bloc finally.

Vous retrouverez ce pattern dans toutes les bases de code Go que vous ouvrirez. Ceux qui sautent Effective Go ont tendance à le réinventer, et mal. Notre cours Go Idioms & Naming vous fait pratiquer ces patterns de façon interactive, mais le document original est gratuit et c'est la source de référence.

Étape 3 : la concurrence telle que le vrai code Go l'utilise

La concurrence est la fonctionnalité de Go qu'on apprend pour elle-même avant de mal l'utiliser. Elle s'ancre mieux quand on l'apprend à travers les briques qu'utilise le vrai code Go : goroutines, channels et context.

Il vous faut au minimum ces trois éléments :

• Les goroutines se lancent avec go someFunc(). Ce ne sont pas des threads du système d'exploitation. Le runtime les répartit sur un petit pool de threads.
• Les channels sont les tuyaux typés par lesquels les goroutines se coordonnent. make(chan T) pour un channel non bufferisé, make(chan T, n) pour un channel bufferisé.
• context.Context est le moyen d'annuler un travail qui traverse les frontières entre fonctions ou goroutines. Les API bloquantes de la bibliothèque standard prennent désormais un context.

La combinaison la plus courante répartit le travail sur des goroutines, collecte les résultats sur un channel et s'arrête plus tôt si le context est annulé.

sequenceDiagram
    participant Caller
    participant Main as fetchAll
    participant G as Worker goroutines
    participant Ch as Results channel
    Caller->>Main: ctx, urls
    Main->>G: spawn one goroutine per URL
    G->>Ch: send result
    Caller-->>Main: ctx cancel signal
    Ch->>Main: collect via select
    Main->>Caller: results

Répartir, collecter et s'arrêter en cas d'annulation. Les serveurs Go utilisent cette structure en interne.

example.gogo
func fetchAll(ctx context.Context, urls []string) []result {
    out := make(chan result, len(urls))
    for _, u := range urls {
        go func(u string) {
            out <- fetch(ctx, u)
        }(u)
    }
    results := make([]result, 0, len(urls))
    for range urls {
        select {
        case r := <-out:
            results = append(results, r)
        case <-ctx.Done():
            return results
        }
    }
    return results
}

C'est le select sur ctx.Done() qui permet à la fonction de rendre la main proprement quand l'appelant annule. net/http et database/sql font la même chose en interne.

Une fois que le select sur un context vous paraît naturel, vous maîtrisez la partie de la concurrence dont dépend le code Go de tous les jours. Concurrency Fundamentals couvre le reste du modèle de façon interactive.

Étape 4 : créer un outil CLI et un service HTTP

Ce sont les deux types de projets que livrent 73-74 % des développeurs Go en activité. (source) Construisez-en un de chaque avant de toucher à un framework.

Un outil CLI. Le package flag fait partie de la bibliothèque standard, et beaucoup de CLI que vous utilisez déjà (kubectl, docker, terraform, gh) sont écrits en Go. Un exemple minimal ressemble à ceci :

example.gogo
package main

import (
    "flag"
    "fmt"
)

func main() {
    name := flag.String("name", "world", "who to greet")
    flag.Parse()
    fmt.Printf("hello, %s\n", *name)
}

example.gogo
$ go build -o greet . && ./greet --name=patrik
hello, patrik

Le résultat est un binaire lié statiquement que vous pouvez donner à quelqu'un d'autre et qui fonctionne. Y parvenir demande plus de travail dans la plupart des autres langages backend. Le cours Building CLI Apps couvre les sous-commandes, les codes de sortie et la mise en forme de la sortie.

Un service HTTP. net/http fait aussi partie de la bibliothèque standard, vous n'avez donc pas besoin de Gin ou d'Echo pour en livrer un.

example.gogo
package main

import (
    "encoding/json"
    "net/http"
)

func main() {
    http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
        json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
    })
    http.ListenAndServe(":8080", nil)
}

Voilà un serveur HTTP fonctionnel, sans aucune dépendance. Ajoutez des logs structurés, un vrai routage (http.ServeMux s'est nettement amélioré avec Go 1.22) et des tests, et vous obtenez un service API.

Étape 5 : les tests et la bibliothèque standard avant les frameworks

go test est fourni avec Go, et la plupart des tests Go sont pilotés par table, comme celui-ci.

example.gogo
func TestAdd(t *testing.T) {
    cases := []struct {
        name     string
        a, b, want int
    }{
        {"zero", 0, 0, 0},
        {"positive", 2, 3, 5},
        {"negative", -1, 1, 0},
    }
    for _, tc := range cases {
        t.Run(tc.name, func(t *testing.T) {
            if got := Add(tc.a, tc.b); got != tc.want {
                t.Errorf("Add(%d, %d) = %d, want %d", tc.a, tc.b, got, tc.want)
            }
        })
    }
}

example.gogo
$ go test -v ./...
=== RUN   TestAdd
=== RUN   TestAdd/zero
=== RUN   TestAdd/positive
=== RUN   TestAdd/negative
PASS

Aucune bibliothèque d'assertions ni aucun framework de mocking n'intervient. Le tutoriel officiel de l'équipe Go comporte un chapitre sur le fuzzing (go test -fuzz), et le package testing prend en charge les benchmarks (go test -bench) nativement. Professional Go Testing couvre les patterns dont vous aurez besoin quand vos tests dépasseront le stade des exemples jouets.

Dans l'enquête du second semestre 2024, « maintenir des standards de code cohérents » était le défi n° 1, à 58 %. Les tests permettent à une équipe d'imposer cette cohérence automatiquement au lieu d'en débattre en code review.

Autres packages de la bibliothèque standard à bien connaître, à peu près dans cet ordre :

• errors, fmt : enveloppement d'erreurs avec %w, errors.Is, errors.As.
• io, os : readers, writers, gestion des fichiers.
• encoding/json : struct tags, encodeurs, décodeurs.
• context : déjà abordé plus haut.
• net/http : déjà abordé plus haut.
• database/sql : pool de connexions, requêtes préparées. Ajoutez pgx ou sqlite plus tard.
• log/slog : logs structurés, ajouté dans Go 1.21. Remplacez log par celui-ci dès le premier jour.

Étape 6 : faut-il apprendre un framework web, et quand ?

La plupart des feuilles de route publiées placent Gin, Echo et Fiber dès le début. Le matériel de démarrage de l'équipe Go utilise lui-même Gin, mais Effective Go et les tutoriels sur la bibliothèque standard utilisent directement net/http. La documentation officielle se contredit vraiment sur ce point, et nous nous rangeons du côté de la bibliothèque standard.

Voici pourquoi :

• net/http fait partie du runtime. Les frameworks sont des dépendances que vous devez maintenir au fil des mises à jour de Go.
• L'enquête 2025 classe les « modules Go fiables » au 3e rang des frustrations (26 %). Choisir un framework est généralement la première fois qu'un nouveau développeur Go s'y heurte.
• Les améliorations de http.ServeMux dans Go 1.22 ont supprimé la plupart des raisons de routage qui poussaient à choisir Gin. Le routage par méthode et les paramètres de chemin font désormais partie de la bibliothèque standard.

Apprenez un framework quand un projet en a réellement besoin. Gin et Echo conviennent très bien. Fiber contourne entièrement net/http et repose sur fasthttp, ce qui entraîne ses propres problèmes de compatibilité avec les middlewares.

Si la mission consiste à « construire une API JSON pour une startup », net/http associé à chi (un routeur léger et idiomatique) est une combinaison que vous n'aurez pas besoin d'abandonner par la suite.

Carrière et salaire : ce que disent les données (et ce qu'elles ne disent pas)

Il n'existe aucun jeu de données public rigoureux qui isole la rémunération propre à Go. Le 2025 End of Year Pay Report de Levels.fyi couvre 245 000 points de données dans 5 000 entreprises et ne ventile pas du tout par langage. (source)

Voici ce qui existe :

• La Stack Overflow Developer Survey 2025 indique que Go est utilisé par 16,4 % de l'ensemble des répondants et 17,4 % des développeurs professionnels, ce qui le place au 13e rang des langages de programmation. (source)
• Le salaire déclaré sur Glassdoor pour un « Go Developer » aux États-Unis, consulté en avril 2026, s'élève en moyenne à 133 673 $, avec un 25e centile à 105 368 $ et un 75e à 171 400 $. Ces chiffres sont autodéclarés, ils ont donc moins de poids que des données de paie.
• La Go Developer Survey 2025 montre que 75 % des répondants ont plus de 6 ans d'expérience professionnelle en développement. La plupart des développeurs Go avaient déjà une carrière backend avant Go, et « développeur Go » est rarement le premier emploi de quelqu'un.

Go n'est donc pas un langage qu'on apprend en bootcamp pour être embauché six semaines plus tard. Il est très utilisé dans des entreprises qui paient bien (Google, Cloudflare, Uber et Datadog font toutes tourner beaucoup de Go), et il constitue une excellente deuxième compétence en plus d'une expérience backend. Notre comparaison honnête de Go et Rust pour le backend examine comment les deux se comparent côté recrutement.

Pour la feuille de route, cela signifie que vous ne devriez pas vous organiser en fonction des données salariales. Devenez bon pour construire des choses, et les opportunités d'emploi suivront.

Une mise en garde : l'équipe Go ne publie aucune feuille de route officielle

L'équipe Go publie le Tour of Go, Effective Go, la spécification du langage, l'index de la documentation et l'enquête développeurs. Aucun de ces documents n'est une feuille de route. L'élément officiel qui s'en rapproche le plus est la page go.dev/learn, qui classe les ressources en niveaux débutant, intermédiaire et avancé.

Toutes les « Go Developer Roadmap » que vous trouverez en ligne sont écrites par la communauté, celle-ci comprise. Le dépôt de feuille de route d'Alikhll sur GitHub, qui compte 18,4k étoiles, indique toujours « in 2021 » dans son README. Le parcours Go de roadmap.sh est bon, mais commercial. Les feuilles de route publiées sur Medium se copient pour la plupart les unes les autres.

Soyez donc sceptique face à l'étiquette. Le parcours qui tient la route, c'est le Tour officiel, puis Effective Go, puis les CLI et les services HTTP, avec une concurrence apprise sur des charges de travail réelles et des tests écrits au fur et à mesure. Les frameworks viennent en dernier.

Questions fréquentes

Combien de temps faut-il pour devenir développeur Go ?

Si vous faites déjà du backend dans un autre langage, trois mois de pratique régulière suffisent pour livrer du Go en production. En partant de zéro, comptez 9 à 12 mois, et attendez-vous à passer une grande partie de ce temps à comprendre le fonctionnement des systèmes plutôt qu'à apprendre la syntaxe.

Faut-il un diplôme en informatique pour devenir développeur Go ?

Non. L'enquête 2025 ne suit pas le diplôme comme critère d'embauche, et la place importante de Go dans les postes DevOps et de platform engineering fait que beaucoup de développeurs Go sont arrivés par l'exploitation ou en autodidactes.

Faut-il apprendre Gin/Echo/Fiber en tant que débutant ?

Pas en premier. Construisez un service net/http de bout en bout pour comprendre le routage, les middlewares et le cycle de vie d'une requête. Ajoutez un framework plus tard si votre projet en tire un réel bénéfice.

Quelle est la meilleure façon de pratiquer Go après le Tour ?

Construisez les deux choses que livrent les développeurs Go en activité : un outil CLI et un service HTTP. Ajoutez ensuite des tests et un Dockerfile. Cela couvre ~80 % du quotidien d'un poste de développeur Go junior.

Go est-il toujours demandé en 2026 ?

Oui. La Stack Overflow 2025 montre une utilisation de Go à 17,4 % chez les développeurs professionnels, en hausse de 2 points de pourcentage par rapport à 2024. La Go Developer Survey affiche 91 % de satisfaction (63 % de « très satisfaits ») pour la septième année consécutive.

Pour aller plus loin

Si vous voulez un parcours interactif qui suit les étapes ci-dessus, le cours Go Fundamentals de LevelUpGo couvre dans l'ordre la toolchain, les idiomes, la concurrence, la bibliothèque standard et les tests. L'offre gratuite couvre les bases. Pro débloque les cours de projets dans lesquels vous construisez les CLI et les services HTTP que recommande cette feuille de route.