GolangArrêt gracieux pour serveur HTTP Go
Arrêter un serveur HTTP Go en toute sécurité avec signal.NotifyContext et http.Server.Shutdown, gérer les timeouts, WebSocket, les ressources annexes et Kubernetes.
Lire et écrire du JSON en Go avec encoding/json
Guide sur encoding/json en Go, des opérations Marshal/Unmarshal, struct tag, Encoder/Decoder jusqu'aux types personnalisés, avec tests et erreurs courantes.
Worker pool en Go : limiter les goroutines et annuler en toute sécurité
Comment construire un worker pool en Go avec channel, sync.WaitGroup, context et errgroup pour un traitement parallèle limité, annulable et testable.
Struct embedding dans Go plutôt que l'héritage
Go n'a pas d'héritage. Cet article explique le struct embedding, comment les méthodes sont « promues », les pièges de la réécriture de méthodes et comment combiner l'embedding avec les interfaces.
defer, panic et recover en Go : quand les utiliser
Comprendre defer, panic, recover en Go, les pièges courants, et quand retourner une erreur plutôt que panic.
Profiling Go avec pprof : trouver les points chauds CPU, mémoire et goroutine
Guide pour utiliser pprof afin de collecter et analyser les profils CPU, heap, goroutine, block et mutex dans une application Go, du service HTTP au benchmark.
Maps en Go et l'erreur « concurrent map writes »
Découvrez le fonctionnement des maps en Go, pourquoi le programme plante avec « concurrent map writes » et comment corriger avec sync.Mutex, sync.RWMutex, sync.Map.
Slices en Go : len, cap et pièges avec append
Comprenez comment les slices partagent un array sous-jacent, le rôle de len et cap, et comment éviter les erreurs d'écrasement de données difficiles à détecter lors de l'utilisation d'append.
Go modules : gestion des dépendances et versioning
Guide complet pour initialiser un projet avec Go modules, ajouter et mettre à niveau les dépendances, gérer les versions majeures, utiliser replace, go.work et les modules privés.
Test piloté par les données en Go
Comment écrire des tests pilotés par les données en Go avec slice struct, t.Run, vérification d'erreurs, exécution parallèle et comparaison de structures avec go-cmp, avec les erreurs courantes.
sync.WaitGroup, Mutex et errgroup : orchestrer les goroutines
Utilisez sync.WaitGroup pour attendre les goroutines, sync.Mutex pour éviter les data races, et errgroup pour regrouper les erreurs, annuler via context et limiter le nombre de goroutines.
Écrire une API REST avec net/http et le routage de Go 1.22
Utilisez ServeMux de Go 1.22 pour matcher la méthode, lire les paramètres de chemin et retourner du JSON. Vous aurez une API REST complète sans avoir besoin de routeur tiers.
Génériques en Go : type parameter par l'exemple
Apprenez à utiliser les type parameter, constraint, la notation ~ et les types génériques en Go à travers les exemples Order, Customer, Stack et Cache.
Gestion des erreurs en Go : errors.Is, errors.As et wrapping
Comment envelopper les erreurs avec %w, vérifier via la chaîne avec errors.Is, extraire les erreurs personnalisées avec errors.As, fusionner les erreurs avec errors.Join et les pièges courants.
Les interfaces Go : petites, implicites et bien utilisées
Les interfaces Go sont satisfaites implicitement. Cet article vous guide pour les garder petites, les placer côté consommateur, les tester avec des fakes et éviter les erreurs de nil interface.
Context en Go : timeout, cancel et transmission de valeurs
Découvrez comment utiliser context.Context en Go pour contrôler les timeouts, les deadlines, annuler des goroutines et transmettre des valeurs request-scoped de manière sécurisée.
Goroutine Leak : L'erreur silencieuse qui dévore votre RAM
Les fuites de goroutines ne crashent pas immédiatement mais dévorent silencieusement ta RAM au fil du temps. Cet article explique les causes courantes, comment les détecter et les corriger définitivement.
Goroutine et channel : fondamentaux de la concurrence en Go
Découvrez comment Go gère la concurrence via les goroutines et les channels, des bases aux patterns pratiques comme WaitGroup, select et context.