Apprenez à programmer avec Go

📚 Résumé du contenu

Une introduction pratique et accessible au langage de programmation Go. Le cours est structuré en leçons courtes et gérables, avec un thème d'exploration spatiale, couvrant la programmation impérative, les types, les fonctions, les méthodes, les collections, l'état et la concurrence.

Découvrez le plaisir de coder avec Go à travers de courtes leçons et sept projets finaux sur des missions spatiales.

Auteur : Nathan Youngman, Roger Peppé

Remerciements : Jennifer Stout, Marina Michaels, Matthew Merkes, Joel Kotarski, Aleksandar Dragosavljević, Renée French, Olga Shalakhina, Erick Zelaya, April Milne, Monica Kamsvaag.

🎯 Objectifs d'apprentissage

1. Définir le langage de programmation Go et ses cas d'utilisation principaux.
2. Expliquer le rôle du compilateur Go et ses avantages par rapport aux interpréteurs.
3. Naviguer dans Go Playground pour écrire, compiler et exécuter du code.
4. Structurer correctement le code Go en utilisant le style obligatoire des accolades ("one true brace style") afin d'éviter les erreurs de syntaxe.
5. Gérer les données à l'aide de différentes techniques de déclaration de variables et d'opérateurs d'affectation arithmétique.
6. Générer des nombres pseudo-aléatoires et implémenter une logique conditionnelle à l'aide de branches et d'opérateurs logiques.
7. Déclarer et formater des variables flottantes en utilisant float32 et float64 avec une largeur et une précision spécifiques.
8. Identifier et atténuer les erreurs causées par les imprécisions flottantes et les dépassements d'entiers (integer wrap-around).
9. Utiliser le package big et les constantes non typées pour traiter des nombres dépassant les limites standard de taille bit.
10. Définir et appeler des fonctions en utilisant des paramètres, des arguments et une syntaxe variadique.

🔹 Leçon 1 : Décollage vers l'orbite

Aperçu : Cette leçon présente Go, le langage de programmation contemporain utilisé dans le cloud computing. Les étudiants apprendront la différence fondamentale entre la nature compilée de Go et les langages interprétés, comment utiliser Go Playground pour expérimenter immédiatement, ainsi que la structure de base d'un programme Go incluant les paquets et la fonction main.

Objectifs d'apprentissage :

• Définir le langage de programmation Go et ses cas d'utilisation principaux.
• Expliquer le rôle du compilateur Go et ses avantages par rapport aux interpréteurs.
• Naviguer dans Go Playground pour écrire, compiler et exécuter du code.

🔹 Leçon 2 : Logique du Centre de mission

Aperçu : Cette leçon introduit les éléments fondamentaux de la programmation Go, en se concentrant sur la structure du code et son exécution. Les étudiants apprendront le style obligatoire des accolades ("one true brace style"), les points d'entrée des programmes, progresseront vers des raccourcis de déclaration de variables et des opérateurs mathématiques, puis concluront par une logique décisionnelle basée sur les booléens, les comparaisons et les branches.

Objectifs d'apprentissage :

• Structurer correctement le code Go en utilisant le style obligatoire des accolades ("one true brace style") pour éviter les erreurs de syntaxe.
• Gérer les données à l'aide de différentes techniques de déclaration de variables et d'opérateurs d'affectation arithmétique.
• Générer des nombres pseudo-aléatoires et implémenter une logique conditionnelle à l'aide de branches et d'opérateurs logiques.

🔹 Leçon 3 : La physique des données spatiales

Aperçu : Cette leçon explore la manière dont Go traite les données numériques, allant de la précision fractionnaire des nombres flottants aux échelles massives nécessaires pour les distances astronomiques. Les étudiants apprendront à gérer les limitations de la mémoire informatique, notamment les imprécisions flottantes et les dépassements d'entiers, tout en maîtrisant la conversion explicite de types et l'utilisation du package big pour des tailles numériques inhabituelles.

Objectifs d'apprentissage :

• Déclarer et formater des variables flottantes en utilisant float32 et float64 avec une largeur et une précision spécifiques.
• Identifier et atténuer les erreurs causées par les imprécisions flottantes et les dépassements d'entiers.
• Utiliser le package big et les constantes non typées pour traiter des nombres dépassant les limites standard de taille bit.

🔹 Leçon 4 : Construction de modules modulaires

Aperçu : Cette leçon aborde les blocs de construction fondamentaux des programmes Go : les fonctions, les types personnalisés et les méthodes. Les étudiants apprendront à encapsuler de la logique pour la réutilisation, à définir de nouveaux types avec des comportements spécifiques, et à tirer parti des fonctions de premier ordre — y compris les fermetures (closures) et les fonctions anonymes — pour créer un code flexible et modulaire. La leçon se termine par un projet final pratique impliquant des tableaux de conversion de température.

Objectifs d'apprentissage :

• Définir et appeler des fonctions en utilisant des paramètres, des arguments et une syntaxe variadique.
• Distinger entre les identifiants exportés et non exportés en suivant les conventions de nommage de Go.
• Créer des types personnalisés et leur attacher des comportements à l'aide de méthodes et de récepteurs.

🔹 Leçon 5 : Approvisionnement de la soute

Aperçu : Cette leçon couvre les structures de données essentielles en Go pour gérer des collections d'informations. Elle passe des tableaux de longueur fixe et de leur comportement de copie mémoire aux tranches dynamiques qui servent de fenêtres flexibles sur les données, puis aux cartes (maps) pour des recherches clé-valeur efficaces. L'unité culmine par le projet final "Jeu de la vie", qui démontre comment utiliser des tranches multidimensionnelles pour simuler des systèmes complexes.

Objectifs d'apprentissage :

• Déclarer, initialiser et itérer à travers des tableaux de longueur fixe et des grilles multidimensionnelles.
• Manipuler des tranches à l'aide de plages d'index et de croissance dynamique via la fonction append.
• Gérer l'efficacité mémoire en distinguant la longueur et la capacité, et en préallouant des collections avec make.

🔹 Leçon 6 : Structuration des habitats martiens

Aperçu : Cette leçon présente la méthode de Go pour organiser des données et des comportements complexes. Les étudiants apprendront à regrouper des types de données disparates dans des structures (structs), à les initialiser à l'aide de littéraux composés, et à gérer leurs comportements grâce à des méthodes et des fonctions constructrices. La leçon explore également le concept unique de conception de Go : privilégier la composition plutôt que l'héritage, et utiliser des interfaces implicites pour obtenir de la polymorphisme.

Objectifs d'apprentissage :

• Définir, initialiser et copier des structures pour gérer des données complexes telles que les coordonnées martiennes et celles des rovers.
• Encoder des structures Go au format JSON à l'aide de balises de structure pour un échange de données personnalisé.
• Implémenter des méthodes, des fonctions constructrices et l'intégration de structures pour créer un code réutilisable et bien organisé.

🔹 Leçon 7 : Navigation dans le tunnel du Gopher

Aperçu : Cette leçon explore le pouvoir et la sécurité de l'indirection en Go, en se concentrant sur la manière dont les pointeurs permettent une mutation efficace des données et une gestion mémoire optimisée. Elle fournit un cadre solide pour la programmation défensive en enseignant aux étudiants comment gérer les valeurs nil, gérer les ressources avec defer, et mettre en œuvre des schémas d'erreur idiomatiques — aboutissant à l'application de ces règles à un moteur de validation de Sudoku.

Objectifs d'apprentissage :

• Utiliser le caractère & et l'astérisque * pour gérer les adresses mémoire et désérialiser des valeurs.
• Implémenter des paramètres et des récepteurs pointeur pour permettre la mutation des données dans les fonctions et les méthodes.
• Naviguer sans panique runtime à travers les valeurs nil dans des tranches, des cartes et des interfaces.

🔹 Leçon 8 : Communication entre plusieurs rovers

Aperçu : Cette leçon présente les primitives fondamentales de concurrence en Go : les goroutines et les canaux. Elle explore comment exécuter des tâches indépendamment, communiquer en toute sécurité entre elles, et gérer l'état partagé à l'aide de Mutexes pour éviter les conditions de course. La leçon se termine par un projet final simulant des rovers martiens naviguant sur une grille et signalant leurs découvertes.

Objectifs d'apprentissage :

• Lancer et gérer des tâches concurrentes à l'aide du mot-clé go.
• Mettre en œuvre une communication sécurisée entre goroutines à l'aide de canaux et de l'instruction select.
• Construire des pipelines de données et gérer les cycles de vie des goroutines en fermant les canaux.