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 web et système
• Caractéristiques clés :
  • Typage statique
  • Simplicité et lisibilité
  • Compilation rapide
  • Concurrence intégrée
  • Gestion automatique de la mémoire (garbage collection)
  • Compilation multiplateforme
• Cas d'usage courants de Go
• Avantages et limites 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 : Examen et exécution d'un programme Go simple

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'une 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 les modules Go
• 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 de programmes avec go run
• Construction d'applications avec go build
• Installation d'applications Go
• Compilation croisée des applications
• Pratique : Création et configuration d'un projet Go dans un conteneur

3. Variables, constantes et types en Go

• Déclaration de variables
• Types explicites vs inférés
• Déclarations de variables courtes
• Constantes
• Valeurs 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
• Manipulation de l'Unicode et de l'UTF-8
• Runes et octets
• Affectation multiple de variables
• Comprendre la sécurité des types
• Exercice : Construction d'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ément et décrément
• Précédence des opérateurs
• Manipulation des calculs entiers et flottants
• Éviter les erreurs courantes de conversion de types
• Exercice : Implémentation de calculs et de logique de validation

5. Dates, heures et formatage

• Utilisation du package time
• Création et manipulation de dates
• Récupération de l'heure actuelle
• Fuseaux horaires et localisations
• Analysis (parsing) des dates et heures
• Formatage des dates et heures
• Calcul de durées
• Manipulation des timestamps Unix
• Gestion des temporisations (timeouts)
• Exercice : Ajout de timestamps et de calculs de durée à une application

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

Tableaux

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

Tranches (Slices)

• Compréhension des tranches vs tableaux
• Création de tranches
• Ajout d'éléments
• Copie de tranches
• Longueur et capacité des tranches
• Sous-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 des structures

• Initialisation des structures

• Structures imbriquées

• Structures anonymes

• Méthodes des structures

• Tags JSON des structures

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

7. Logique conditionnelle et boucles

• Instructions if
• else et else if
• Déclaration 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 cas
• Cas par défaut
• Type switches
• Exercice : Implémentation de la logique de validation et de traitement de l'application

8. Fonctions

• Définition de fonctions
• Paramètres de fonctions
• Valeurs de retour
• Multiple valeurs de retour
• Valeurs de retour nommées
• Fonctions variadiques
• Fonctions anonymes
• Valeurs de fonction
• Fermetures (closures)
• Récursivité
• Passage de fonctions comme arguments
• Fonctions retournant des erreurs
• Conception de fonctions petites et réutilisables
• Exercice : Réécriture du 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
• Récepteurs de pointeurs
• Pointeurs vers des structures
• Pointeurs nuls (nil)
• Quand utiliser des pointeurs
• Sémantique de valeur vs référence
• Compréhension de la gestion de la mémoire et de la collecte des ordures de Go
• Erreurs courantes liées aux pointeurs
• Pratique : Modification de 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 package net/http
• Création d'un serveur HTTP
• Requêtes et réponses HTTP
• Méthodes HTTP
• URL de requête et paramètres de requête
• 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 templates HTML
• Variables et structures de contrôle des templates
• Structuration d'une application web
• Pratique : Construction d'un serveur web Go de base

11. Construction d'un service web RESTful

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

12. Runtime Go, compilation et construction de projets

• Comprendre le compilateur Go
• Processus de construction de Go
• go run
• go build
• go install
• go test
• Options 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 : Compilation de 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 de fichiers
• E/S tamponnée
• Travail avec des flux (streams)
• Lecture et écriture de fichiers JSON
• Clients HTTP
• Envoi de requêtes HTTP sortantes
• Gestion des erreurs du client HTTP
• Timeouts et annulation
• Traitement des réponses d'API
• Pratique : Récupération de données d'une API externe et persistance locale

14. Gestion des erreurs et débogage

• L'approche de Go concernant les erreurs
• Retour d'erreurs depuis les fonctions
• Vérification des erreurs
• Création d'erreurs personnalisées
• Emballement (wrapping) des erreurs
• 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 : Diagnostic et correction d'erreurs d'application intentionnellement introduites

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émentations par pointeur vs par valeur
• Conception de petites interfaces
• Inversion de dépendances
• Utilisation d'interfaces pour le test
• Réduction du couplage de l'application
• Pratique : Introduction d'interfaces dans l'application web d'exemple

16. Packages et organisation du projet

• Création de packages
• Conventions de nommage des packages
• Identifiants exportés et non exportés
• Importation de packages
• Initialisation de packages
• Organisation des couches de l'application
• Packages internes
• Gestion des dépendances avec les modules Go
• Versioning sémantique
• Utilisation de packages tiers
• Éviter les dépendances circulaires
• Conception de projets Go maintenables
• Exercice : Réécriture de l'application en packages séparés

17. Concurrence avec les goroutines

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

18. Canaux (Channels)

• Comprendre les canaux
• Envoi et réception de valeurs
• Canaux tamponnés vs non tamponnés
• Comportement bloquant
• Fermeture des canaux
• Bouclage sur les canaux (range)
• Canaux directionnels
• Communication basée sur les canaux
• Instructions select
• Timeouts et annulation
• Modèles de pool de travailleurs (worker-pool)
• Modèles producteur/consommateur
• Pratique : Construction d'un système de travailleurs concurrents

19. Contexte et gestion des requêtes

• Importance des contextes dans les applications web
• context.Context
• Contexte lié aux requêtes
• Annulation
• Délais (Deadlines)
• Timeouts
• Propagation du contexte à travers les couches de l'application
• Annulation des opérations de base de données ou HTTP
• Éviter les mauvais usages du contexte
• Exercice : Ajout d'annulation de requête et de timeouts à l'application web

20. Test des applications Go

• L'importance des tests automatisés
• Rédaction de tests unitaires
• Le package testing
• Fonctions de test
• Conventions de nommage des tests
• Tests guidés par tableau (table-driven tests)
• Test des erreurs
• Test des gestionnaires HTTP
• Serveurs de test HTTP
• Fixtures de test
• Couverture de test
• Benchmarks
• Tests d'exemple
• Test des interfaces avec des mocks ou des faux (fakes)
• Pratique : Création d'une suite de tests pour l'application d'exemple

21. Optimisation des performances

• Comprendre les performances des applications Go
• Identification des goulets d'étranglement
• Performance CPU vs 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 cache
• Considérations sur la base de données et le réseau
• Profilage des applications
• Benchmarks et tests de performance
• Utilisation des outils de profilage Go
• Exercice : Profilage et optimisation d'une application délibérément inefficace

22. Sécurité et bonnes pratiques pour les 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
• Éviter les informations sensibles dans les journaux
• Gestion des dépendances et mises à jour
• Limites de ressources et timeouts de requête
• Exercice : Révision et durcissement de l'API d'exemple

23. Journalisation de l'application et observabilité

• 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 santé (health-check endpoints)
• Diagnostic des problèmes en production
• Pratique : Ajout de journalisation structurée et de 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 d'exécution minimale
• Gestion de la configuration via des variables d'environnement
• Réseautage de conteneurs
• Exposition des ports de l'application
• Exécution de l'application dans un conteneur
• Test de l'application conteneurisée
• Pratique : Packaging de l'application Go d'exemple en tant que 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 progressif (graceful shutdown)
• Gestion des signaux du système d'exploitation
• Mise à l'échelle des applications web Go
• Échelle horizontale vs verticale
• Dépannage de base des déploiements
• Pratique : Déploiement de l'application web d'exemple

26. Projet final : Application web Go complète

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

Le projet peut inclure :

• Initialisation du projet avec les modules Go
• Organisation des packages
• Routage HTTP
• Points d'accès d'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 par fichiers 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 Go fondamentale
• Conventions de codage Go
• Écriture de Go idiomatique
• Conserver le code simple
• Conception efficace des packages
• Meilleures pratiques de gestion des erreurs
• Principes de conception des 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 du monde 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