VT2016 Go

Présentation

• Sujet : Go, un langage pour les serveurs
• Auteur : Marwan Hallal
• Enseignants : Didier Donsez, Georges-Pierre Bonneau
• Date : 14/10/2016

• Mots-clés : Go, langage, système, concurrence

Historique

Le langage Go a été crée en 2007 au sein de Google par une équipe de trois ingénieurs: Robert Griesemer, Ken Thompson (Unix) et Rob Pike (UTF-8). Le projet devient open-source le 10 Novembre 2009.

Le nouveau langage était une réponse à certains grands problèmes rencontrés lors du développement de l'infrastructure interne de Google:

• lenteur du processus de build
• mauvaise gestion des dépendances
• coût des mises à jour
• illisibilité du code, mauvaise documentation

Introduction

Go est un langage compilé, statiquement typé, concurrent et avec une gestion automatique de la mémoire (garbage-collection). Aujourd'hui, beaucoup de projets utilisent le langage Go, notamment Docker, Vitess (système de clustering pour MySQL, utilisé pour l'infrastructure de YouTube), InfluxDB, ainsi que le serveur de téléchargement de Google. C'est un langage de la famille C (syntaxe de base), mais qui s'est inspiré aussi des langages Pascal et Modula (déclarations, packages). Le modèle de concurrence de Go repose sur le langage formel dit CSP de Tony Hoare. Cependant, Go emprunte la notion d'interfaces et de méthodes aux langages orienté objets.

Une librairie standard exhaustive permet aux développeurs de créer des applications qui accédent au réseau en sécurité (crypto), d'internationaliser (i18n) leur programmes (support Unicode), et de manipuler les données dans beaucoup des base de données les plus utilisées (drivers SQL).

Syntaxe de base

La syntaxe du langage Go est proche de celle du langage C; Les strucutres de contrôle (if..else, for, switch) s'écrivent presque de la même façon. Les instructions en Go ne se terminent pas par un point-virgule, celles-ci étant ajoutées automatiquement par le compilateur.

Il existe deux façons de déclarer une variable en Go:

• Déclaration sans initialisation

        var x int
        var y string

        // ou même les pointeurs
        var iptr *int = &x

• Déclaration avec initialisation

        var x = 5 // inférence de type
        // ou
        x := 5

Exemples de code (structures de contrôles):

        // if..else
        if num := 9; num < 0 {
            fmt.Println("is negative")
        } else if num < 10 {
            fmt.Println("has 1 digit")
        } else {
            fmt.Println("has multiple digits")
        }

        //for
        for j := 7; j <= 9; j++ {
            fmt.Println(j)
        }

        for {
            fmt.Println("loop")
            break
        }

        //switch
        switch time.Now().Weekday() {
            case time.Saturday, time.Sunday:
                fmt.Println("It's the weekend")
            defautl:
                fmt.Println("It's a weekday")
        }

Les types

Au delà des types primitifs du langage (int, string, float, ...), il est possible de définir des types plus complexes à l'aide des structures.

    type rect struct {
        width  int
        height int
    }

==Fonctions vs. Méthodes==
Les fonctions dans Go sont similaires à celles du langage C, mais peuvent avoir plusieurs valeurs de retour.

    func plus(a int, b int) int {
        return a + b
    }

    func plusMinus(a int, b int) int {
        return a + b, a - b
    }

    // comment récupérer plusieurs valeurs de retour ?
    x , y := plusMinus(2, 5)
    // ou si on veut ignorer une/plusieurs valeurs
    x, _ := plusMinus(2, 5)

Les méthodes permettent de définir le comportement d'un type (comme en orienté-objet). Une méthode en Go a un type récepteur (sur lequel cette méthode agit) et est définie de la façon suivante:

    func (r rect) perim() int {
        return 2 * r.width + 2 * r.height
    }

Les interfaces

Une interface introduit la notion de contrat qu'on retrouve aussi en orienté-objet. Une interface est un ensemble de méthodes, et un type implémente une interface s'il implémente toutes ses méthodes.

    type geometry interface {
        area() float64
        perim() float64
    }

    type circle struct {
        radius float64
    }

    // le type circle implémente l'interface geometry puisqu'il définit ses 2 méthodes
    func (c circle) area() float64 {
        return math.Pi * c.radius * c.radius
    }

    func (c circle) perim() float64 {
        return 2 * math.Pi * c.radius
    }