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 moderne de projet basée sur les modules. Relie les conventions de répertoires à la manière dont Go résout les paquets.

Leçon 2 • Choisir et configurer un éditeur

Passe en revue les éditeurs et IDE populaires avec le support 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 Go essentielles

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 courte de variable et les constantes typées. Introduit la garantie de valeur zéro de Go comme fonctionnalité de sécurité.

Leçon 2 • Entrée et sortie 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 type et iota

Explique les règles de conversion de type explicite et l'énumérateur iota pour les constantes. Prévent les bogues courants de non-correspondance de type dès le début de l'apprentissage.

Leçon 4 • Structure de programme et paquets

Examine l'anatomie d'un fichier source Go, y compris les déclarations de paquets 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. Développe des habitudes sécurisées de gestion des ressources dès le début.

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éfinir et appeler des fonctions

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

Leçon 1 • Tableaux : Collections à longueur fixe

Définit la syntaxe des tableaux, la sémantique de valeur et les contraintes de taille. Contraste les tableaux avec les 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 structure de données associative principale 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 éléments 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. Met l'accent sur quand et pourquoi éviter unsafe dans le code d'application.

Leçon 2 • Ramasse-miettes de Go

Décrit le GC à trois couleurs de type marquage-et-balayage, 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ù vivent les variables 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éfinir et utiliser des 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

Dé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 déverrouille 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 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 de canal 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 travailleurs, les pipelines et les architectures d'éventail (fan-out/fan-in). Les étudiants appliquent les primitives à des conceptions de charges de travail concurrentes réelles.

Leçon 4 • Canaux : Tubes 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 • Tests unitaires avec le package testing

Introduit les fonctions de test, les tests pilotés par des tableaux et les sous-tests. Les tests automatisés sont la principale porte 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 centrale dans 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 versionnement et le proxy de module. Les constructions reproductibles dépendent d'une configuration correcte des modules.