Formation Apprendre la programmation Go

1. Introduction à Go

• Qu'est-ce que Go (Golang) ?
• Historique et philosophie de conception de Go
• Go en tant que langage de programmation web et système
• Caractéristiques clés :<
  • Typage statique
  • Simplicité et lisibilité
  • Compilation rapide
  • Concurrence intégrée
  • Collecte des ordures (garbage collection)
  • Compilation multiplateforme
• Cas d'usage courants pour Go
• Avantages et limitations de Go
• Comparaison de Go avec C/C++, JavaScript, Ruby, Python et Java
• Comprendre 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
• Comprendre 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
• Comprendre la structure de projet Go
• Initialisation d'un projet avec les modules Go
• Utilisation de go mod init
• Gestion des dépendances avec go get
• Mise à jour et inspection des dépendances
• Formatage du code source avec gofmt
• Exécution de programmes avec go run
• Compilation d'applications avec go build
• Installation d'applications Go
• Compilation croisée des applications
• Pratique : Créer et configurer un projet Go dans un conteneur

3. Variables, constantes et types en Go

• Déclaration de variables
• Types explicites et inférés
• Déclarations courtes de variables
• Constantes
• Valors nulles (zero values)
• Portée et durée de vie des variables
• Types de données primitifs :<
  • Entiers
  • Nombres à virgule flottante
  • Nombres complexes
  • Booléens
  • Chaînes de caractères
• Conversions de types
• Travail avec l'Unicode et l'UTF-8
• Runes et octets
• Affectation multiple de variables
• Comprendre la sécurité des types
• Exercice : Développer 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ément
• Précédence des opérateurs
• Calculs avec des entiers et des nombres à virgule flottante
• Éviter les erreurs courantes de conversion de type
• Exercice : Implémenter une logique de calcul et de validation

5. Dates, heures et formatage

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

6. Tableaux, tranches, cartes et structures

Tableaux (Arrays)

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

Tranches (Slices)

• Comprendre les tranches par rapport aux tableaux
• Création de tranches
• Ajout d'éléments
• Copie de tranches
• Longueur et capacité des tranches
• Subtraction de tranches
• Pièges courants liés aux tranches

Cartes (Maps)

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

Structures (Structs)

• Définition de structures

• Champs de structure

• Initialisation de structures

• Structures imbriquées

• Structures anonymes

• Méthodes de structure

• Étiquettes de structure JSON

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

7. Logique conditionnelle et boucles

• Énoncés 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
• Énoncés switch
• Switch basés sur des expressions
• Cas multiples
• Cas par défaut
• Type switches
• Exercice : Implémenter une logique de validation et de traitement pour l'application

8. Fonctions

• Définition de fonctions
• Paramètres de fonction
• Valeurs de retour
• Valeurs de retour multiples
• Valeurs de retour nommées
• Fonctions variadiques
• Fonctions anonymes
• Chaînes de fonctions (Function values)
• Fermetures (Closures)
• Récursivité
• Passe de fonctions comme arguments
• Fonctions retournant des erreurs
• Conception de fonctions petites et 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 fonction
• Receveurs de pointeur (Pointer receivers)
• Pointeurs vers des structures
• Pointeurs nuls (Nil pointers)
• Quand utiliser des pointeurs
• Semantique de valeur par rapport à la référence
• Comprendre la gestion de la mémoire et 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 de requête
• En-têtes HTTP
• Codes d'état HTTP
• Fondamentaux de la routage
• Création de gestionnaires (handlers)
• Manipulation des données de formulaire
• Servir des 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 de base en Go

11. Développement d'un service web RESTful

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

12. Runtime Go, compilation et construction de projet

• Comprendre le compilateur Go
• Le processus de construction de Go
• go run
• go build
• go install
• go test
• Paramètres de construction (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 plateformes

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
• Lecture et écriture de fichiers JSON
• Clients HTTP
• Envoi 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 persister localement

14. Gestion des erreurs et débogage

• L'approche de Go pour les erreurs
• Retour d'erreurs depuis les fonctions
• Vérification des erreurs
• Création d'erreurs personnalisées
• Enveloppement d'erreurs (Wrapping errors)
• Ajout de contexte aux erreurs
• errors.Is et errors.As
• Panique 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
• Valeurs d'interface
• Interfaces vides / any
• Assertions de type
• Type switches
• Implémentation par valeur ou par pointeur
• 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 de démonstration

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 de paquets
• Organisation des couches de l'application
• Paquets internes
• Gestion des dépendances avec les modules Go
• Versionnage sémantique
• Utilisation de paquets tiers
• Éviter les 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
• Comprendre l'exécution concurrente légère
• Défis de synchronisation
• État partagé
• Conditions de course (Race conditions)
• Utilisation de sync.WaitGroup
• Mutuelles exclusions et verrous de lecture/écriture
• Opérations atomiques
• Pratique : Convertir une tâche séquentielle en traitement concurrent

18. Canaux (Channels)

• Comprendre les canaux
• Envoi et réception de valeurs
• Canaux tamponnés et non tamponnés
• Comportement bloquant
• Fermeture des canaux
• Itération sur les canaux
• Canaux directionnels
• Communication basée sur les canaux
• Énoncés Select
• Dépassements de délai et annulation
• Motifs de groupe de travailleurs (Worker-pool patterns)
• Motifs producteur/consommateur
• Pratique : Construire un système de travailleurs concurrents

19. Contexte et gestion des requêtes

• L'importance du contexte dans les applications web
• context.Context
• Contexte au niveau de la requête
• Annulation
• Délais (Deadlines)
• Dépassements de délai
• Propagation du contexte à travers les couches de l'application
• Annulation des opérations de base de données ou HTTP
• Éviter le mauvais usage du contexte
• Exercice : Ajouter l'annulation de requêtes et les dépassements de délai à l'application web

20. Tests des applications Go

• L'importance des tests automatisés
• Rédaction de tests unitaires
• Le paquet testing
• Fonctions de test
• Conventions de nommage des tests
• Tests basés sur des tables
• Tests des erreurs
• Tests des gestionnaires HTTP
• Serveurs de test HTTP
• Fichiers d'assistance pour tests (Test fixtures)
• Couverture de tests
• Tests de référence (Benchmarks)
• Tests d'exemple
• Test des interfaces avec des mocks ou des faux objets (fakes)
• Pratique : Créer une suite de tests pour l'application de démonstration

21. Optimisation des performances

• Comprendre les 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
• Éviter la concurrence excessive
• Stratégies de mise en cache
• Considérations base de données et réseau
• Profilage des applications
• Tests de référence et de performance
• Utilisation des outils de profilage de 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écurisée des requêtes HTTP
• Prévention des vulnérabilités web courantes
• Gestion sécurisée des erreurs
• Concepts d'authentification et d'autorisation
• Gestion des secrets et de la configuration
• Communication HTTP sécurisée
• Éviter les informations sensibles dans les journaux
• Gestion et mise à jour des dépendances
• Limites de ressources et dépassements de délai des requêtes
• Exercice : Réviser et durcir l'API de démonstration

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 d'accès de vérification de santé (Health-check)
• Diagnostic des problèmes en production
• Pratique : Ajouter la journalisation structurée et les vérifications de santé

24. Conteneurisation de l'application Go

• Pourquoi utiliser des conteneurs ?
• Applications Go et conteneurisation
• Écriture d'un Dockerfile
• Constructions multi-étapes (Multi-stage builds)
• Création d'une image de runtime minimale
• Gestion de la configuration via des variables d'environnement
• Réseau de 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 de démonstration 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 des conteneurs
• Architecture de déploiement
• Proxies inverses
• Considérations HTTPS/TLS
• Vérifications de santé de l'application
• Arrêt propre (Graceful shutdown)
• Gestion des signaux du système d'exploitation
• Évolutivité des applications web Go
• Évolutivité horizontale par rapport à la verticale
• Dépannage de base du déploiement
• Pratique : Déployer l'application web de démonstration

26. Projet de synthèse : 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 les modules Go
• 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 fichier ou base de données
• Tests automatisés
• Journalisation
• Considérations de performance
• Conteneurisation
• Configuration de production
• Déploiement

27. Révision et bonnes pratiques

• Révision de la syntaxe fondamentale de Go
• Conventions de codage Go
• Écriture de Go idiomatique
• Maintenir le code simple
• Conception efficace des paquets
• Meilleures pratiques de gestion des erreurs
• Principes de conception d'interfaces
• Meilleures pratiques de concurrence
• Stratégies de test
• Considérations de performance
• Maintenabilité et lisibilité
• Erreurs courantes des nouveaux développeurs Go
• Approches recommandées pour continuer le développement Go

28. Conclusion

• Révision des concepts clés
• Révision de l'application web terminée
• Questions et discussion
• Dépannage de scénarios courants en environnement réel
• Prochaines étapes recommandées pour le développement Go
• Bibliothèques Go supplémentaires et ressources de l'écosystème
• Opportunités supplémentaires pour construire des services Go de niveau production