Formation aux bases de la programmation Go

Leçon 1 • Installation et configuration de Go

Couvre l'installation de Go, la disposition de l'espace de travail et la configuration de la chaîne d'outils. Fournit la base opérationnelle dont dépend chaque chapitre suivant.

Leçon 2 • Opérateurs et expressions

Couvre les opérateurs arithmétiques, de comparaison, logiques et binaires. Les étudiants acquièrent la capacité de construire des expressions correctes dans tout contexte Go.

Leçon 3 • Variables, constantes et types de données

Enseigne les styles de déclaration de variables, les valeurs zéro et les types primitifs intégrés. Développe la conscience des types requise pour chaque tâche de codage ultérieure.

Leçon 4 • Utilisation de la chaîne d'outils Go

Explore les commandes go build, go fmt, go vet et go doc. Équipe les étudiants des outils de flux de travail quotidiens utilisés dans le développement Go professionnel.

Leçon 1 • Définition et appel de fonctions

Présente les signatures de fonctions, les paramètres et les valeurs de retour. Établit la brique de base pour le code Go modulaire utilisé tout au long du cours.

Leçon 2 • Boucles et itération

Couvre la boucle for dans toutes ses formes, y compris l'itération basée sur range. Fournit les outils d'itération nécessaires pour traiter les collections et les flux.

Leçon 3 • Defer, Panic et Recover

Explique les appels différés, la propagation des paniques et les modèles de récupération. Les étudiants apprennent l'approche idiomatique de Go pour le nettoyage des ressources et le confinement des erreurs.

Leçon 4 • Fonctions de première classe et fermetures

Traite les fonctions comme des valeurs, couvrant les fonctions anonymes et les fermetures. Prépare les étudiants aux modèles d'ordre supérieur utilisés dans les chapitres suivants.

Leçon 1 • Tableaux en Go

Couvre la déclaration de tableaux de longueur fixe, l'indexation et la sémantique de valeur. Établit le modèle mémoire qui sous-tend le comportement des slices dans les sections suivantes.

Leçon 2 • Modèles courants de slices

Démontre les idiomes de filtrage, de déduplication et de modification sur place. Construit une boîte à outils pratique pour la manipulation de slices utilisée dans les codebases réels.

Leçon 3 • Slices : internes et opérations

Explique les en-têtes de slice, les tableaux sous-jacents et le comportement de croissance. La maîtrise de ceci évite les bogues courants dans la manipulation de données tout au long du cours.

Leçon 4 • Structures en tant qu'enregistrements composites

Présente la déclaration de structure, l'accès aux champs, l'imbrication et les champs anonymes. Jette les bases du système de types exploré dans le chapitre suivant.

Leçon 1 • Ajout et gestion des dépendances

Enseigne go get, go mod tidy et la sélection de version de dépendance. Les étudiants maintiennent des graphes de dépendances propres et reproductibles dans des projets réels.

Leçon 2 • Publication et versionnage de modules

Explique le marquage de versions, les suffixes de version majeure et les proxys de modules. Prépare les étudiants à partager des bibliothèques réutilisables avec l'écosystème Go.

Leçon 3 • Modules Go et go.mod

Explique l'initialisation de module, le fichier go.mod et le versionnage sémantique. Établit le contrat de dépendance qui régit tous les projets Go modernes.

Leçon 4 • Principes d'organisation des packages

Couvre le nommage des packages, les identifiants exportés vs non exportés et la cohésion. Guide les étudiants vers des structures de package qui évoluent avec la taille du projet.

Leçon 1 • Méthodes sur les types

Couvre les récepteurs de valeur et de pointeur, les ensembles de méthodes et la promotion via l'imbrication. Établit la manière dont le comportement est attaché aux types en Go.

Leçon 2 • Bonnes pratiques de conception d'interfaces

Couvre les petites interfaces, accepter les interfaces/retourner des concrets et la pollution d'interface. Guide les étudiants vers des limites d'API maintenables et testables.

Leçon 3 • Interfaces de la bibliothèque standard

Examine les interfaces io.Reader, io.Writer, fmt.Stringer et error. Relie la théorie des interfaces aux interfaces que les étudiants rencontrent quotidiennement.

Leçon 4 • Assertions de type et switches de type

Enseigne les assertions de type sûres et non sûres et le dispatch par switch de type. Permet l'inspection de type à l'exécution nécessaire pour les modèles de gestionnaires génériques.

Leçon 1 • Journalisation et bases de l'observabilité

Présente la journalisation structurée avec les packages log et log/slog. Relie la gestion des erreurs à la visibilité opérationnelle dans les systèmes de production.

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

Couvre les chaînes d'erreurs, errors.Is, errors.As et les arbres de désencapsulation. Les étudiants apprennent à inspecter les erreurs superposées sans briser l'encapsulation.

Leçon 3 • Modèles Panic et Recover

Revient sur panic et recover dans le contexte de la sécurité des limites de bibliothèque. Les étudiants savent quand convertir les paniques en erreurs aux surfaces d'API.

Leçon 4 • Le modèle d'erreur en Go

Explique l'interface error, les vérifications nil et la propagation idiomatique des erreurs. Établit le modèle mental qui régit toute la gestion des erreurs en Go.

Leçon 1 • Synchronisation avec le package sync

Couvre Mutex, RWMutex, WaitGroup et Once pour la sécurité des états partagés. Complète la concurrence basée sur les canaux pour les scénarios nécessitant une mémoire partagée.

Leçon 2 • Goroutines et l'ordonnanceur Go

Explique la création de goroutines, l'ordonnanceur M:N et le cycle de vie des goroutines. Fournit le modèle conceptuel nécessaire pour raisonner sur l'exécution concurrente.

Leçon 3 • Modèles de concurrence courants

Démontre les pools de workers, les pipelines et les architectures fan-out/fan-in. Les étudiants appliquent ces modèles pour construire des programmes concurrents évolutifs.

Leçon 4 • Instruction Select et multiplexage

Enseigne l'instruction select pour le multiplexage des opérations sur canaux. Permet les modèles de temporisation, d'annulation et de fan-in utilisés dans les services de production.

Leçon 1 • Helpers de test et fixtures de test

Enseigne les fonctions helper, TestMain et la configuration de ressources temporaires. Réduit le code passe-partout et améliore la lisibilité des tests dans les grandes suites de tests.

Leçon 2 • Benchmark et profilage

Couvre les fonctions de benchmark, les boucles B.N et l'intégration pprof. Les étudiants identifient et éliminent les goulets d'étranglement de performance avec des preuves basées sur les données.

Leçon 3 • Écriture de tests unitaires avec le package testing

Couvre les conventions de fichiers de test, T.Error, T.Fatal et les sous-tests. Établit la discipline de test de base requise pour tous les projets Go.

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

Explique les rapports de couverture, go test -cover et l'intégration de linter. Relie les tests aux pipelines d'intégration continue pour un contrôle qualité automatisé.