Logo Go

Formation Go

Go est un langage de programmation apparu en 2009, qui a percé dans la décennie suivante, et qui a plus que jamais le vent en poupe. Non content d'être adapté au développement d'outils système (Docker, Kubernetes, Terraform n'en sont que quelques exemples), Go est aussi un langage de choix pour le backend Web, notre formation Go insiste notamment sur son support accru à la programmation concurrente. Le langage se démarque également des autres par son typage fort, ses interfaces satisfaites implicitement, son niveau de performance élevé, son outillage bien fourni, son esprit minimaliste, et sa communauté bienveillante. Dans cette formation Go nous verrons les principales syntaxes et concepts de Go, les bonnes pratiques, ainsi que les outils et bibliothèques permettant d'accélérer le développement.

Objectifs pédagogiques / Compétences visées

  • Savoir écrire, compiler, et tester des bibliothèques et commandes Go
  • Connaître les meilleures pratiques
  • Se familiariser avec l'outillage (commande go, Visual Studio Code)
  • Maîtriser les bases de la programmation concurrente (goroutines et channels)

Pré-requis

  • Connaissance d'un langage de programmation
  • La connaissance d'un langage orienté objet ou fonctionnel est un plus
  • La connaissance d'un langage proche syntaxiquement de C est un plus

Public

  • Développeurs
  • Chefs de projets

Programme

Jour 1

Introduction

  • Les origines et l'esprit du langage Go
  • Outillage et écosystème
  • Compilation et exécution
  • Gestion de dépendances
  • Syntaxe de base

Types

  • Types prédéfinis
  • Valeur zéro
  • Comparabilité
  • Déclaration de types

Variables et constantes

  • Déclaration de variables
  • Adressabilité
  • Pointeurs
  • Constantes

Structures de contrôle

  • Conditionnels
  • Boucles

Fonctions

  • Appel par valeur
  • Déclaration de fonctions
  • Quelques curiosités propres à Go

Traitement d'erreurs

  • Pas d'exceptions en Go !
  • Le type `error`
  • Traitement idiomatique des erreurs
  • Création de valeurs de type `error`
  • Paniques
  • Réclamation facile de ressources grâce au mot-clé `defer`

Paquets

  • Bibliothèques et commandes
  • Organisation des fichiers sources
  • Conventions de nommage
  • Accessibilité des symboles
  • Les cycles d'import sont interdits !
  • Bonnes pratiques

Tests

  • Le package `testing`
  • Fichiers de tests
  • Deux approches possibles
  • Fonctions de tests
  • La sous-commande `go test`
  • Couverture de code

Tableaux

  • Déclaration
  • Indexation
  • Boucle `for`-`range` appliqué aux tableaux
  • Tableaux ou slices : pour quel type opter ?

Slices

  • Un type plus utile que les tableaux
  • Déclaration grâce à la fonction `make`
  • Fonctionnement interne
  • Indexation
  • Opération de tranchage
  • Boucle `for`-`range` appliquée aux slices
  • La fonction `append`
  • Précautions à prendre

Jour 2

Maps

  • Collection de couples clé-valeur
  • Déclaration grâce à la fonction `make`
  • Indexation
  • Ajout d'un couple clé-valeur
  • Elimination d'un couple clé-valeur
  • La fonction `clear`
  • Boucle `for`-`range` appliquée au maps

Structures

  • Déclaration de types structures
  • Instanciation
  • Accès aux champs
  • La structure vide

Génériques

  • Types génériques
  • Fonctions génériques
  • Limitations liées aux méthodes

Méthodes

  • Déclaration
  • Récepteur d'une méthode
  • Conventions de nommage
  • Appel de méthodes
  • Valeur zéro prête à l'emploi

Interfaces

  • Un type défini par une liste de méthodes
  • Satisfaction implicite
  • Composition d'interfaces élémentaires
  • Les types interfaces les plus courants
  • Interfaces et `nil`
  • L'effet libérateur des interfaces
  • Mocking

Jour 3

Concurrence

  • L'art de composer un programme en termes de traitements indépendants
  • L'intérêt de la programmation concurrente
  • Le modèle de concurrence de Go : goroutines et channels

Goroutines

  • Des threads très légers
  • Le Go scheduler
  • Démarrage de goroutines
  • Durée de vie des goroutines
  • Wait groups
  • Fuite de goroutines et comment s'en prémunir
  • Bogues de synchronisation et situations de compétition (_race condition_)

Channels

  • Le mécanisme roi pour la synchronisation et la communication entre goroutines
  • Déclaration grâce à la fonction `make`
  • Capacité d'une channel
  • Communications sur une channel
  • Fermeture d'une channel
  • Résoudre l'ambiguïté à la réception
  • Boucle `for`-`range` appliquée aux channels
  • Channels unidirectionnelles
  • Le mot-clé `select`
  • Annulation de goroutines
  • Le package `context`

Les bases du Web en Go

  • Client HTTP
  • Serveur HTTP
  • Handlers HTTP
  • Encodage/décodage JSON

Partager de la mémoire

  • Exclusions mutuelles
  • Le type `sync.Mutex`

Moyens pédagogiques et techniques

  • Formateur validé par nos équipes techniques et pédagogiques
  • Salle de formation informatisée
  • Support de cours numérique

Suivi et appréciation des résultats

  • Questions orales ou écrites (QCM)
  • Exercices pratiques
  • Formulaires d'évaluation
Dernière modification le 31/01/2024