Discussion :

[Anthony]

La version 1.26 de Go, le langage de programmation développé par Google, est disponible avec des modifications du langage, un nouveau ramasse-miettes, des performances améliorées et bien plus encore

Go 1.26 est désormais disponible. La dernière version du langage de programmation développé par Google introduit deux modifications de la syntaxe du langage : une simplification de la fonction intégrée « new », qui permet désormais à son opérande d'être une expression, et la possibilité pour les types génériques de se référencer à eux-mêmes dans les listes de paramètres de type. Cette mise à jour active également par défaut le ramasse-miettes Green Tea (GC), plus performant, et apporte d'autres améliorations en termes de performances.

Go est un langage de programmation généraliste de haut niveau, statiquement typé et compilé. Il est connu pour la simplicité de sa syntaxe et l'efficacité du développement qu'il permet grâce à l'inclusion d'une grande bibliothèque standard répondant à de nombreux besoins pour les projets courants. Il a été conçu chez Google en 2007 par Robert Griesemer, Rob Pike et Ken Thompson, puis annoncé publiquement en novembre 2009. Sa syntaxe est similaire à celle du C, mais il dispose également d'un ramasse-miettes, d'un typage structurel et d'une concurrence de type CSP.

Go 1.26 introduit plusieurs améliorations majeures du langage et du runtime pour les développeurs. La nouvelle fonction intégrée est désormais plus flexible, car elle accepte des expressions pour les opérandes, ce qui simplifie la spécification des valeurs initiales des variables. Cela est particulièrement utile lors du remplissage de champs facultatifs dans les workflows de sérialisation, tels que ceux utilisant encoding/json ou les tampons de protocole qui utilisent souvent des pointeurs.

Par ailleurs, Go 1.26 permet désormais aux types génériques de se référencer eux-mêmes dans les listes de paramètres de type, ce qui ouvre la voie à des modèles d'abstraction de type plus avancés. Les développeurs bénéficient d'une assistance supplémentaire grâce à la commande go fix entièrement remaniée, qui regroupe désormais les modernizers de Go afin d'automatiser les mises à jour des bases de code, d'appliquer des idiomes modernes et de faciliter les migrations d'API à l'aide d'une suite de fixers et d'un inlineur au niveau de la source.

En termes de performances, le ramasse-miettes Green Tea est désormais activé par défaut, poursuivant ainsi les améliorations apportées en matière d'optimisation et de stabilité lors des expérimentations précédentes. L'efficacité d'exécution est améliorée grâce à une réduction d'environ 30 % de la surcharge des appels cgo. Pour une sécurité renforcée, les plateformes 64 bits bénéficient désormais d'une randomisation de l'adresse de base du tas au démarrage, ce qui rend plus difficile l'exploitation des bogues de mémoire dans cgo.

À la suite de ces changements, Go 1.26 lance également un profil expérimental de fuite de goroutines et apporte d'autres mises à jour au compilateur, au linker, aux routines bootstrap et à la bibliothèque standard.

Modifications du langage

Go 1.26 introduit deux améliorations significatives à la syntaxe du langage et au système de types.

Tout d'abord, la nouvelle fonction intégrée, qui crée une nouvelle variable, permet désormais à son opérande d'être une expression, spécifiant la valeur initiale de la variable.

Un exemple simple de ce changement signifie qu'un code tel que celui-ci :

Code Go :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
x := int64(300)
ptr := &x

Peut être simplifié comme suit :

Code Go :

Sélectionner tout - Visualiser dans une fenêtre à part

ptr := new(int64(300))

Cette fonctionnalité est particulièrement utile lorsque vous travaillez avec des paquets de sérialisation tels que encoding/json ou les tampons de protocole qui utilisent un pointeur pour représenter une valeur facultative, car elle permet de remplir un champ facultatif dans une expression simple, par exemple :

Code Go :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import "encoding/json"
 
type Person struct {
    Name string   `json:"name"`
    Age  *int     `json:"age"` // age if known; nil otherwise
}
 
func personJSON(name string, born time.Time) ([]byte, error) {
    return json.Marshal(Person{
        Name: name,
        Age:  new(yearsSince(born)),
    })
}
 
func yearsSince(t time.Time) int {
    return int(time.Since(t).Hours() / (365.25 * 24)) // approximately
}

Deuxièmement, la restriction selon laquelle un type générique ne peut pas faire référence à lui-même dans sa liste de paramètres de type a été supprimée. Il est désormais possible de spécifier des contraintes de type qui font référence au type générique contraint. Ce changement simplifie la mise en œuvre de structures de données et d'interfaces complexes.

Par exemple, un type générique Adder peut exiger d'être instancié avec un type qui lui est similaire :

Code Go :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
type Adder[A Adder[A]] interface {
    Add(A) A
}
 
func algo[A Adder[A]](x, y A) A {
    return x.Add(y)
}

Auparavant, l'autoréférence à Adder dans la première ligne n'était pas autorisée. Outre le fait de rendre les contraintes de type plus puissantes, cette modification simplifie également très légèrement les règles de spécification pour les paramètres de type.

Améliorations apportées aux outils

Commande Go

La vénérable commande go fix a été entièrement remaniée et héberge désormais les modernisateurs de Go. Elle offre désormais un moyen fiable et instantané de mettre à jour les bases de code Go vers les dernières expressions idiomatiques et API de bibliothèque centrale. La suite initiale de moderniseurs comprend des dizaines de correcteurs permettant d'utiliser les fonctionnalités modernes du langage et de la bibliothèque Go, ainsi que l'analyseur inline au niveau source qui permet aux utilisateurs d'automatiser leurs propres migrations d'API à l'aide des directives inline //go:fix. Ces correcteurs ne devraient pas modifier le comportement de votre programme.

La commande go fix réécrite s'appuie sur le même framework d'analyse Go que go vet. Cela signifie que les mêmes analyseurs qui fournissent des diagnostics dans go vet peuvent être utilisés pour suggérer et appliquer des corrections dans go fix. Les correcteurs historiques de la commande go fix, qui étaient tous obsolètes, ont été supprimés.

go mod init utilise désormais par défaut une version inférieure de Go dans les nouveaux fichiers go.mod. L'exécution de go mod init à l'aide d'une chaîne d'outils de version 1.N.X créera un fichier go.mod spécifiant la version Go go 1.(N-1).0. Les versions préliminaires de 1.N créeront des fichiers go.mod spécifiant go 1.(N-2).0. Par exemple, les versions candidates de Go 1.26 créeront des fichiers go.mod avec go 1.24.0, et Go 1.26 et ses versions mineures créeront des fichiers go.mod avec go 1.25.0. Cela vise à encourager la création de modules compatibles avec les versions actuellement prises en charge de Go. Pour un contrôle supplémentaire de la version de Go dans les nouveaux modules, go mod init peut être suivi de go get go@version.

cmd/doc et go tool doc ont été supprimés. go doc peut être utilisé en remplacement de go tool doc : il accepte les mêmes flags et arguments et se comporte de la même manière.

Pprof

L'interface utilisateur Web de l'outil pprof, activée avec le drapeau -http, affiche désormais par défaut le graphique en flammes. L'ancien graphique est disponible dans le menu « Affichage -> Graphique » ou via /ui/graph.

Améliorations des performances

Le compilateur peut désormais allouer la mémoire de sauvegarde pour les tranches sur la pile dans davantage de situations, ce qui améliore les performances.

Nouveau ramasse-miettes

Le ramasse-miettes Green Tea, précédemment disponible à titre expérimental dans Go 1.25, est désormais activé par défaut.

La conception de ce ramasse-miettes améliore les performances du marquage et du balayage des petits objets grâce à une meilleure localisation et une meilleure évolutivité du processeur. Les résultats des tests de performance varient, mais une réduction de 10 à 40 % de la charge liée au ramasse-miettes dans les programmes réels qui utilisent intensivement le ramasse-miettes est attendue. Des améliorations supplémentaires, de l'ordre de 10 % de la charge liée au ramasse-miettes, sont attendues lors de l'exécution sur des plates-formes CPU amd64 plus récentes (Intel Ice Lake ou AMD Zen 4 et plus récentes), car le ramasse-miettes exploite désormais les instructions vectorielles pour analyser les petits objets lorsque cela est possible.

Le nouveau ramasse-miettes peut être désactivé en définissant GOEXPERIMENT=nogreenteagc lors de la compilation. Ce paramètre de désactivation devrait être supprimé dans Go 1.27.

Appels cgo plus rapides

La surcharge d'exécution de base des appels cgo a été réduite d'environ 30 %.

Compilateur

Le compilateur peut désormais allouer la mémoire de sauvegarde pour les tranches sur la pile dans davantage de situations, ce qui améliore les performances. Si cette modification pose problème, l'outil bisect peut être utilisé pour trouver l'allocation à l'origine du problème à l'aide du drapeau -compile=variablemake. Toutes ces nouvelles allocations de pile peuvent également être désactivées à l'aide de -gcflags=all=-d=variablemakehash=n.

Autres améliorations et modifications

Go 1.26 apporte de nombreuses améliorations par rapport à Go 1.25 au niveau des outils, du runtime, du compilateur, du linker et de la bibliothèque standard. Cela inclut l'ajout de trois nouveaux paquets : crypto/hpke, crypto/mlkem/mlkemtest et testing/cryptotest. Il y a également des modifications spécifiques au port et des mises à jour des paramètres GODEBUG.

Certaines des nouveautés de Go 1.26 sont encore au stade expérimental et ne sont disponibles que si vous les activez explicitement. Notamment :

• Un paquet expérimental simd/archsimd permet d'accéder aux opérations « single instruction, multiple data » (SIMD).
• Un package expérimental runtime/secret fournit une fonctionnalité permettant d'effacer en toute sécurité les fichiers temporaires utilisés dans le code qui manipule des informations secrètes, généralement de nature cryptographique.
• Un profil goroutineleak expérimental dans le package runtime/pprof qui signale les goroutines qui fuient.

Ces fonctionnalités expérimentales devraient toutes être disponibles dans une prochaine version de Go. Pour obtenir la liste complète des ajouts, modifications et améliorations apportées à Go 1.26, vous pouvez consulter les notes de version.

Source : Notes de mise à jour de Go 1.26

Et vous ?

Quel est votre avis sur le sujet ?
Que pensez-vous des nouveautés proposées par cette version de Go ? Les trouvez-vous utiles et intéressantes ?

Voir aussi :

Go et WebAssembly, une alternative prometteuse à React ? Dagger tente l'approche pour optimiser les performances de son frontend et unifier sa base de code

Le langage Go souffle ses 15 bougies et atteint sa position la plus haute sur l'indice Tiobe, Google annonce que le nombre d'utilisateurs de Go a plus que triplé au cours des cinq dernières années

Sortie de la version 1.22 du langage Go, apportant des changements à l'implémentation de la chaîne d'outils, au moteur d'exécution et aux bibliothèques

[dolanor]

Bien content de cette version.

Des retours que j'ai vu, les gains sur CGO et le garbage collection sont assez sympatiques !

Faudrait que je teste sur la démo du moteur 3D g3n.

Et je suis trop content qu'ils réinvestissent sur go fix, un outil tellement sous côté