Cours d'introduction à 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 façon dont Go résout les paquets.

Leçon 2 • Choisir et configurer un éditeur

Passe en revue les éditeurs et IDE populaires avec prise en charge de Go et configure les fonctionnalités du serveur de langage. Un outillage productif accélère 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 et étudiantes acquièrent de l'assurance 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 abrégée des variables et les constantes typées. Présente 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 paquet fmt pour l'affichage et la lecture des entrées utilisateur. Établit le lien entre la connaissance de la syntaxe et le 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évient les bogues courants de non-concordance de type dès le début du parcours d'apprentissage.

Leçon 4 • Structure du programme et paquets

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

Leçon 1 • Defer, Panic et Recover

Présente les appels différés pour le nettoyage et le mécanisme panic/recover pour le confinement des erreurs. Développe de bonnes habitudes de gestion sécuritaire 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 et étudiantes aux patrons 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. Établit le lien entre les motifs d'itération et l'utilisation ultérieure avec les tranches et les dictionnaires.

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 Go utilisées tout au long du cours.

Leçon 1 • Tableaux : collections de taille fixe

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

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

Explique la création de dictionnaires, les opérations CRUD et l'idiome virgule-ok. Les dictionnaires 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 dictionnaires. Renforce l'itération idiomatique Go introduite dans le chapitre sur le flux de contrôle.

Leçon 4 • Tranches : séquences dynamiques

Couvre les composantes 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 • Paquet unsafe et accès de bas niveau

Passe en revue unsafe.Pointer, Sizeof et Alignof pour les tâches systèmes. 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 à balayage et marquage trichromique, le réglage de GOGC et les pauses du GC. Les étudiants et étudiantes 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'évasion. Comprendre l'allocation aide les étudiants et étudiantes à écrire du code à faible latence et favorable au GC.

Leçon 1 • Définir et utiliser des structures

Couvre la déclaration de structure, l'accès aux champs, l'imbrication 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'imbrication de structures et d'interfaces remplace l'héritage classique. Les étudiants et étudiantes 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 io.Reader, io.Writer, fmt.Stringer et l'interface error. Leur implémentation permet une intégration transparente avec la bibliothèque standard Go.

Leçon 4 • Interfaces et implémentation implicite

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

Leçon 1 • État partagé et paquet sync

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

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 de créer des programmes concurrents réactifs qui gèrent plusieurs sources d'événements.

Leçon 3 • Patrons de concurrence courants

Démontre les pools de travailleurs, les pipelines et les architectures d'éventail de sortie (fan-out) et d'éventail d'entrée (fan-in). Les étudiants et étudiantes appliquent les primitives à des conceptions de charge de travail concurrente réelles.

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écuritaire de données entre goroutines.

Leçon 1 • Test unitaire avec le paquet testing

Présente les fonctions de test, les tests pilotés par tableau et les sous-tests. Les tests automatisés sont la première 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 au cœur de la philosophie de fiabilité de Go.

Leçon 3 • Paquet Context pour l'annulation

Enseigne context.Background, WithCancel, WithTimeout et la propagation de valeurs. Context 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 builds reproductibles dépendent d'une configuration de module correcte.