DEV Community: Gwenaël NARDIN

Nouvelle version de Go : 1.18

Gwenaël NARDIN — Fri, 25 Mar 2022 21:17:30 +0000

Generics

On peut définir la programmation générique comme un style de programmation qui permet de représenter des fonctions et des structures de données sous une forme générique, avec des types adaptés. Ca, c’est pour la théorie. Voyons un exemple.

Pour illustrer le principe, imaginons que nous avons besoins de calculer la somme des éléments d’un map de int64 :

// SumInts adds together the values of m.
func SumInts(m map[string]int64) int64 {
    var s int64
    for _, v := range m {
        s += v
    }
    return s
}

Rien d’exceptionnel.

Maintenant, si nous avons besoin de faire de même pour un map de float64, notre fonction pourrait être quelque chose de ce genre :

// SumFloats adds together the values of m.
func SumFloats(m map[string]float64) float64 {
    var s float64
    for _, v := range m {
        s += v
    }
    return s
}

On constate la très grande similarité entre nos deux fonctions ; rien ne change à part le type.

Déclarer une fonction générique

Pour pouvoir utiliser des valeurs de plusieurs types, il faut écrire une fonction qui déclare des type parameters en plus des paramètres de fonction habituels.

Chaque type parameter a une contrainte qui permet de spécifier le type d'argument qui peut être accepté par la fonction.

Notre fonction générique peut se définir ainsi :

// SumIntsOrFloats sums the values of map m. It supports both int64 and float64
// as types for map values.
func SumIntsOrFloats[K comparable, V int64 | float64](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

On peut déclarer les contraintes comme une interface et modifier la fonction en conséquence :

type Number interface {
    int64 | float64
}

// SumNumbers sums the values of map m. It supports both integers
// and floats as map values.
func SumNumbers[K comparable, V Number](m map[K]V) V {
    var s V
    for _, v := range m {
        s += v
    }
    return s
}

Cas d’usage

La généricité peut être utile pour les fonctions qui font :

Trouver le plus petit/grand élément d’un slice
Trouver la déviation moyenne/standard d’un slice
Calculer l’union/intersection de maps
Trouver le chemin le plus court d’un nœud d’un graphe
Appliquer une fonction de transformation à un slice/map, qui retourne un slice de résultat

Dans les cas plus spécifique à l’utilisation de la concurrence en Go, on pourrait avoir les cas d’usages suivant :

Lire un canal avec un timeout
Combiner deux canaux en un seul
Appeler une liste de fonctions en parallèle, renvoyer un slice de résultat
Appeler une liste de fonctions, en utilisant un Context, retourner le résultat de la première fonction qui termine, annuler et nettoyer les autres goroutines

Aller plus loin

Les exemples et les explications sont tirés de ce tutoriel (et également plus complet).

Une introduction publiée sur le blog officiel de Go.

Les détails sont dans la release note.

Des explications sur le pourquoi, les cas d’usages classiques : Why Generics ?.

Fuzzing

Le fuzzing est l’injection de données aléatoires dans un test afin de tenter de trouver une vulnérabilités ou de détecter des potentielles entrées qui pourraient faire crasher un programme. Voyons un exemple de mise en œuvre.

Exemple

On prend une fonction qui inverse le sens d’une chaîne de caractères :

func Reverse(s string) string {
    b := []byte(s)
    for i, j := 0, len(b)-1; i < len(b)/2; i, j = i+1, j-1 {
        b[i], b[j] = b[j], b[i]
    }
    return string(b)
}

Cette fonction prend une string en entrée, itère octet (byte) par octet et renvoi la string inversée.

Nota: ce code est basé sur la fonction stringutil.Reverse de golang.org/x/example.

Ajoutons un test unitaire :

package main

import (
    "testing"
)

func TestReverse(t *testing.T) {
    testcases := []struct {
        in, want string
    }{
        {"Hello, world", "dlrow ,olleH"},
        {" ", " "},
        {"!12345", "54321!"},
    }
    for _, tc := range testcases {
        rev := Reverse(tc.in)
        if rev != tc.want {
                t.Errorf("Reverse: %q, want %q", rev, tc.want)
        }
    }
}

Il s’agit d’un simple test qui s’assure que la string d'entrée est bien inversée.

Remplaçons maintenant ce test classique par un test en fuzzing :

func FuzzReverse(f *testing.F) {
    testcases := []string{"Hello, world", " ", "!12345"}
    for _, tc := range testcases {
        f.Add(tc)  // Use f.Add to provide a seed corpus
    }
    f.Fuzz(func(t *testing.T, orig string) {
        rev := Reverse(orig)
        doubleRev := Reverse(rev)
        if orig != doubleRev {
            t.Errorf("Before: %q, after: %q", orig, doubleRev)
        }
        if utf8.ValidString(orig) && !utf8.ValidString(rev) {
            t.Errorf("Reverse produced invalid UTF-8 string %q", rev)
        }
    })
}

Il y a des différences de syntaxes par rapport aux tests classiques :

La nom de la fonction débute par FuzzXxx (à la place de TestXxx)
La fonction prend *testing.F en type d'entrée (à la place de *testing.T)
On utilise f.Fuzz (à la place de t.Run) qui prend comme paramètre une fonction à fuzzer qui a comme paramètres *testing.T et le type à fuzzer

On peut ici identifier une limitation à ce type de test : il n’est pas possible de prédire la sortie puisque nous contrôlons pas l’entrée. Il faut donc s’appuyer sur d’autres propriétés pour réaliser nos tests, comme :

Inverser deux fois l’entrée doit préserver l’entrée originale
La chaîne inversée doit être une chaîne UTF-8 valide

Aller plus loin

Le tutoriel de go.dev (dont sont tiré les exemples ci-dessus), ainsi que la documentation officielle vous permettrons de creuser le sujet.

Workspaces

Cette nouvelle fonctionnalité permet de simplifier le travail sur de multiples paquets interdépendant en même temps.

Un workspace est défini par un fichier go.work de cette forme :

go 1.18

use (
  ../foo/bar
  ./baz
)

replace example.com/foo v1.2.3 => example.com/bar v1.4.5

On peut alors initialiser un espace de travail dans le répertoire courant :

go work init

Aller plus loin

Autres ajouts

Amélioration des performances de 20% sur Apple M1, ARM64, PowerPC64.
Le type any comme alias de interface{} : l’ issue sur Github, un article de blog.
Un nouveau paquet net/netip avec un type d’adresse IP : documentation officielle.
Un paquet debug/buildinfo pour accéder aux informations d’un binaire compilé : documentation officielle.

Pour conclure

Voilà pour ce qui me paraît l’essentiel à savoir sur cette nouvelle version de Go. Vous trouverez l’intégralité des ajouts, des suppressions et des corrections dans la Release Note.

Codez bien !

Programmation concurrente avec des goroutines

Gwenaël NARDIN — Wed, 23 Mar 2022 11:50:16 +0000

Nouvelle année, nouveau challenge ! Ca fait pas mal de temps de je lorgne sur le Go (ou Golang) et ça y est, il est venu le temps de s'y mettre !
Avant cela, j'ai (un peu) mis à jour mon site et rajouter un lien pour ma page LinkedIn : n'hésitez pas à me suivre ou m'ajouter afin de recevoir les prochaines mises à jour 😊.

Le Go (ou Golang) est un langage développé depuis quelques années désormais (plus de 10 ans) par une équipe de Google, et pas des débutants ! Notamment Brian Kernighan, éminent informaticien en C et autre. Ils ont alors développé ce langage pour simplifier l'utilisation du multithreading, principe au coeur du Go.

Je vais vous présenter içi les goroutines, principe de base pour la mise en oeuvre du multithreading en Go.

Définitions

Programmation concurente : composition de plusieurs activités autonomes.

Go supporte deux types de programmation concurrente :

CSP (communicating sequential processes - processus séquentiels de communication). Les variables sont passées entre des activités indépendamment mais les variables sont la plus part du temps confinées à une seule de ces activités.
shared memory multithreading (multithreading à mémoire partagée)

goroutine : activité exécutée en concurrence

Exemples

Maintenant que nous avons vu le principe de base, place aux exemples !

Basique

On va faire un simple hello world ! mais en utilisant une goroutine. On va écrire une fonction say qui prend une string en argument et que l'on appelera en tant que goroutine (avec le mot-clé go) et qui nous affichera "hello". Voyons ce que ça donne :

package main
import "fmt"


func say(s string) {
    fmt.Println(s)
}

func main() {
    go say("hello")
    fmt.Println("world !")
}

La sortie :

world !

Quoi ?!? Mais il manque un bout !!! 😱😱😱

Explication : la boucle principale main n'attend pas la fin de l'exécution de la goroutine. Pour le moment, on va résoudre ça avec un simple sleep. On modifie le code ainsi :

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    fmt.Println(s)
}

func main() {
    go say("hello")
    fmt.Println("world !")
    time.Sleep(500 * time.Millisecond)
}

On obtient en sortie :

world !
hello

Ah !!!!! Voilà ! On obtient bien ce que l'on souhaite en sortie mais c'est loin d'être optimal...

On peut faire beaucoup mieux !! Place à la suite 😉

Attendre plusieurs goroutines

Lorsque l'on a besoin d'attendre que une ou plusieurs goroutine finissent, on utilise le packet sync et la fonction sync.WaitGroup. Elle est utilisé pour bloquer le main (ou toute autre fonction appelante) jusqu'à ce que toutes les goroutine aient terminé leur travail. Un exemple parlant (adapté de l'article How to wait for all goroutines to finish in Golang) :

package main

import (
    "fmt"
    "sync"
    "time"
)

func worker(wg *sync.WaitGroup, id int) {
    defer wg.Done() //décrémentation (lorsque la goroutine a terminé)

    fmt.Printf("Worker %v: Début\n", id)
    time.Sleep(time.Second)
    fmt.Printf("Worker %v: Terminé\n", id)
}

func main() {
    var wg sync.WaitGroup // déclaration

    for i := 0; i < 5; i++ {
        fmt.Println("Main: Lancement du Worker", i)
        wg.Add(1) // incrémentation d'une unité
        go worker(&wg, i) // passage par adresse
    }

    fmt.Println("Main: En attente des Workers")
    wg.Wait()
    fmt.Println("Main: Terminé")
}

Ce qui donne :

Main: Lancement du Worker 0
Main: Lancement du Worker 1
Main: Lancement du Worker 2
Main: Lancement du Worker 3
Main: Lancement du Worker 4
Worker 0: Début
Worker 4: Début
Worker 2: Début
Main: En attente des Workers
Worker 1: Début
Worker 3: Début
Worker 1: Terminé
Worker 0: Terminé
Worker 4: Terminé
Worker 2: Terminé
Worker 3: Terminé
Main: Terminé

N'est-ce pas formidable ?

L'utilisation de WaitGroup est assez simple :

déclation dans le main
incrémentation avec .Add(1) avant l'appel de la goroutine
appel de la goroutine avec passage par adresse du WaitGroup
décrémentation du WaitGroup au sein de la goroutine avec .Done()
en fin de bloc, on attend la fin des goroutine avec .Wait()

Notez l'utilisation de defer pour la décrémentation dès le début de la goroutine. Ce mot-clé permet de s'assurer que la fonction qui le suit sera bien appelée à la fin du bloc. On le retrouve pour la lecture des fichiers : on s'assure ainsi que ce dernier sera bien fermé à la fin du traitement.

goroutine anonyme

Lorsque la goroutine ne fait quelques lignes (pas trop, sinon le code devient vite illisible...), il est possible d'utiliser une fonction anonyme. Voyons avec l'exemple précédent ce que cela change :

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup // déclaration

    for i := 0; i < 5; i++ {
        fmt.Println("Main: Lancement du Worker", i)
        wg.Add(1) // incrémentation d'une unité

        go func(id int) { // fonction anonyme
            defer wg.Done() //décrémentation (lorsque la goroutine a terminé)

            fmt.Printf("Worker %v: Début\n", id)
            time.Sleep(time.Second)
            fmt.Printf("Worker %v: Terminé\n", id)
        }(i)
    }

    fmt.Println("Main: En attente des Workers")
    wg.Wait()
    fmt.Println("Main: Terminé")
}

C'est un peu plus concis 😊

Conclusion

Voilà, c'est terminé pour cette petite présentation ! J'ai utilisé également les livres suivant dans mon apprentissage :

A bientôt !