Formation Golang avancée

Leçon 1 • Présentation de l'architecture de l'exécution de Go

Examinez les composants centraux de l'exécution de Go : l'ordonnanceur, l'allocateur mémoire et le ramasse-miettes. Ce contexte sert de base à tous les sujets avancés du cours.

Leçon 2 • Fonctionnement interne du ramasse-miettes

Explorez le ramasse-miettes à trois couleurs de type « mark-and-sweep », les barrières d'écriture et la cadence du GC. Ces connaissances permettent un réglage ciblé des performances dans les chapitres suivants.

Leçon 3 • Fondamentaux du modèle mémoire de Go

Définissez la relation « se produit avant » et les garanties de synchronisation en Go. Des modèles mentaux corrects ici préviennent les courses de données dans les travaux ultérieurs sur la concurrence.

Leçon 1 • Primitives de synchronisation en profondeur

Utilisez correctement sync.Mutex, RWMutex, WaitGroup, Once et les opérations atomiques en situation de contention. La sélection appropriée des primitives a un impact direct sur le débit.

Leçon 2 • Plongée dans l'ordonnanceur de goroutines

Analysez l'ordonnanceur M:N, le vol de travail et la préemption pour prédire le comportement des goroutines. Cela sous-tend la conception correcte des pipelines concurrents.

Leçon 3 • Modèles de concurrence avancés

Implémentez des sémaphores, des pools de workers, des limiteurs de débit et des errgroup pour une concurrence structurée. Ces modèles composent les primitives des sections précédentes.

Leçon 4 • Modèles de canaux et pièges

Concevez des pipelines, des modèles « fan-out », « fan-in » et « done-channel » à l'aide de canaux typés. Reconnaître les mauvais usages courants prévient les fuites de goroutines.

Leçon 1 • Structures de données génériques

Construisez des piles, files d'attente, ensembles et cartes génériques avec une conception de contraintes correcte. Ces structures démontrent une réutilisation pratique dans des familles de types non apparentées.

Leçon 2 • Contraintes et unions d'interfaces

Définissez des contraintes précises à l'aide d'unions d'interfaces, de types sous-jacents et de comparable. Des contraintes strictes produisent des API génériques plus sûres et plus expressives.

Leçon 3 • Performances et limites des génériques

Analysez le « stenciling » de formes GC, le passage de dictionnaire et les compromis de monomorphisation. Connaître les limites évite les mauvais usages qui dégradent les performances d'exécution.

Leçon 1 • Réflexion avec le package reflect

Utilisez reflect.Type et reflect.Value pour inspecter et manipuler les types à l'exécution. La réflexion permet des frameworks génériques de sérialisation et d'injection de dépendances.

Leçon 2 • Génération de code comme alternative à la réflexion

Générez du code standard type-safe avec go generate et des outils basés sur l'AST pour remplacer la réflexion coûteuse. Le code généré offre une flexibilité comparable à la réflexion sans coût à l'exécution.

Leçon 3 • Fonctionnement interne des interfaces et disposition d'iface

Examinez les structures iface et eface, la mise en cache d'itab et les pièges des interfaces nil. La connaissance interne prévient les bogues subtils dans le code fortement basé sur les interfaces.

Leçon 1 • Analyse comparative avec le package testing

Écrivez des benchmarks fiables en utilisant testing.B, les sous-benchmarks et benchstat pour une comparaison statistique. Une analyse comparative rigoureuse valide objectivement l'impact de l'optimisation.

Leçon 2 • Techniques d'optimisation mémoire

Réduisez les allocations à l'aide de sync.Pool, de l'alignement des champs de structure et de la pré-allocation de slices. Chaque technique réduit directement la fréquence du GC et les temps de pause.

Leçon 3 • Profilage avec pprof

Collectez les profils CPU, tas, goroutine et bloc à l'aide de pprof et interprétez les flame graphs. Le profilage est la première étape obligatoire avant toute tentative d'optimisation.

Leçon 4 • Traceur d'exécution et analyse de la latence

Utilisez le traceur d'exécution de l'exécution pour diagnostiquer la latence d'ordonnancement, les pauses du GC et le blocage des appels système. L'analyse des traces révèle les goulots d'étranglement de concurrence invisibles pour pprof.

Leçon 1 • Erreurs sentinelles et hiérarchies d'erreurs

Définissez des erreurs sentinelles au niveau du package et des hiérarchies d'erreurs typées pour des diagnostics spécifiques au domaine. Une taxonomie d'erreurs cohérente améliore l'ergonomie pour l'appelant dans les grandes bases de code.

Leçon 2 • Mocking, stubs et bouchons de test

Concevez des interfaces testables et injectez des mocks ou des stubs pour isoler les unités sous test. L'injection basée sur les interfaces permet des tests rapides et déterministes sans dépendances réelles.

Leçon 3 • Tests pilotés par les données et sous-tests

Structurez des suites de tests complètes avec des cas pilotés par des données et des sous-tests t.Run pour l'isolation. Cette approche fait évoluer la couverture des tests sans dupliquer la logique de configuration.

Leçon 4 • Encapsulation et désencapsulation d'erreurs

Utilisez fmt.Errorf avec %w, errors.Is et errors.As pour construire des chaînes d'erreurs inspectables. Les erreurs structurées permettent un traitement précis sans correspondance de chaînes.

Leçon 1 • Le package unsafe

Utilisez unsafe.Pointer, uintptr et Sizeof pour la manipulation mémoire bas niveau avec des règles de sécurité explicites. Les opérations unsafe sont nécessaires pour la sérialisation haute performance et les FFI.

Leçon 2 • Performances de CGo et alternatives

Mesurez la surcharge des appels CGo et évaluez les alternatives possibles : syscall, purego et bibliothèques partagées. Choisir la bonne stratégie FFI permet d'équilibrer performances, portabilité et sécurité.

Leçon 3 • Fondamentaux de CGo

Appelez des fonctions C depuis Go et exportez des fonctions Go vers C à l'aide de directives CGo et de correspondances de types. CGo permet l'intégration avec des bibliothèques C existantes et des API au niveau du système d'exploitation.

Leçon 1 • Arrêt gracieux et gestion des signaux

Implémentez des séquences d'arrêt sensibles aux signaux qui vident les requêtes en cours et libèrent proprement les ressources. Un arrêt gracieux évite les pertes de données et les erreurs de connexion lors des déploiements.

Leçon 2 • Métriques et tracing distribué

Instrumentez les services avec les métriques et les traces OpenTelemetry pour exposer la latence, les taux d'erreur et le débit. Les données d'instrumentation animent la surveillance des SLO et le diagnostic des incidents.

Leçon 3 • Modèles de résilience dans les services Go

Appliquez des disjoncteurs, des tentatives avec backoff et des cloisons étanches pour prévenir les défaillances en cascade. Ces modèles rendent les services auto-cicatrisants en cas de pannes partielles d'infrastructure.

Leçon 4 • Configuration et injection de dépendances

Gérez la configuration avec des variables d'environnement, des fichiers et une validation ; câblez les dépendances explicitement. Un câblage explicite améliore la testabilité et élimine l'état global caché.