Go dispose d'un excellent profilage intégré via l'outil pprof, et la démarche suit toujours la même discipline : profiler pour trouver le véritable goulot d'étranglement, puis l'optimiser — jamais deviner. Le profilage en Go est une fonctionnalité de première classe, bien intégrée.
_
{ http.ListenAndServe(, ) }()
pprof profile l'utilisation du CPU, les allocations mémoire, les goroutines et les blocages — et génère des flame graphs pour localiser les points chauds. Les endpoints HTTP en direct permettent l'utilisation en production avec un surcoût faible.
func BenchmarkProcess(b *testing.B) {
for i := 0; i < b.N; i++ { Process(data) }
}
// go test -bench=. -benchmem → ns/op AND allocations/op (B/op, allocs/op)
// use benchstat to compare before/after statistically
Les benchmarks (avec -benchmem) mesurent à la fois la vitesse et les allocations — et benchstat compare les exécutions rigoureusement, vous permettant de confirmer qu'une optimisation a réellement aidé.
✓ Reduce allocations (the biggest GC-driven win):
- preallocate slices/maps with known capacity: make([]T, 0, n)
- reuse objects with sync.Pool in hot paths
- minimize heap escapes (check with: go build -gcflags='-m')
- use strings.Builder for string concatenation (not += in loops)
✓ Algorithmic improvements — right data structure (map O(1) vs slice scan O(n))
✓ Concurrency — parallelize independent work with goroutines (use all cores)
- but bound it (worker pools) and beware the overhead for small tasks
✓ Avoid unnecessary interface boxing / reflection in hot paths
✓ I/O — buffer reads/writes (bufio), batch operations, reuse connections
// ❌ allocates a new string each iteration
s := ""
for _, w := range words { s += w }
// ✅ strings.Builder reuses a buffer
var b strings.Builder
for _, w := range words { b.WriteString(w) }
s := b.String()
Réduire les allocations du heap diminue la pression sur le GC, souvent le plus grand levier de performance en Go.
For server apps, the slow part is usually DB queries (N+1, missing indexes) or
network I/O — NOT Go code. Profile to confirm where the time actually goes.
Go est souvent choisi pour les systèmes sensibles aux performances, et son profilage intégré exceptionnel (pprof, benchmarks intégrés, le race detector) fait de l'optimisation une activité bien supportée et de première classe.
La discipline essentielle est la même partout : mesurer d'abord avec pprof/benchmarks pour trouver le goulot d'étranglement réel, puis l'optimiser spécifiquement — deviner gaspille les efforts.
Les connaissances spécifiques à Go comptent : réduire les allocations est fréquemment le plus grand gain (préallocation, sync.Pool, strings.Builder, minimiser les fuites vers le heap) car cela diminue la pression du GC ; les améliorations algorithmiques et la concurrence bornée aident ; et reconnaître que le goulot d'étranglement est souvent la base de données ou l'I/O, pas le code Go, cible correctement les efforts.
Savoir utiliser pprof efficacement, benchmarker rigoureusement (-benchmem, benchstat), et appliquer les bonnes optimisations est une compétence clé de niveau senior en Go, d'autant plus que Go est choisi précisément pour construire des services rapides et scalables.