Ouvrir le menu principal

Wikipédia β

Go (langage)

Langage de programmation
Page d'aide sur l'homonymie Pour les articles homonymes, voir GO.
Page d'aide sur l'homonymie Cet article concerne le langage de programmation open source créé par Google en 2009 . Pour le langage de programmation créé en 2003 , voir Go! (langage). Pour go dans d'autres contexte, voir GO.

Go est un langage de programmation compilé et concurrent inspiré de C et Pascal. Ce langage a été développé par Google[5] à partir d'un concept initial de Robert Griesemer, Rob Pike et Ken Thompson. Go possède deux implémentations, la première utilise gc, le compilateur Go et la seconde utilise gccgo un « frontend » GCC écrit en C++. Go est écrit en C en utilisant yacc et GNU Bison pour l'analyse syntaxique[6] jusqu'à la version 1.4, et en Go lui-même pour les versions suivantes (1.5).

Go
Logo.
Image illustrative de l'article Go (langage)

Date de première version
Paradigme Langage compilé, programmation concurrente, impérative et structurée
Auteur Robert Griesemer
Rob Pike
Ken Thompson
Dernière version 1.9 ()[1]Voir et modifier les données sur Wikidata
Typage Fort, statique, structurel
Influencé par C
Python
Oberon-2 (en)
Limbo
Active Oberon (en)
Communicating sequential processes
Pascal
Oberon
Smalltalk
Newsqueak (en)
Modula-2Voir et modifier les données sur Wikidata
Système d'exploitation Windows, GNU/Linux, Mac OS X, FreeBSD, Plan 9[2]
Licence Licence BSD[3], breveté[4]
Site web golang.orgVoir et modifier les données sur Wikidata
Extension de fichier goVoir et modifier les données sur Wikidata
Logo de Google Go
Mascotte de Google Go.

Un objectif de Go est donné par Rob Pike, l'un de ses trois créateurs, qui dit à propos des jeunes développeurs[7] :

« 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 »

Go veut faciliter et accélérer la programmation à grande échelle : en raison de sa simplicité, sa compilation serait de 80 % à 90 % plus rapide que la compilation classique du C[8], et il est donc concevable de l'utiliser aussi bien pour écrire des applications, des scripts ou de grands systèmes. Cette simplicité est nécessaire aussi pour assurer la maintenance et l'évolution des programmes sur plusieurs générations de développeurs.

S'il vise aussi la rapidité d'exécution, indispensable à la programmation système, il considère le multithreading comme le moyen le plus robuste d'assurer sur les processeurs actuels cette rapidité[9] tout en rendant la maintenance facile par séparation de tâches simples exécutées indépendamment afin d'éviter de créer des « usines à gaz ». Cette conception permet également le fonctionnement sans réécriture sur des architectures multi-cœurs en exploitant immédiatement l'augmentation de puissance correspondante.

Sommaire

« Hello, world »Modifier

Voici un exemple d'un programme Hello world typique écrit en Go.

package main

import "fmt"

func main() {
	fmt.Printf("Hello, world\n")
}

CaractéristiquesModifier

Le langage Go a été créé pour la programmation système et a depuis été étendu aux applications, ce qui constitue la même cible que le C et surtout le C++. Il s'agit d'un langage impératif et concurrent.

ConcurrenceModifier

Go intègre directement, comme Java, les traitements de code en concurrence. Le mot clé go permet à un appel de fonction de s'exécuter en concurrence avec le thread courant[10]. Ce code exécuté en concurrence se nomme une goroutine par analogie lointaine avec les coroutines. Le programme prendra alors avantage de la topologie de l'ordinateur pour exécuter au mieux les goroutines, pas forcément dans un nouveau thread, mais il est aussi possible qu'un groupe de goroutines soit multiplexé sur un groupe de threads.

Pour appeler une fonction f, on écrit f(). Pour l'appeler en tant que goroutine, on écrit simplement go f(), ce qui est très semblable au call f task; de PL/I ; langage gérant également le multitâche depuis 1970.

Les goroutines communiquent entre elles par passage de messages, en envoyant ou en recevant des messages sur des canaux[11].

Ces messages synchronisent les goroutines entre elles, conformément au modèle CSP, considéré par les auteurs comme plus intuitif que le modèle multi-threadé (avec synchronisation par sémaphores comportant des verrous, notion introduite aussi elle-même par Dijkstra).

Système de typesModifier

Go a un système de type statique, fortement typé, structurel et sûr, fondé sur l'inférence de types avec la possibilité d'utiliser un typage explicite.

La compatibilité des types composés est fondée sur les propriétés plutôt que sur le nom. C'est-à-dire que deux types composés seront équivalents si leurs propriétés sont équivalentes : même nom pour la propriété et équivalence de type. C'est le typage structurel.

Cela a pour conséquence que le langage n'est pas objet au sens classique (soit avec classes, soit avec prototype), cependant les concepteurs du langage ont fait un choix plus original pour un langage statique. Il est possible de définir des interfaces portant des méthodes décrivant le comportement d'un objet (Il est aussi facilement possible de mélanger plusieurs interfaces en une seule)[12]. Les fonctions Go peuvent déclarer accepter un argument de cette interface. Un objet déclarant toutes les méthodes de cette interface, avec la même signature, peut être passé en argument de cette méthode. La vérification du type est effectuée statiquement par le compilateur.

Le fait que Go ne soit pas objet au sens classique fait que Go n'a pas d'héritage de type et pas de sous-classage. Ceci permet de contourner les problèmes posés par ces systèmes tels l'héritage multiple dans les langages qui le permettent (en C++ par exemple), ou l'héritage simple (en Java par exemple). Grâce à l'équivalence de types fondée sur les propriétés, Go n'a pas besoin d'héritage de type. Le sous-classage est émulé par l'« embarquement de type ». Ceci permet de mélanger facilement deux bases de code conçues indépendamment, sans qu'elles aient besoin de partager des types communs.

La visibilité des structures, attributs, variables, constantes, méthodes, types de haut niveau et des fonctions hors de leur paquetage de déclaration est définie par la casse du premier caractère de leurs identificateurs.

DiversModifier

Dans Go, la gestion de la mémoire est laissée à un ramasse-miettes[12].

Il n'y a pas encore de programmation générique même si les concepteurs du langage y réfléchissent. Il n'y a pas de surcharge de méthodes ou d'arithmétique des pointeurs. Enfin, il n'y a pas d'assertions ou d'exceptions. Pour remplacer ces deux derniers, Go fournit les mots clés defer, panic et recover[13] qui donnent des mécanismes similaires aux systèmes de gestion des exceptions de langages tels que C++ et Java (mots clés try, catch, finally et throw).

Go peut s'interfacer avec des bibliothèques en C/C++, des développeurs tiers ayant déjà développé des bindings pour SDL et MySQL.

Go définit un format de code standard (au niveau des indentations, et de la présentation des structures de contrôle) et fournit un outil pour l'appliquer (go fmt).

Go propose également un système de documentation à partir du code et un framework de test.

L'unité de compilation de go est le package qui est représenté dans l'implémentation standard par un répertoire et les fichiers directement contenus dans ce répertoire.

L'import d'un package se fait par son chemin d'importation et peut préciser soit une bibliothèque standard, soit également des packages tiers installés dans des dépôts de sources distants (actuellement supporté : dépôt sous svn, git, mercurial et bazaar)

Extensions expérimentalesModifier

Bien que Go soit au départ destiné à produire des applications système robustes et non des programmes destinés à des utilisateurs, des liens avec OpenGL sont développés à titre expérimental[14].

Projets utilisant goModifier

  • Caddy - Serveur web
  • Cayley - Base de données orientée graphe
  • Cockroach - Base de données SQL distribuée
  • Consul - Système de découverte de service et de gestion de configuration
  • Docker - Création, déploiement et exécution d'application dans des conteneurs
  • Etcd - Base de données distribuée clé-valeur
  • Gogs - Forge multiplateforme fondée sur git
  • Grafana - Outil de monitoring, d'analyse de métriques et de création de dashboards
  • Influxdb - Base de données destinée à l'enregistrement d'évènements, de métriques
  • Kubernetes - Système de gestion d'applications conteneurisées
  • Nsq - Plateforme de messaging distribuée et temps réel
  • Prometheus - Système de monitoring
  • Readium LCP - Serveur de DRM pour EPUB
  • Terraform - Outil pour construire, modifier et combiner des infrastructures
  • Tidb - Base de données NewSQL distribuée compatible avec MySQL
  • Traefik - HTTP reverse proxy et load balancer

Notes et référencesModifier

  1. « Go 1.9 is released » (consulté le 25 août 2017)
  2. (en) « Go on Plan9 ».
  3. (en) « Text file LICENSE » (consulté le 27 janvier 2011).
  4. (en) « Additional IP Rights Grant », sur golang (consulté le 30 juin 2017).
  5. (en) https://techcrunch.com/2009/11/10/google-go-language/.
  6. (en) « FAQ - The Go Programming Language », golang.org, 6 octobre 2011.
  7. (en) « From Parallel to Concurrent ».
  8. (en) [PDF] « Go Tech Talk »(ArchiveWikiwixArchive.isGoogleQue faire ?) (consulté le 13 avril 2013), page 37.
  9. (en) [vidéo] Rob Pike sur la programmation concurrente sur YouTube.
  10. Cette notion avait été introduite dans PL/I en 1970 en faisant suivre un appel de sous-programme du mot TASK.
  11. Voir Message Passing Interface.
  12. a et b (en) Rob Pike, « Go at Google » (consulté le 6 novembre 2012).
  13. « Defer, Panic, and Recover », sur blog.golang.org, .
  14. (en) https://github.com/go-gl.

AnnexesModifier

Sur les autres projets Wikimedia :

Liens externesModifier