Formation au langage Golang

Leçon 1 • Espace de travail Go et système de modules

Explique la structure de projet basée sur les modules introduite dans Go 1.11 et comment go.mod gère les dépendances. Les étudiants créent leur premier module et comprennent l'organisation des paquets.

Leçon 2 • Écrire et exécuter votre premier programme

Présente le paquet main, la fonction main et le paquet fmt pour la sortie. Les étudiants écrivent, compilent et exécutent un programme Hello World de bout en bout.

Leçon 3 • Installer et configurer Go

Explique le téléchargement de la chaîne d'outils Go, la définition de GOPATH et GOROOT, et la vérification de l'installation. Assure un environnement cohérent pour tous les exercices suivants.

Leçon 1 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, de comparaison, logiques et binaires ainsi que la précédence des opérateurs. Les étudiants écrivent des expressions correctes et évitent les pièges courants de précédence.

Leçon 2 • Structures de flux de contrôle

Enseigne if/else, switch, for et defer dans le style idiomatique Go. Les étudiants remplacent les branchements complexes par des motifs de flux de contrôle propres et lisibles.

Leçon 3 • Pointeurs et adressage mémoire

Introduit la syntaxe des pointeurs, le déréférencement et la fonction new. Les étudiants comprennent quand Go passe par valeur vs. par pointeur et évitent les erreurs courantes de pointeur nil.

Leçon 4 • Variables, constantes et valeurs zéro

Couvre les déclarations var, les déclarations courtes de variables, les constantes typées et non typées, et la garantie de valeur zéro de Go. Construit la base pour toutes les manipulations de données ultérieures.

Leçon 1 • Panique, récupération et codage défensif

Distingue la panique des retours d'erreur, montre la récupération dans des fonctions différées et établit des directives pour savoir quand les paniques sont appropriées. Empêche les plantages non gérés à l'exécution.

Leçon 2 • L'interface d'erreur et la gestion idiomatique

Présente l'interface d'erreur intégrée, le paquet errors et le motif if err != nil. Les étudiants adoptent la philosophie de gestion explicite des erreurs de Go dès le départ.

Leçon 3 • Fonctions anonymes et fermetures

Explique comment les fermetures capturent les variables des portées englobantes et comment les fonctions anonymes permettent les rappels et la logique différée. Les étudiants utilisent les fermetures pour écrire du code flexible et concis.

Leçon 4 • Définir et appeler des fonctions

Couvre les signatures de fonctions, le passage de paramètres, les valeurs de retour nommées et les fonctions variadiques. Établit les blocs de construction pour tout code Go modulaire.

Leçon 1 • Assertions de type et commutateurs de type

Couvre les assertions de type sûres et non sûres et la construction de commutateur de type pour distribuer sur des types dynamiques. Les étudiants gèrent des valeurs polymorphes sans surcharge de réflexion.

Leçon 2 • Interfaces et implémentation implicite

Introduit le typage structurel de Go, la déclaration d'interface et l'interface vide. Les étudiants écrivent du code qui accepte tout type satisfaisant un contrat sans déclarations explicites.

Leçon 3 • Méthodes sur les structures

Explique les récepteurs de valeur vs. les récepteurs de pointeur, les ensembles de méthodes et le chaînage de méthodes. Les étudiants attachent un comportement aux types et comprennent quand chaque type de récepteur est approprié.

Leçon 4 • Composition vs. héritage

Démontre l'incorporation de structures comme alternative de Go à l'héritage et montre comment les méthodes promues fonctionnent. Les étudiants construisent des hiérarchies de types flexibles sans couplage basé sur les classes.

Leçon 1 • Visite de la bibliothèque standard

Passe en revue les paquets les plus utilisés de la bibliothèque standard : fmt, os, io, strings, strconv et time. Les étudiants exploitent les fonctionnalités intégrées avant de recourir à des bibliothèques tierces.

Leçon 2 • Écrire et publier des paquets

Guide les étudiants dans la documentation des paquets avec des commentaires godoc, le marquage des versions et la publication sur un registre de modules public. Permet la contribution open-source et la réutilisation.

Leçon 3 • Principes de conception de paquets

Couvre les conventions de nommage, la cohésion et le principe de responsabilité unique pour les paquets. Les étudiants structurent les projets afin que les paquets soient testables et importables de manière indépendante.

Leçon 1 • Goroutines et l'ordonnanceur Go

Explique comment les goroutines sont des threads légers gérés par l'exécution Go et comment l'ordonnanceur M:N fonctionne. Les étudiants lancent des goroutines et comprennent leur cycle de vie.

Leçon 2 • Contexte pour l'annulation et les délais

Enseigne le paquet context pour propager les signaux d'annulation et les délais dans les arbres de goroutines. Les étudiants construisent des services qui s'arrêtent proprement en cas de délai ou d'annulation.

Leçon 3 • Détecter et corriger les conditions de course

Démontre le détecteur de course de Go, les motifs courants de conditions de course et les opérations atomiques via sync/atomic. Les étudiants éliminent les courses avant que le code n'atteigne la production.

Leçon 4 • Primitives de synchronisation

Présente sync.Mutex, sync.RWMutex, sync.WaitGroup et sync.Once pour coordonner les goroutines. Les étudiants choisissent la primitive appropriée pour chaque scénario de synchronisation.

Leçon 1 • Débogage avec Delve et journalisation

Couvre le débogueur Delve pour les points d'arrêt et l'inspection de la pile, et la journalisation structurée avec le paquet log/slog. Les étudiants diagnostiquent efficacement les bogues dans des environnements locaux et distants.

Leçon 2 • Tests unitaires avec le paquet testing

Couvre les conventions de fichier de test, le type testing.T, les tests pilotés par table et les sous-tests. Les étudiants écrivent des suites de tests maintenables qui documentent le comportement attendu.

Leçon 3 • Couverture de code et barrières de qualité

Explique go test -cover, les rapports de couverture HTML et l'intégration de seuils de couverture dans les pipelines CI. Les étudiants appliquent automatiquement des normes de qualité à chaque commit.

Leçon 4 • Benchmarking et profilage

Présente testing.B pour les micro-benchmarks, pprof pour le profilage CPU et mémoire, et trace pour l'analyse des goroutines. Les étudiants identifient et éliminent les véritables goulots d'étranglement de performance.

Leçon 1 • Accès aux bases de données avec database/sql

Présente l'interface database/sql, le regroupement de connexions, les instructions préparées et la gestion des transactions. Les étudiants écrivent du code de base de données sûr et efficace qui évite les injections SQL.

Leçon 2 • Conteneurisation et déploiement de services Go

Couvre les builds Docker multi-étapes pour des images Go minimales, les motifs d'arrêt gracieux et le déploiement sur des plateformes d'orchestration de conteneurs. Les étudiants livrent des services Go de manière fiable.

Leçon 3 • Serveurs HTTP et API REST

Construit des serveurs HTTP en utilisant net/http, définit des routes, analyse les requêtes et écrit des réponses JSON. Les étudiants créent des API REST entièrement fonctionnelles sans frameworks tiers.

Leçon 4 • Observabilité : métriques, tracing et journalisation

Intègre la journalisation structurée, le tracing distribué et l'exposition de métriques dans un service Go. Les étudiants rendent les applications observables et diagnostiquables dans les environnements de production.