Cours d'initiation à la programmation Go

Leçon 1 • Comprendre l'espace de travail Go

Explique la disposition traditionnelle de l'espace de travail et la structure de projet moderne basée sur les modules. Établit le lien entre les conventions de répertoires et la manière dont Go résout les packages.

Leçon 2 • Choix et configuration d'un éditeur

Passe en revue les éditeurs et IDE populaires prenant en charge Go et configure les fonctionnalités du serveur de langage. Des outils productifs accélèrent l'apprentissage tout au long du cours.

Leçon 3 • Commandes CLI de base de Go

Présente les sous-commandes essentielles de la commande go utilisées quotidiennement. Les étudiants gagnent en confiance pour exécuter, compiler et tester du code depuis le terminal.

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

Couvre les déclarations var, la syntaxe de déclaration courte et les constantes typées. Introduit la garantie de valeur zéro de Go comme fonctionnalité de sécurité.

Leçon 2 • Entrées et sorties formatées

Enseigne les verbes du package fmt pour l'affichage et la lecture des entrées utilisateur. Relie la connaissance de la syntaxe au comportement visible du programme.

Leçon 3 • Conversions de types et iota

Explique les règles de conversion de type explicite et l'énumérateur iota pour les constantes. Prévent les erreurs courantes d'incompatibilité de type dès le début de l'apprentissage.

Leçon 4 • Structure du programme et packages

Examine l'anatomie d'un fichier source Go, y compris les déclarations de package et les importations. Établit les règles structurelles que tout programme Go doit suivre.

Leçon 1 • Defer, Panic et Recover

Introduit les appels différés pour le nettoyage et le mécanisme panic/recover pour le confinement des erreurs. Construit des habitudes de gestion sécurisée des ressources dès le départ.

Leçon 2 • Fermetures et fonctions d'ordre supérieur

Explore comment les fermetures capturent les variables et comment les fonctions acceptent ou retournent d'autres fonctions. Prépare les étudiants aux motifs fonctionnels utilisés dans les bibliothèques Go.

Leçon 3 • Boucles et itération

Explique le mot-clé de boucle unique for de Go et ses trois formes. Relie les motifs d'itération à une utilisation ultérieure avec les tranches et les maps.

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

Enseigne les signatures de fonction, les valeurs de retour multiples et les retours nommés. Établit les conventions de fonction de Go utilisées tout au long du reste du cours.

Leçon 1 • Tableaux : collections de longueur fixe

Définit la syntaxe des tableaux, la sémantique de valeur et les contraintes de taille. Oppose les tableaux aux tranches pour motiver pourquoi les tranches dominent le code Go.

Leçon 2 • Maps : stockage clé-valeur

Explique la création de maps, les opérations CRUD et l'idiome virgule-ok. Les maps sont la principale structure de données associative dans les programmes Go.

Leçon 3 • Itération sur les collections avec range

Enseigne le mot-clé range sur les tranches, tableaux, chaînes et maps. Renforce l'itération Go idiomatique introduite dans le chapitre sur le flux de contrôle.

Leçon 4 • Tranches : séquences dynamiques

Couvre les aspects internes des tranches (pointeur, longueur, capacité) et les opérations courantes. La maîtrise des tranches est essentielle pour presque tous les programmes Go.

Leçon 1 • Package unsafe et accès bas niveau

Passe en revue unsafe.Pointer, Sizeof et Alignof pour les tâches au niveau système. Insiste sur le moment et la raison pour lesquels il faut éviter unsafe dans le code d'application.

Leçon 2 • Le ramasse-miettes de Go

Décrit le GC mark-and-sweep tricolore, le réglage de GOGC et les pauses du GC. Les étudiants apprennent à profiler et à réduire la pression du GC dans les programmes de production.

Leçon 3 • Allocation sur la pile vs. sur le tas

Explique comment le compilateur décide où les variables vivent en utilisant l'analyse d'échappement. Comprendre l'allocation aide les étudiants à écrire du code à faible latence et compatible avec le GC.

Leçon 1 • Définition et utilisation de structures

Couvre la déclaration de structure, l'accès aux champs, l'incorporation et les structures anonymes. Les structures sont le mécanisme principal de Go pour regrouper des données connexes.

Leçon 2 • Composition plutôt qu'héritage

Montre comment l'incorporation de structures et d'interfaces remplace l'héritage classique. Les étudiants conçoivent des hiérarchies de types flexibles et maintenables sans sous-classement.

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

Passe en revue les interfaces io.Reader, io.Writer, fmt.Stringer et error. Leur implémentation permet une intégration transparente avec la bibliothèque standard de Go.

Leçon 4 • Interfaces et implémentation implicite

Explique la déclaration d'interface, la satisfaction implicite et la répartition polymorphe. Les interfaces sont la pierre angulaire du modèle d'extensibilité de Go.

Leçon 1 • État partagé et le package sync

Introduit Mutex, RWMutex, Once et les opérations atomiques pour la concurrence en mémoire partagée. Complète les motifs basés sur les canaux pour les sections critiques en termes de performances.

Leçon 2 • Instruction select et délais d'attente

Enseigne le multiplexage des opérations sur les canaux avec select et l'implémentation de délais d'attente. Permet des programmes concurrents réactifs qui gèrent plusieurs sources d'événements.

Leçon 3 • Motifs de concurrence courants

Démontre les pools de workers, les pipelines et les architectures fan-out/fan-in. Les étudiants appliquent les primitives à des conceptions de charges de travail concurrentes du monde réel.

Leçon 4 • Canaux : tuyaux de communication typés

Couvre les canaux non tamponnés et tamponnés, les types directionnels et la sémantique de fermeture. Les canaux sont l'outil principal de Go pour le partage sécurisé de données entre goroutines.

Leçon 1 • Test unitaire avec le package testing

Introduit les fonctions de test, les tests pilotés par tableaux et les sous-tests. Les tests automatisés sont la principale passerelle de qualité pour les projets Go.

Leçon 2 • Gestion idiomatique des erreurs

Couvre l'interface error, les erreurs sentinelles et les types d'erreur personnalisés. La gestion idiomatique des erreurs est au cœur de la philosophie de fiabilité de Go.

Leçon 3 • Package context pour l'annulation

Enseigne context.Background, WithCancel, WithTimeout et la propagation de valeurs. Le contexte est le mécanisme standard pour les délais et l'annulation à travers les limites des API.

Leçon 4 • Modules Go et gestion des dépendances

Explique go.mod, go.sum, le versioning et le proxy de modules. Les constructions reproductibles dépendent d'une configuration correcte des modules.