Formation Apprendre la programmation Go

1. Introduction à Go

• Qu'est-ce que Go (Golang) ?
• Histoire et philosophie de conception de Go
• Go comme langage de programmation pour le web et les systèmes
• Caractéristiques clés :
  • Typage statique
  • Simplicité et lisibilité
  • Compilation rapide
  • Concurrence intégrée
  • Collecte des ordures (garbage collection)
  • Compilation multiplateforme
• Cas d'utilisation courants de Go
• Avantages et limites de Go
• Comparaison de Go avec C/C++, JavaScript, Ruby, Python et Java
• Compréhension de l'écosystème Go
• Aperçu de la bibliothèque standard Go
• Modules Go et gestion des dépendances
• Anatomie d'une application Go
• Pratique : Examiner et exécuter un simple programme Go

2. Configuration de l'environnement de développement Go

• Installation de Go
• Compréhension de la chaîne d'outils Go (toolchain)
• Configuration des variables d'environnement
• Choix d'un IDE ou d'un éditeur de code
• Utilisation de la ligne de commande avec Go
• Création d'un espace de travail Go
• Compréhension de la structure de projet Go
• Initialisation d'un projet avec Go Modules
• Utilisation de go mod init
• Gestion des dépendances avec go get
• Mise à jour et inspection des dépendances
• Mise en forme du code source avec gofmt
• Exécution des programmes avec go run
• Construction des applications avec go build
• Installation des applications Go
• Compilation croisée des applications
• Pratique : Créer et configurer un projet Go à l'intérieur d'un conteneur

3. Variables, constantes et types en Go

• Déclaration des variables
• Types explicites par rapport aux types inférés
• Déclarations de variables courtes
• Constantes
• Values nulles (zero values)
• Portée et durée de vie des variables
• Types de données primitives :
  • Entiers
  • Nombres à virgule flottante
  • Nombres complexes
  • Booléens
  • Chaînes de caractères
• Conversions de types
• Manipulation de l'Unicode et de l'UTF-8
• Runes et octets (bytes)
• Affectation multiple de variables
• Compréhension de la sécurité des types
• Exercice : Construire un petit programme de traitement de données en ligne de commande

4. Opérateurs et expressions

• Opérateurs arithmétiques
• Opérateurs de comparaison
• Opérateurs logiques
• Opérateurs d'affectation
• Incrémentation et décrémentation
• Précédence des opérateurs
• Manipulation des calculs entiers et à virgule flottante
• Éviter les erreurs courantes de conversion de types
• Exercice : Implémenter la logique de calcul et de validation

5. Dates, heures et formatage

• Utilisation du paquet time
• Création et manipulation des dates
• Récupération de l'heure actuelle
• Fuseaux horaires et localisations
• Interprétation (parsing) des dates et heures
• Formatage des dates et heures
• Calcul des durées
• Manipulation des horodatages Unix (timestamps)
• Gestion des dépassements de délai (timeouts)
• Exercice : Ajouter des horodatages et des calculs de durée à une application

6. Tableaux, tranches (slices), maps et structures (structs)

Tableaux

• Déclaration de tableaux
• Initialisation de tableaux
• Itération sur les tableaux
• Tableaux multidimensionnels

Tranches (Slices)

• Compréhension des différences entre tranches et tableaux
• Création de tranches
• Ajout d'éléments
• Copie de tranches
• Longueur et capacité des tranches
• Sous-tranches (slicing)
• Pièges courants liés aux tranches

Maps

• Création de maps
• Ajout et suppression d'entrées
• Vérification de l'existence d'une clé
• Itération sur les maps
• Maps contenant des données complexes

Structures (Structs)

• Définition des structures

• Champs des structures

• Initialisation des structures

• Structures imbriquées

• Structures anonymes

• Méthodes des structures

• Étiquettes de structure JSON (JSON struct tags)

• Pratique : Modéliser des utilisateurs, des produits et des données d'application à l'aide de structures, de tranches et de maps

7. Logique conditionnelle et boucles

• Instructions if
• else et else if
• Déclarations de variables dans les conditions
• Boucles for
• Boucles infinies
• Conditions de boucle
• break et continue
• Itération avec range
• Boucles imbriquées
• Instructions switch
• Switch basés sur des expressions
• Multiple cases
• Cas par défaut (default cases)
• Type switches
• Exercice : Implémenter la logique de validation et de traitement de l'application

8. Fonctions

• Définition des fonctions
• Paramètres des fonctions
• Values de retour
• Multiple values de retour
• Values de retour nommées
• Fonctions variadiques
• Fonctions anonymes
• Values de fonctions
• Fermetures (closures)
• Récursion
• Passage de fonctions comme arguments
• Fonctions renvoyant des erreurs
• Conception de petites fonctions réutilisables
• Exercice : Refactoriser le code existant en fonctions réutilisables

9. Pointeurs et concepts de mémoire

• Qu'est-ce qu'un pointeur ?
• Opérateurs d'adresse et de référence
• Pointeurs et paramètres de fonctions
• Récepteurs de pointeurs
• Pointeurs vers des structures
• Pointeurs nuls (Nil pointers)
• Quand utiliser des pointeurs
• Sémantique de valeur par rapport à la référence
• Compréhension de la gestion de la mémoire et de la collecte des ordures en Go
• Erreurs courantes liées aux pointeurs
• Pratique : Modifier des données d'application à l'aide de pointeurs

10. Création d'une application web en Go

• Aperçu des capacités web de Go
• Introduction au paquet net/http
• Création d'un serveur HTTP
• Requêtes et réponses HTTP
• Méthodes HTTP
• URLs de requête et paramètres d'interrogation
• En-têtes HTTP
• Codes de statut HTTP
• Fondamentaux du routage
• Création de gestionnaires (handlers)
• Gestion des données de formulaire
• Serveur de fichiers statiques
• Travail avec des modèles HTML
• Variables de modèle et structures de contrôle
• Structuration d'une application web
• Pratique : Construire un serveur web Go de base

11. Construction d'un service web RESTful

• Fondamentaux de l'architecture REST
• Conception des points d'accès API
• GET, POST, PUT, PATCH et DELETE
• Travail avec JSON
• Encodage et décodage JSON
• Validation des requêtes
• Codes de statut HTTP
• Responses d'erreur
• Paramètres d'interrogation et paramètres de chemin
• Structures de réponse API
• Séparation des gestionnaires de la logique métier
• Pratique : Construire une API REST CRUD

12. Runtime Go, compilation et construction de projets

• Compréhension du compilateur Go
• Processus de construction de Go
• go run
• go build
• go install
• go test
• Drapeaux de construction (build flags)
• Configuration spécifique à l'environnement
• Construction pour différents systèmes d'exploitation et architectures
• Production de binaires autonomes
• Gestion de la configuration de l'application
• Exercice : Compiler l'application pour plusieurs plates-formes

13. Travail avec les fichiers et le web

• Ouverture et fermeture de fichiers
• Lecture de fichiers
• Écriture de fichiers
• Création de répertoires
• Métadonnées des fichiers
• Entrées/sorties tamponnées (Buffered I/O)
• Travail avec les flux (streams)
• Lecture et écriture de fichiers JSON
• Clients HTTP
• Emission de requêtes HTTP sortantes
• Gestion des erreurs du client HTTP
• Dépassements de délai et annulation
• Traitement des réponses API
• Pratique : Récupérer des données d'une API externe et les stocker localement

14. Gestion des erreurs et débogage

• L'approche de Go pour les erreurs
• Renvoyer des erreurs depuis des fonctions
• Vérification des erreurs
• Création d'erreurs personnalisées
• Enveloppement des erreurs (wrapping errors)
• Ajout de contexte aux erreurs
• errors.Is et errors.As
• Panics et récupération
• Quand utiliser panic
• Débogage des problèmes courants en Go
• Journalisation de l'activité de l'application
• Utilisation des outils de débogage Go
• Exercice : Diagnostiquer et corriger des erreurs d'application introduites volontairement

15. Interfaces et abstraction

• Qu'est-ce qu'une interface ?
• Implémentation implicite d'interfaces
• Définition d'interfaces
• Values d'interface
• Interfaces vides / any
• Affirmations de type
• Type switches
• Implémentations par pointeur par rapport à la valeur
• Conception de petites interfaces
• Inversion de dépendances
• Utilisation des interfaces pour le test
• Réduction du couplage de l'application
• Pratique : Introduire des interfaces dans l'application web d'exemple

16. Paquets et organisation du projet

• Création de paquets
• Conventions de nommage des paquets
• Identifiants exportés et non exportés
• Importation de paquets
• Initialisation des paquets
• Organisation des couches d'application
• Paquets internes
• Gestion des dépendances avec Go Modules
• Versioning sémantique
• Utilisation de paquets tiers
• Évitement des dépendances circulaires
• Conception de projets Go maintenables
• Exercice : Refactoriser l'application en paquets distincts

17. Concurrence avec les Goroutines

• Qu'est-ce que la concurrence ?
• Goroutines
• Démarrage de goroutines
• Compréhension de l'exécution concurrente légère
• Défis de synchronisation
• État partagé
• Conditions de course (race conditions)
• Utilisation de sync.WaitGroup
• Mutexes et mutexes en lecture/écriture
• Opérations atomiques
• Pratique : Convertir une tâche séquentielle en traitement concurrent

18. Canaux (Channels)

• Compréhension des canaux
• Envoi et réception de valeurs
• Canaux tamponnés par rapport aux canaux non tamponnés
• Comportement bloquant
• Fermeture des canaux
• Itération sur les canaux (ranging over channels)
• Canaux directionnels
• Communication basée sur les canaux
• Instructions Select
• Dépassements de délai et annulation
• Modèles de pool de travailleurs (worker-pool patterns)
• Modèles producteur/consommateur
• Pratique : Construire un système de travailleurs concurrent

19. Contexte et gestion des requêtes

• Pourquoi les contextes sont importants dans les applications web
• context.Context
• Contexte de portée de requête
• Annulation
• Délais (deadlines)
• Dépassements de délai (timeouts)
• Propagation du contexte à travers les couches d'application
• Annulation des opérations de base de données ou HTTP
• Évitement du mauvais usage du contexte
• Exercice : Ajouter l'annulation des requêtes et les dépassements de délai à l'application web

20. Test des applications Go

• Pourquoi les tests automatisés sont importants
• Rédaction de tests unitaires
• Le paquet testing
• Fonctions de test
• Conventions de nommage des tests
• Tests basés sur des tables
• Test des erreurs
• Test des gestionnaires HTTP
• Serveurs de test HTTP
• Fixtures de test
• Couverture des tests
• Tests de référence (Benchmarks)
• Tests d'exemple
• Test des interfaces avec des mocks ou des fakes
• Pratique : Créer une suite de tests pour l'application d'exemple

21. Optimisation des performances

• Compréhension des performances des applications Go
• Identification des goulets d'étranglement
• Performances CPU par rapport à la mémoire
• Structures de données efficaces
• Réduction des allocations inutiles
• Chaînes de caractères, octets et tampons
• Gestion des goroutines
• Évitement de la concurrence excessive
• Stratégies de cache
• Considérations sur la base de données et le réseau
• Profilage des applications
• Tests de référence et de performance
• Utilisation des outils de profilage Go
• Exercice : Profiler et optimiser une application volontairement inefficace

22. Sécurité et bonnes pratiques pour des applications web robustes

• Validation des entrées utilisateur
• Gestion sûre des requêtes HTTP
• Prévention des vulnérabilités web courantes
• Gestion sûre des erreurs
• Concepts d'authentification et d'autorisation
• Gestion des secrets et de la configuration
• Communication HTTP sécurisée
• Évitement des informations sensibles dans les journaux
• Gestion et mises à jour des dépendances
• Limites de ressources et dépassements de délai des requêtes
• Exercice : Revoir et durcir l'API d'exemple

23. Journalisation et observabilité des applications

• Fondamentaux de la journalisation
• Journalisation structurée
• Niveaux de journalisation
• Journalisation des requêtes
• Journalisation des erreurs
• Corrélation et identifiants de requête
• Surveillance du comportement de l'application
• Métriques de base
• Points de contrôle de santé (Health-check endpoints)
• Diagnostic des problèmes en production
• Pratique : Ajouter la journalisation structurée et les contrôles de santé

24. Conteneurisation de l'application Go

• Pourquoi utiliser des conteneurs ?
• Applications Go et conteneurisation
• Rédaction d'un Dockerfile
• Constructions multi-étapes
• Construction d'une image de runtime minimale
• Gestion de la configuration via des variables d'environnement
• Réseautage des conteneurs
• Exposition des ports de l'application
• Exécution de l'application dans un conteneur
• Test de l'application conteneurisée
• Pratique : Emballer l'application Go d'exemple en un conteneur prêt pour la production

25. Déploiement

• Préparation d'une application pour la production
• Construction de binaires de production
• Configuration de l'environnement
• Déploiement basé sur les conteneurs
• Architecture de déploiement
• Proxies inverses
• Considérations HTTPS/TLS
• Contrôles de santé de l'application
• Arrêt gracieux (Graceful shutdown)
• Gestion des signaux du système d'exploitation
• Passage à l'échelle des applications web Go
• Passage à l'échelle horizontal par rapport à vertical
• Diagnostic de base des problèmes de déploiement
• Pratique : Déployer l'application web d'exemple

26. Projet de fin de cours : Application web Go complète

Les participants regroupent les concepts en développant une application complète.

Le projet peut inclure :

• Initialisation du projet avec Go Modules
• Organisation des paquets
• Routage HTTP
• Points d'accès API REST
• Gestion des requêtes et réponses JSON
• Validation des entrées
• Gestion des erreurs
• Interfaces
• Traitement concurrent
• Communication avec des API externes
• Persistance de fichiers ou de base de données
• Tests automatisés
• Journalisation
• Considérations sur les performances
• Conteneurisation
• Configuration de production
• Déploiement

27. Revue et meilleures pratiques

• Revue de la syntaxe fondamentale de Go
• Conventions de codage Go
• Écriture de Go idiomatique
• Conserver le code simple
• Conception efficace des paquets
• Meilleures pratiques de gestion des erreurs
• Principes de conception des interfaces
• Meilleures pratiques de concurrence
• Stratégies de test
• Considérations sur les performances
• Maintenabilité et lisibilité
• Erreurs courantes commises par les nouveaux développeurs Go
• Approches recommandées pour continuer le développement Go

28. Conclusion

• Revue des concepts clés
• Revue de l'application web terminée
• Questions et discussions
• Dépannage des scénarios courants du monde réel
• Étapes suivantes recommandées pour le développement Go
• Bibliothèques et ressources de l'écosystème Go supplémentaires
• Autres opportunités de construction de services Go de qualité de production