X
Programmer avec le langage Go de Google
Thierry Thaureaux / vendredi 13 octobre 2017 / Thèmes: Développement, Dossier

Programmer avec le langage Go de Google

Le langage Go a été créé par Google afin d’exploiter au mieux la puissance des processeurs multicoeurs actuels. Si le Go était initialement destiné à remplacer le C pour la programmation bas niveau, il se substitue le plus souvent au Python.

À l’origine

Pour concevoir le langage Go, Google a fait appel à plusieurs vétérans de la programmation : Ken Thompson, co-auteur d’Unix et créateur du langage B auquel a succédé le C, Rob Pike, le créateur du système Plan 9 pour Bell, et Robert Griesemer qui a contribué au compilateur JavaScript V8 de Chrome et au projet GCC, le compilateur C GNU. Créé en 2007, le Go est utilisé en production chez Google depuis mai 2010. Outre le fait qu’il peut remplacer le C++ très efficacement dans certains cas de figure – pas tous, loin s’en faut –, il tend aussi à être utilisé à la place de Python et Ruby car sa vitesse de compilation convient au scripting, tout en produisant des binaires. Il peut être employé à la place de presque tous les langages de conception de programmes en ligne de commande. Le Go innove surtout au niveau de ses fonctionnalités, particulièrement les Slice, Map, channels et Goroutines.

Rob Pike, un des auteurs, a déclaré : « Le point central est que nos programmeurs sont des Gogglers, ce ne sont pas des chercheurs. Typiquement, ils sont plutôt jeunes, fraîchement sortis de l’école, ont probablement appris le Java, peut-être le C ou C++, et peutêtre le Python. Ils ne sont pas capables de comprendre un langage brillant, mais nous voulons les amener à réaliser de bons programmes. Ainsi, le langage que nous leur donnons doit être facile à comprendre et facile à adopter. » Le Go serait donc fait pour programmer vite sans trop se creuser la tête, en résumé, mais sans disposer de toute la puissance de langages tels que les C et C++, qui sont eux plus complexes.

Le site officiel du langage Go, Golang.org, réalisé avec Go : https://golang.org/.

Cadres d’utilisation de Go

Le Go est principalement conçu pour des équipes fluctuantes, où les développeurs changent souvent. Il permet d’être rapidement productif même pour des débutants. Sa syntaxe et la façon dont il traite les objets le destinent surtout à la programmation de logiciels serveurs, la construction de CMS ou la génération de pages HTML en remplacement de Perl, Python, PHP ou même Java. Il permet à la fois un développement rapide et des scripts plus efficaces que ce qu’offrent la plupart des langages de script. Il propose des fonctionnalités de concurrence et un garbage collector.

L’hybride

Jugé par certains plus simple que le C++, plus adaptable que Java, plus rapide et plus sûr que Python, le Go dispose d’une bibliothèque (côté serveur) complète et bien conçue et fournit les services requis aux applications web, WebSocket et autres closures. Les programmes sont compilés instantanément, ce qui peut en faciliter la mise au point. Voici les principales caractéristiques du langage Go :

• le Go est typé, mais il n’est pas indispensable de déclarer les variables ;

• les points-virgules en fin de ligne ne sont pas indispensables. Ils ne sont réellement nécessaires que pour séparer des instructions sur une même ligne d’édition ;

• les variables sont déclarées dans l’esprit du Pascal, comme par exemple : var x int;

• break et continue existent, mais peuvent spécifier directement un label (étiquette) comme le goto du C/C++. ;

• la commande go appelle une fonction en démarrant un nouveau thread ;

• chan – pour channel – est un canal permettant de communiquer entre des goroutines, celles-ci étant les fonctions lancées par des processus concurrents ;

• les types de base sont bool, string, int, int8 à int64 et idem pour uint (unsigned int), byte, float32, float64, complex64 et complex128 ;

• les chaînes de caractères sont au format UTF-8 ;

• un map est une collection dynamique de type table de hachage ;

• un slice est un tableau indexé. La technologie CSP (Communicating Sequential Processes) utilisée par le Go gère la communication entre programmes ainsi que celle des processeurs multi-coeurs.

Vous trouverez quelques exemples de programmes Go sur Golang.org (https://golang.org/).

Syntaxe du langage Go

La syntaxe du Go se veut simplifiée par rapport à celle du C++. Le fonctionnement multithread est beaucoup plus simple, avec une seule commande spéciale pour créer un nouveau thread. Dans le Go, il n’y a ni classe ni héritage. À la place, si l’on peut dire, il y a des structs et des interfaces. Ces « objets » peuvent être étendus, mais par composition, pas par héritage. Bien que ce ne soit pas un langage orienté- objet, il est possible d’attacher une fonction à un type :

func (t *Twitter) FriendsTimeline()

(string, os.Error) { … }

La mémoire est nettoyée automatiquement par un garbage collector (ramasse-miettes). Ses pauses sont d’une durée inférieure à 100 microsecondes, ce qui les rend quasi-transparentes pour l’utilisateur. Le Go propose également des pointeurs. Le symbole de pointeur -> est remplacé par le point, comme en Java. Les tableaux sont passés par valeur et non par adresse comme en C/C++. Les imports se font par package, comme en Java. Les conversions de types (cast) nécessitent systématiquement l’emploi d’une fonction. Les incréments/décréments -- et ++ ne peuvent être employés dans des expressions. Les constantes peuvent être déclarées sans type, tout comme les variables. Il y a bien un new en Go, mais c’est une fonction et non un opérateur, contrairement à la plupart des langages objets. La généricité n’est pas supportée par le Go, jugée trop complexe par les auteurs du langage.

Voyons un peu de code. Tout d’abord, voici le traditionnel « Hello World » :

import "fmt"

func main() {

fmt.Println("Hello, World!")

}

Voici comment déclarer une variable. Le type peut être défini par inférence. Cela signifie que c’est le compilateur qui va choisir le type tout seul, comme un grand. var i : int = 10 // en spécifiant le type explicitement var i = 10 // par inférence La déclaration d’une chaîne de caractères par inférence : var str = "Bonjour le Monde ! " D’une constante : const a = 1 Les déclarations peuvent être regroupées :

var b int = 2 //une autre manière de typer

une variable

var x, y, z int // idem mais 3 variables d’un

coup. Le type

// – ici int – est spécifié à la fin

var i, j, k int = 5, 10, 20 // déclaration /

initialisation

b += x // b est

« incrémenté » de la valeur de x :

// b = b + x, comme en C/C++

La structure if permet d’inclure une déclaration devant la condition, ce qui, au passage, n’est guère intéressant et rend le code moins lisible. Autant la déclarer et l’initialiser sur la ligne précédente.

x = multiplier(y, 100)

if x < 1000 { // « classique »,

c’est-à-dire comme en C/C++

fmt.Println("ok")

}i

f x = multiplier(y, 100); x < 1000 { // à

la « sauce » Go

fmt.Prinfln("ok")

}

x = multiplier(y, 100);

if(x < 1000) {

puts("ok");

}

La structure switch est un peu différente, et là, cela peut s’avérer utile. Le break habituellement nécessaire (en C, C++, C# ou Java) pour ne pas exécuter le code de plusieurs conditions disparaît. Le switch du Go n’en a pas besoin pour sortir directement. Il est néanmoins possible d’associer plusieurs cas à un même traitement, en spécifiant le mot réservé fallthrough.

switch x {

case "a":

fmt.Println("a")

case "b":

fallthrough

case "c":

fmt.Println("b ou c")

default:

fmt.Println("x")

}

La boucle for ne comporte plus de parenthèses. Les accolades sont, du coup, obligatoires, même lorsqu’il n’y a qu’une ligne d’instruction à exécuter – ce qui n’est pas le cas en C/ C++ ou Java.

for i:= 0; i < 100; i++ {

fmt.Println(i)

}

Le for remplace le while, en précisant seulement la condition :

// le mot var peut être employé pour

l’inférence, comme en C#

var i = 0

for i < 100 {

fmt.Println(i)

i += 10 // comme pour un while, il

faut faire évoluer

} // la condition

dans le corps de la boucle

Le For ... each existe, mais il se « met en place » via le mot range :

var tab = []int { 10,20,30 }

for i, t := range tab {

fmt.Println(t)

}

Eh oui, le Go est adepte du verlan et aime mettre les types à la fin. La déclaration d’une fonction se fait avec le mot-clef func. Le JavaScript utilise le mot function, le Python def et le C/C++, … rien.

Cela donne, pour déclarer une fonction multiplier :

func multiplier(x int, y int) int { return x * y }

Une fonction Go peut retourner plusieurs valeurs sous forme de tuple, contrairement à la plupart des langages :

func ftuple(x int, y int) (int, int) { return

x * 2, y * 2 }

Et pour les récupérer dans le code appelant :

x, y = ftuple(10, 15)

Cela peut s’avérer pratique, il faut bien l’avouer. Les structures de données sont, elles aussi, déclarées à la mode verlan :

type Coordonnees struct {

x float64

y float64

}

Et voici un petit script d’affichage des lettres d’une chaîne via une boucle for :

package main

import ("os";"flag";)

func main() {

var chaine = " Bonjour le Monde !"

// on se contente de passer le nom du

tableau

// pour sa longueur. En C++, il aurait

fallu écrire

// i < chaine.length

for i := 0; i < chaine; i++ {

fmt.Println(chaine[i])

}

}

La gestion des bibliothèques est très différente de celle du C++. Il n’y a pas de fichiers d’entêtes, mais à côté de cela, vous pouvez inclure des modules externes directement d’un site distant. Ces informations sur l’intégration sont stockées dans des modules du Go. Cela peut faciliter la distribution des programmes. L’inconvénient – de taille – est que les modules importés ainsi cessent souvent d’être compatibles, ce qui vous oblige alors à modifier vos programmes.

Vous pouvez réaliser des applications web utilisant le Go côté serveur depuis l’infrastructure cloud de Google grâce à l’App Engine pour Go (https://cloud. google.com/ appengine/ docs/go/ ).

Goroutines, channels et parallélisme

Une goroutine est une espèce de thread simplifié permettant d’écrire du code asynchrone très rapidement – et simplement. Pour créer une goroutine, il suffit de placer le mot-clé go devant un appel de fonction :

go list.Sort() // lance list.Sort dans un

nouveau thread

C’est une fonctionnalité puissante, mais il faut bien récupérer d’éventuelles données générées par la goroutine ou simplement savoir si son exécution est terminée. Pour cela, vous avez les channels, conçus pour gérer la communication entre les goroutines.

c := make(chan int) // création d’un

channel de type entier.

// Lancement d’une goroutine. Lorsque le

traitement est

// terminé, un signal est envoyé au

channel.

go func() {

list.Sort()

c <- 3 // Envoie un signal au channel c

}()

doSomething ()

<-c // Attends la fin du traitement pour

continuer.

Cet exemple de code crée un channel de type int puis une goroutine dans laquelle est effectué le traitement – ici un tri. À la fin du traitement, le channel en est informé grâce à l’envoi d’un signal. La fonction doSomething est appelée. La dernière ligne indique qu’il faut attendre la réception du signal pour passer à la suite. Ici, la valeur retournée par le signal n’a pas d’importance puisqu’elle n’est pas traitée. L’utilisation conjuguée de ces deux fonctionnalités permet d’écrire assez facilement des programmes comportant des traitements asynchrones.

Sur Go by example (https:// gobyexample. com/), vous trouverez aussi de très nombreux exemples de codes.

Outils et bibliothèques

Plusieurs outils sont fournis par Google avec le compilateur du Go : go fmt, pour formater le code correctement, golint qui propose des suggestions d’amélioration ainsi que go vet qui vérifie la syntaxe et la présence des constructeurs. La bibliothèque de base du Go est très riche. Vous pouvez coder un serveur web à l’aide de net/http ou créer des traitements d’entrées / sorties (Input/ Output) avec io et io/ioutil. Si en plus vous utilisez des fichiers, vous disposez d’os. Vous voulez coder une API en JSON ? C’est encoding/json qu’il faudra charger. Concernant les dépendances, leur gestion se fait simplement en les déclarants dans le fichier qui les utilise, comme en Java :

package main

import "fmt"

func main() {

fmt.Println("Hello, world!")

}

Les programmes Go sont compilés en binaires. Un simple scp suivi d’un restart permet de déployer une nouvelle version de son programme. Un code similaire générera un binaire plus gros en Go qu’en C ou même qu’en C++. Le postulat de départ – remplacer le langage C pour des programmes bas niveau – est passé aux oubliettes, semble-t-il.

Les canaux

Les canaux sont synchrones par défaut mais ils peuvent être déclarés asynchrones, en spécifiant la taille du tampon. Vous pouvez aussi écouter plusieurs canaux en même temps grâce à la commande Select. Les variables non utilisées sont interdites et pas seulement signalées via des warnings lors de la compilation. L’allocation dynamique de mémoire se fait via la fonction make – rien à voir avec le make de C/C++, mais plutôt avec ses fonctions malloc ou calloc.

valeur := make([]byte, 1024)

Comme il y a un garbage, nul besoin d’instruction free. Il n’y a pas de gestion des exceptions, les auteurs voyant cela comme une structure de contrôle dangereuse.


Les slices, des vues sur un tableau

Les tableaux sont assez rigides, néanmoins les vues (slices) viennent assouplir la gestion des collections. Il est du coup plus fréquent, en Go, d’utiliser des vues à la place du tableau sous-jacent :

binary.BigEndian.PutUint16(result[2:8], packet.Qdcount)

// result est le tableau, result[2:8] une vue et non une copie

 


Interfaces

Le Go, tel le Java, a des interfaces. Cela permet de spécifier les signatures ou prototypes de fonctions qui doivent être implémentées par un type pour que celui-ci puisse être utilisé. Ce concept est très employé dans les bibliothèques. En voici un exemple dans la librairie io :

/* Un type avec une fonction d’écriture. Cela peut être un

fichier, une chaîne de caractères ou autre */

type Writer interface {

Write(p []byte) (n int, err os.Error)

}/

* Et ensuite : */

func NewBufferedWriter(wr io.Writer) *BufferedWriter

Print
1451
Tags:dev

Name:
Email:
Subject:
Message:
x
Rechercher dans les Dossiers
Actuellement à la Une...
Là où la fibre n’est pas attendue à court ou moyen terme, l’Arcep va attribuer des fréquences dans la bande 3,5 GHz aux opérateurs pour le très haut débit radio. Le régulateur a publié les modalités des délivrances d’autorisation.

C’est la deuxième fois cette année qu’un enregistreur de saisie est découvert dans les pilotes présents sur les PC de HP. Cette fois-ci, la faille de sécurité affecte les drivers des pavés tactiles Synaptics sur 450 modèles d’ordinateurs portables.

Si les cartes de débit Payoneer sont on ne peut plus légales, elles peuvent faciliter la fraude fiscale en compliquant le travail du fisc. Airbnb a accepté sur demande des ministres de l’Économie et de l’Action et des Comptes publics de retirer ce moyen de paiement qu’il proposait aux hébergeurs.

En juillet dernier, SFR annonçait tambour battant son intention de déployer son propre réseau FTTH, sur fonds propres. Le voici qui revient aujourd’hui sur ce projet, ne souhaitant pas trop s'engager envers les collectivités territoriales. Et manquant accessoirement des capacités d’investissements nécessaires.

Après le passage de 140 à 280 caractères, Twitter débride toujours plus ses services quitte à perdre encore un peu de son âme.

C’est désormais officiellement confirmé, la marque à la pomme va mettre la main sur les technologies de reconnaissance musicale de Shazam, laissant Spotify et Snap, eux-aussi candidats au rachat, sur le carreau.

Microsoft n’a pas encore d’ordinateur quantique, mais il propose déjà un kit de développement d’applications quantiques, reposant sur Q#, son nouveau langage de programmation dédié. Le kit embarque par ailleurs un simulateur de calcul quantique, simulant 30 qubits, pour remédier au manque de hardware à Redmond.

Quantum, le spécialiste de la gestion des données, rend disponible une solution Xcellis de Scale-out NAS prêt à faire face à toutes les tâches même les plus exigeantes pour un coût inférieur à 100 $/To.

Les 30 membres du CNNum sont désormais connus. Avec à sa tête l’entrepreneuse Marie Ekeland, la formation regroupe des acteurs de l’économie, des personnalités de la société civile et des chercheuses et chercheurs issus du monde académique.

L’outil, intégré notamment à Windows Defender, est censé protéger l’internaute des vils malwares qui traînent sur le Net et dans les messageries. Paradoxe qui serait cocasse s’il n’était pas aussi inquiétant, Malware Protection Engine était lui-même affligé d’une méchante faille simple à exploiter.

Toutes les News

LIVRES BLANCS

"L'entreprise numérique", un Livre Blanc IDC/Interxion.

Ce livre blanc présente les résultats d'une enquête menée auprès de plus de 750 entreprises européennes.

Vous y découvrirez l'approche adoptée par les leaders du numérique, combinant l’adoption des services Cloud avec une politique d’hébergement externalisé.  

  


La maintenance prédictive, pilier de la transformation digitale, un Livre Blanc Econocom.

LA MAINTENANCE IT, L’INVISIBLE PIERRE ANGULAIRE DE L’ENTREPRISE DIGITALE

La transformation digitale rebat les cartes de la performance des entreprises. Face à l’évolution simultanée des attentes des clients, des modèles économiques, des conditions de marché et des modes de travail, chaque métier doit revoir sa contribution aux trois axes qui conditionnent dorénavant la réussite: l’excellence opérationnelle, l’expérience utilisateurs et l’innovation métier.


CARTOGRAPHIE DU PAYSAGE DES RANSOMWARES, un Livre Blanc Fortinet.

Comprendre la portée et la sophistication de la menace.

Lorsque les cybermenaces sont multipliées par 35 en un an, chaque entreprise doit en tenir compte. C’est précisément le cas avec les ransomwares. Les hacktivistes ont ciblé des entreprises de pratiquement toutes les tailles et représentant une multitude de secteurs industriels dans le monde entier.


Comment moderniser ses centres de données, un Livre Blanc HPE.

La transformation numérique des entreprises crée de nouvelles contraintes sur les directions informatiques, en particulier pour les environnements de stockage. 

La croissance exponentielle des données, la virtualisation massive, l'évolution des charges de travail et la mise en place permanente de nouvelles applications (devops) obligent l'infrastructure de stockage informatique à évoluer. 


Repensez votre approche en matière de cybersécurité, un Livre Blanc Fortinet.

Pourquoi les leaders de la sécurité sont désormais contraints de faire face aux principales menaces de sécurité. 

Le paysage de cybermenace continue de croître et d’évoluer. Cybersecurity Ventures prévoit que la cybersécurité deviendra un business de mille milliards de dollars entre 2017 et 2021.


Tous les Livres Blancs