Simple, performant, minimaliste, axé sur la productivité... Le langage de programmation Go (aussi surnommé Golang) ne manque pas d'atouts. Depuis son apparition en 2009, Go est devenu un langage incontournable tant pour l'implémentation d'outils tels que Docker et Kubernetes que pour le développement backend d'applications Web.

Cette formation Go (récemment mise à jour pour Go 1.23) s'adresse à des développeur·euse·s ayant déjà de l'expérience en développement backend Web souhaitant se lancer dans le développement en Go.

Durant cet apprentissage, vous comprendrez comment utiliser Go pour développer une application permettant la vérification de la validité et disponibilité d'un nom sur plusieurs réseaux sociaux.

Vous repartirez avec le code source du projet développé lors de ces trois jours, ainsi que la solution du formateur (sur GitHub), et l'envie —on l'espère— d'utiliser Go dans vos projets actuels et futurs !

A l'aise avec Go mais pas avec les goroutines, channels, mutexes, etc. ?

Le dernier tiers de cette formation, dédié à la programmation concurrente en Go, est également disponible à part sous la forme de la formation Programmation concurrente en Go, également animée par Julien Cretel.

Envie de passer au niveau supérieur ?

Jetez un œil à la formation Go Avancé animée par Julien Cretel.
Vous y verrez comment bien tester vos applications en Go, améliorer les performances de vos applications et bien les sécuriser.

Toutes nos formations étant limitées à 6 participant·e·s par session, vous aurez un contact privilégié avec votre formateur, Julien Cretel, Gopher passionné et pédagogue, enthousiaste de partager ses expériences professionnelles lors des moments informels de cette formation.

Les objectifs

• Acquérir les bases de développement en Go
• Reconnaître les cas où Go est, ou non, adapté à vos besoins
• Apprendre à développer une app Web permettant de vérifier la validité et la disponibilité d'un nom d'utilisateur·rice sur plusieurs réseaux sociaux (GitHub, Reddit etc.)

Pré-requis

• Une expérience soutenue d'au moins un an avec un autre langage de programmation
• Des bases en anglais technique
• Installation de Go (1.23+)
• Installation de Visual Studio Code et de son extension Go
• Installation de Git
• Ordinateur portable à apporter

Le programme de la formation Go

Jour 1 : Introduction

Préambule

• A propos du support
• Présentations
• Installation
• namecheck : notre projet fil-rouge
• Genèse et histoire du langage Go
• Logo et mascotte
• Go : un langage multi-paradigmatique
• Un outillage riche

Premiers pas en Go

• Le playground Go : votre bac à sable pour expérimenter avec le langage
• L'incontournable premier programme : Hello, World!
• Modules et gestion de dépendances
• Encodage et formatage du code source
• Compilation et exécution
• Transcompilation
• Mots-clés et noms pré-déclarés
• Commentaires

Mises en pratique :
- Initialisation du projet fil-rouge au sein de VS Code
- Compilation et transcompilation d'un programme Hello World

Paquets (packages)

• Nom et chemin d'import d'un paquet
• Paquet : l'unité de compilation
• Documentation des paquets
• Encapsulation
• Importation de paquets

Types

• Types basiques
• Types composites
• Valeur vierge d'un type : chaque type à une valeur par défaut
• Comparabilité des types
• Définition de type
• Conversion d'une valeur vers un autre type

Variables

• Gestion automatique de la mémoire
• Déclaration de variable : mot-clé var et déclaration courte
• Attention au masquage accidentel de variables
• Nommage des variables

Instructions conditionnelles

• Instruction if-else
• Instruction switch
• Instruction switch sans expression (tagless switch)

Mise en pratique :
-Validation d'un nom d'utilisateur·rice GitHub

Pointeurs

• Pointeur : l'adresse d'une valeur
• Adressabilité et opérateur esperluette
• Valeur vierge des types pointeurs
• Comparabilité des pointeurs
• Déréférencement d'un pointeur
• La pseudo-fonction new
• Les types références : des pointeurs "déguisés"

Fonctions

• Appel d'une fonction
• Stratégie d'évaluation des arguments d'une fonction : appel par valeur
• Déclaration d'une fonction
• Résultats multiples
• Résultats nommés
• Paramètres variadiques
• Factorisation du type de paramètres/résultats consécutifs de type identique
• Les fonctions sont des valeurs à part entière.
• Fonctions anonymes et fermetures
• Récursivité
• Un aperçu des méthodes

Mise en pratique :
-Extraction de la logique de validation dans une fonction

Gestion des erreurs

• Les erreurs sont des valeurs : pas de système d'exceptions en Go
• Le type error
• L'importance de ne pas ignorer les erreurs
• Elimination progressive des échecs
• Gestion d'une erreur non-nil
• Création de valeurs de type error
• De bonnes pratiques au sujet des messages d'erreurs
• Panique : le signe d'un échec irréparable

Mise en pratique :
-Gestion judicieuse des erreurs au sein de la fonction responsable de la validation d'un nom d'utilisateur·rice GitHub

Création de paquets

• Paquets d'exécutables et paquets de bibliothèques
• Les fichiers sources d'un paquet
• Conventions de nommage
• Sous-paquets
• Contrainte d'acyclicité dans le graphe des importations
• Organisation d'un projet en paquets
• Un bon paquet ne panique pas après initialisation

Mise en pratique :
-Création d'un paquet dédié à GitHub

Tests unitaires

• Tour d'horizon de l'outillage Go pour les tests
• Fichiers de test
• Approches "boîte blanche" et "boîte noire"
• Fonctions de tests
• Exécution de tests
• Mesure de la couverture de code

Mise en pratique :
-Écriture et exécution de tests unitaires

Réclamations de resources

• Le mot-clé defer : une sorte de mot-clé finally survitaminé
• Gare aux instructions defer au sein d'une boucle
• L'intérêt des instructions defer

Mise en pratique :
-Vérification de la disponibilité d'un nom d'utilisateur·rice sur GitHub

Boucles

• Boucle à trois clauses (dérivées du C)
• Boucle conditionnelle
• Mots-clés break et continue
• Boucle inconditionnelle
• Boucle for-range pour itérer sur une valeur de type composite
• Boucle for-range appliquée à un entier (nouveau en Go 1.22)

Jour 2 : types composites et orientation objet

Tableaux

• Une séquence de taille fixe de valeurs d'un même type
• Littéral de tableau
• Les tableaux sont des valeurs
• Valeur vierge d'un type tableau
• Comparabilité des tableaux
• Indexation d'un tableau
• Itération sur un tableau
• Valeur zéro d'un tableau
• Un type inflexible et rarement utilisé directement

Slices

• Un type incontournable en Go
• Une fenêtre redimensionnable sur un tableau
• Initialisation d'une slice via un littéral ou grâce à la pseudo-fonction make
• Valeur vierge d'un type slice
• Incomparabilité des slices
• Indexation d'une slice
• Sous le capot d'une slice
• Longueur et capacité d'une slice
• Pourquoi préférer les slices aux tableaux
• Slicing operator
• Itération sur une slice
• La pseudo-fonction append
• Aliasing et découplage accidentel
• Autres opérations courantes sur les slices

Mises en pratique :
- Récupération du nom d'utilisateur·rice à tester via un argument de ligne de commande
- Réusinage des tests en table de tests afin d'éliminer la duplication de code

Maps

• Collection non-ordonnée de couples clé-valeur
• Initialisation d'une map via un littéral ou grâce à la pseudo-fonction make
• Valeur vierge d'un type map
• Incomparabilité des maps
• Indexation d'une map
• Ajout d'un couple clé-valeur dans une map
• Elimination d'un couple clé-valeur d'une map
• Implémentation d'un ensemble mathématique
• Itération sur une map
• Autres opérations courantes sur les slices

Structures

• Une collection hétéroclite de champs
• Déclaration d'un type structure
• Valeur vierge d'un type structure
• Littéraux de structures
• Le type structure vide
• Accès aux champs d'une structure
• Encapsulation et visibilité externe des champs d'une structure
• Etiquettes de champs
• Comparabilité des structures
• Champs intégrés
• Un aperçu des types et fonctions génériques
• Un aperçu des itérateurs (nouveau en Go 1.23)

Mises en pratique :
- Conception d'un type structure représentant un arbre binaire
- Déclaration de types structures dédiés à chaque plateforme supportée

Méthodes

• Des fonctions rattachées à un type en particulier
• Déclaration d'une méthode
• Récepteur d'une méthode
• Conventions de nommage des méthodes
• Conventions de nommage des récepteurs
• Appel d'une méthode
• Récepteur valeur et récepteur pointeur
• L'importance de rendre la valeur vierge d'un type prête à l'emploi
• Ensemble des méthodes d'un type
• Injection de dépendances à travers le récepteur d'une méthode

Mise en pratique :
-Transformation de fonctions en méthodes sur les types structures déclarés précédemment

Interfaces

• La puissance des interfaces en Go
• Interfaces basiques
• Comparabilité des interfaces
• Conventions de nommage
• Satisfaction implicite des interfaces
• Ensemble des méthodes d'une interface
• L'interface vide
• L'importante de garder ses interfaces petites et focalisées
• Composition d'interfaces
• Ne pas déclarer d'interfaces plus tôt que nécessaire
• L'interface fmt.Stringer
• Les interfaces io.Reader et io.Writer
• Préférer des paramètres de types interfaces si le comportement prime sur la donnée
• Ne pas demander à vos paramètres des comportements non requis
• L'interface error
• Sous le capot d'une interface
• Un écueil courant : quand nil n'est pas nil
• Assertions de type
• Type switch
• Préférer déclarer ses interfaces où elles sont utiles
• Usage des interfaces pour les doublures de tests (mock, stub, etc.)

Mises en pratique :
- Déclaration judicieuse de types interfaces
- Simplification du code existant grâce aux interfaces
- Création d'un stub pour le client HTTP

Jour 3 : programmation concurrente

Introduction à la concurrence

• La concurrence : l'art de composer un programme de manière à délinéer les tâches indépendantes
• Concurrence et parallélisme : deux notions étroitement liées mais distinctes
• La concurrence permet le parallélisme et ouvre la porte à une plus grande vitesse d'exécution.
• Loi d'Amdahl et loi de Gunther : le parallélisme n'est pas magique !
• Le tiercé gagnant de la concurrence en Go : goroutines, canaux, et instruction select

Mise en pratique :
-Identification, dans le programme namecheck, de traitements séquentiels qui bénéficieraient d'une ré-écriture traitements concurrents

Goroutines

• Les goroutines : une sorte de thread "poids plume"
• L'ordonnanceur (scheduler) : la partie du runtime qui jongle avec les goroutines
• Démarrage de goroutines grâce au mot-clé go
• La règle d'or : ne pas démarrer une goroutine que si on peut expliquer quand elle se terminera.
• La fonction main n'attend pas la fin des autres goroutines.
• Groupes d'attente (wait groups)
• Bogue de synchronisation et situations de compétition
• Concurrency safety : la garantie qu'une opération peut être effectuée de manière concurrente sans souci
• Situations de compétitions portant sur l'accès à de la mémoire partagée
• Détecteur de situations de compétition portant sur l'accès à de la mémoire partagée (option -race)
• Bogue de synchronisation dû à la portée inappropriée des variables de boucle avant Go 1.22

Mise en pratique :
-Vérification concurrente de la validité et disponibilité d'un nom sur de multiples réseaux sociaux

Canaux (channels) et programmation concurrente par envoi de messages

• Partage d'état ou envoi de messages : deux approches possibles pour la programmation concurrente
• Un adage incontournable en Go : Plutôt que communiquer en partageant de la mémoire, mieux vaut partager de la mémoire en communiquant.
• Les canaux : la méthode reine pour communiquer entre goroutines et/ou les synchroniser
• Convention de nommage des canaux
• Les canaux sont des valeurs à part entière.
• Valeur vierge des canaux
• Initialisation de channels avec la fonction make
• Capacité et espace tampon d'un canal
• Les canaux fonctionnent sur le principe du "premier entré, premier sorti" (FIFO).
• L'importance de bien choisir la capacité des canaux
• Emission d'une valeur dans un canal : syntaxe et sémantique
• Réception d'une valeur d'un canal : syntaxe et sémantique
• Résoudre l'ambiguïté à la réception d'une valeur d'un canal
• Interblocage ou étreinte mortelle : quand les goroutines se bloquent entre elles
• Fuite de goroutines
• Fermeture d'un canal : syntaxe et sémantique
• Bonnes et mauvaises raisons de fermer un canal
• Réception à répétition d'un canal grâce à une boucle for-range
• Canaux unidirectionnels (émission seule ou réception seule)

Mises en pratique :
- Analyse et résolution d'un d'interblocage
- Analyse et résolution d'une fuite de goroutines
- Communication de résultats entre goroutines à l'aide d'un canal dans le but d'agréger ces résultats

Serveur HTTP

• Présentation sommaire du paquet net/http
• Présentation d'un simple serveur "Hello, World!"
• Quid des frameworks Web pour Go ?
• Méfiance : un handler fait l'objet d'invocations concurrentes par le serveur
• Encodage et décodage JSON

Mise en pratique :
-Transformation de l'outil de ligne de commande de départ en une API HTTP

Gestion de dépendances tierces

• Installation de dépendances tierces
• Les fichiers go.mod et go.sum

Mise en pratique :
-Configuration CORS de l'API HTTP à l'aide d'une bibliothèque tierce

L'instruction select

• Sélecteur de communications sur canaux
• Instruction select : syntaxe et sémantique
• Boucle d'évènements : instruction select au sein d'une boucle
• Le besoin de signaler à des goroutines qu'elles doivent se terminer/s'annuler
• Quels genres de fonction rendre annulables ?
• Emission et détection d'un signal de terminaison : la technique de base
• Emission et détection d'un signal de terminaison en pratique avec le paquet context
• Comment rendre annulable l'émission d'une valeur dans un canal
• Débogage d'une simple simulation de ping-pong

Mises en pratique :
- Utilisation d'une instruction select et de deux canaux distincts, l'un dédié aux résultats et l'autre aux erreurs
- Analyse et résolution d'une fuite de goroutines

Programmation concurrente par partage d'état

• Communiquer en partageant de la mémoire
• Exclusions mutuelles (mutexes) et sections critiques
• Utilisation du type sync.Mutex

Mise en pratique :
-Utilisation d'une exclusion mutuelle pour la mise à jour d'une variable globale d'état

Ressources d'apprentissage

Le(s) formateur(s)

A propos de Human Coders

Human Coders c'est un centre de formation pour développeurs avec :

• une certification Qualiopi, indispensable pour que vous puissiez obtenir des aides au financement via votre OPCO
• de nombreux clients qui nous font confiance depuis des années
• un manifeste pour garantir des formations à taille humaine, des formateurs passionnés, de véritables workshops...
• 122 formations au catalogue, 1604 sessions depuis nos débuts en 2012 avec une moyenne de satisfaction de 4,6/5
• la possibilité de vous proposer un accompagnement personnalisé ou du conseil après la formation