Go

Go : une nouvelle API JSON

Soumis par francoistonic le
Image

Go travaille à la refonte complète de son API JSON. Fondamentalement, elle a peu évoluée depuis sa apparition dans le langage. "Après avoir pris en compte les retours d'utilisateurs et apporté des améliorations, les nouveaux packages encoding/json/v2 et encoding/json/jsontext sont stables et disponibles pour tous dans Go 1.27 !" explique le long post officiel.

Globalement, l'encodage JSON a bien résisté à l'épreuve du temps. L'idée de sérialiser et de désérialiser des types Go arbitraires avec une représentation JSON par défaut, combinée à la possibilité de personnaliser cette représentation, s'est avérée extrêmement flexible. 

De nombreux utilisateurs ont relevé plusieurs lacunes :

  • gestion imprécise la syntaxe JSON
  • acceptation d'un UTF-8 invalide en encodage JSON
  • appel des méthodes un peu aléatoire 
  • des performances qui pèsent l'environnement Go
  • une gestion mémoire imparfaite

Mais changer une API aussi importante pose de nombreux problèmes. Le plus important est l'incompatibilité entre la v1 et la v2 (la nouvelle API). "S'il est relativement facile d'ajouter de nouvelles fonctionnalités, il est difficile de modifier celles existantes. Malheureusement, ces problèmes sont inhérents à l'API actuelle, ce qui les rend pratiquement impossibles à corriger dans le cadre de la compatibilité avec Go 1.

En principe, nous pourrions déclarer des noms distincts, tels que MarshalV2 ou UnmarshalV2, mais cela reviendrait à créer un espace de noms parallèle au sein du même package. C'est pourquoi nous avons opté pour encoding/json/v2 (ci-après appelé v2), où nous pouvons effectuer ces modifications dans un espace de noms v2 séparé, contrairement à encoding/json (ci-après appelé v1)." explique le post.

La sérialisation JSON repose sur 2 composants :

- la fonctionnalité syntaxique, qui traite le JSON en fonction de sa grammaire, et

- la fonctionnalité sémantique, qui définit la relation entre les valeurs JSON et les valeurs Go.

encoding/json/2 package est là pour corriger les problèmes de la v1 sans pour autant rompre avec les habitudes des développeurs et de faciliter la migration vers la v2. Par exemple, les fonctions Marshal et Unmarshel ont des signatures identiques à la v1 mais elles acceptent des options pour pouvoir configurer et modifier le comportement. 

Les principales différentes entre la v1 et v2 :

  • La version 2 signale une erreur si un encodage UTF-8 est invalide.
  • La version 2 signale une erreur si un objet JSON contient un nom dupliqué.
  • La version 2 désérialise un objet JSON en une structure Go en utilisant une correspondance sensible à la casse entre le nom du membre JSON et le nom du champ Go.
  • La version 2 redéfinit l'option de balise `omitempty` pour omettre un champ s'il aurait été encodé comme une valeur JSON « vide » 
  • La version 2 signale une erreur lors de la tentative de sérialisation d'un `time.Duration`, qui n'a actuellement pas de représentation par défaut, mais offre des options permettant à l'appelant de choisir.

Présentation complète : https://go.dev/blog/jsonv2

 

Go 1.27 étend son SIMD expérimental à arm64 et wasm avec simd/archsimd

Soumis par francoistonic le
Image

Actualité par la rédaction de Programmez!

Go 1.27 étend l'API SIMD expérimentale, limitée à amd64 depuis Go 1.26, à deux architectures de plus : arm64 et Wasm. L'équipe Go l'a publié le 2 octobre dans un billet de Junyang Shao et David Chase. 

Les nouvelles API s'intègre au package simd/archsimd, la couche de bas niveau sur laquelle repose le package simdportable, l'équivalent des intrinsics dans d'autres langages. Elles s'activent en compilant avec GOEXPERIMENT=simd. Avant l'introduction de cette API expérimentale, écrire directement du SIMD en Go passait par l'assembleur. Le support amd64 couvre AVX, AVX2 et une bonne part d'AVX-512 ; arm64 couvre NEON, tandis que SVE et SVE2 sont en cours d'intégration ; Wasm est presque complet grâce à son abstraction SIMD 128 bits. 

Les extensions matricielles AMX et SME ne sont pas prises en charge ; leur intégration nécessiterait notamment une représentation des matrices. Le parti pris de conception : des types distincts par forme de vecteur (Float32x4, Int32x8, Uint8x16) avec les opérations en méthodes, un seul nom quand la sémantique est identique (x.Add(y) plutôt que 18 fonctions), des noms différents quand le comportement diverge aux bords (PermuteOrZero sur amd64, LookupOrZero sur NEON et Wasm), et des réinterprétations de type sans coût comme ToBits() à la place des méthodes As de Go 1.26. L'équipe attend les retours sur l'issue #73787.

Annonce : https://go.dev/blog/archsimd

GO avancé : nouveau livre sur le langage Go

Soumis par francoistonic le
Image

Les éditions D-Booker annoncent la sortie du livre Go avancé. Un livre pour comprendre le fonctionnement interne du langage Go et de son runtime (compatible Go 1.23+), afin de l'utiliser plus efficacement et de concevoir de meilleures architectures logicielles.

L'ouvrage se découpe en plusieurs parties :

- les fondamentaux du runtime

- types et structures de données

- mécanismes avancés du langage : swift, fonctions anonymes, defer, etc.

- concurrence

Auteur : Thierry Fournier.

Prix : 52 € (version papier), 29 € (version numérique)

Lien : https://www.d-booker.fr/programmation-et-langage/837-1372-golang-avance.html

Programmez! : numéro gaming et développement de jeux est disponible

Soumis par francoistonic le
Image

Le magazine Programmez! sort son numéro hors série d'été : gaming et développeurs de jeux !

Au sommaire : développer des jeux de A à Z en TinyGo, en Rust, avec le moteur Phaser.

Le défi : un casse-briques codé en 1h ou encore créer des jeux pour Game Boy Advance, Nintendo Wii et Super Nintendo ! Ou encore créer un clone du jeu de voitures Out Run, une référence des années 1980.

Pour commander la version papier : https://www.programmez.com/magazine-papier/programmez-hors-serie-23

Pour commander la version PDF : https://www.programmez.com/magazine.php

Tomasz Nurkiewicz explique comment il a réécrit un jeu C++ en Go

Soumis par francoistonic le

Tomasz a publié un très intéressant REX sur la réécriture d'un jeu écrit en C++ / OpenGL, il y a 20 ans. CuTe est un Tetris 3D utilisant C++, OpenGL, WinAPI, Boost, le tout compilé avec Visual Studio 2005 sur Windows XP. Bref, la stack technique commune en 2005. Il a repris le source C++ et demandé à Claude Code : "réécris ceci en Go, remplace OpenGL par quelque chose de portable, mais tout cela doit fonctionner."

Le code représente 3 000 lignes, avec un code OpenGL personnalisé et un usage intensif de Boost 1.33. L'architecture était plusieurs fois faite et la réécriture ne doit pas la modifier :

- moteur pour la logique du jeu et la gestion des objets

- engineExt : pour les animations

- GLEngine : pour le rendu OpenGL

- game : composition des scènes, mode caméra

Avec la fin d'OpenGL sur macOS, il fallait une nouvelle couche graphique qui soit portable : le choix s'est arrêté sur raylib-go. Le code n'a rien à voir. 

Comme l'explique le développeur, le 1er test réalisé par Claude Code a réussi à "comprendre" la logique 3D et à générer 750 lignes. "Bien que j'aie demandé à ce que l'intégralité du code soit portée en Go, Claude Code a simplement estimé que certaines fonctionnalités n'en valaient pas la peine. Je me suis senti un peu vexé..." explique Tomasz. 

Il poursuit "Même si je comprends que certains choix de conception étaient discutables (chiffrement XOR, format de ressources personnalisé, analyseur XML personnalisé), je ne pense pas que cela justifie que Claude les abandonne purement et simplement. Fais juste ce pour quoi je te paie !

Ce qui ressort de cette expérience :

- la séparation des couches dans le code initial a permis à Claude de porter chaque couche. Le moteur du jeu a été réécrit en Go avec le même principe

- les difficultés se sont cachées dans l'expérience du jeu, les spécifications dans les scènes et les objets 3D. Ces éléments sont peu ou pas visibles même quand on lit le code

- l'approche itérative s'est révélée être une meilleure approche que de vouloir faire d'un seul bloc

Source : https://nurkiewicz.com/2026/06/rewriting-cpp-opengl-game-in-go.html

Go, cgo et GOMAXPROCS : nouveau podcast du magazine Programmez!

Soumis par francoistonic le

Programmez! reçoit Thierry Fournier. Avec Thierry, nous parlons de la gestion de l'async en Go, de GOMAXPROCS, faut-il utiliser cgo, et petit aperçu de la structure des binaires en Go.

[video:https://youtu.be/GGIhd8G2BhY?si=Si2n5A56HPf_XzRQ autoplay:0]

PodDev est un podcast du magazine Programmez! www.programmez.com (http://www.programmez.com)

Go : les binaires Go incluent tout

Soumis par francoistonic le

C'est un débat qui existe depuis les premiers langages : que doit contenir un binaire exécutable ? Nous avons lu un résumé sur Linkedin sur les binaires Go de Thierry Fournier. Il précise en introduction qu'un simple code C (hello world) pèse 8 Ko contre 1,2 Mo pour Go. 

Quand on regarde la structure d'un binaire Go, on comprend immédiatement pourquoi il pèse plus lourd. Un binaire exécutable contient TOUS les composants nécessaires pour s'exécuter sur l'OS hôte. Cela signifie qu'il agit comme toute application stand alone. Le binaire Go intègre l'ensemble du runtime incluant le garbade collector, le scheduler des goroutines, la partie de la lib standard utilisée ainsi que le code compilé et les dépendances. 

Cela signifie que nous n'avons besoin que du binaire pour exécuter son application Go sur Linux, macOS, Windows et l'ensemble des architectures matérielles supportées. 

Avantage :

- aucune installation préalable d'un framework, d'une lib ou d'un runtime

- binaire tout-en-un

Inconvénient :

- le poids du binaire qui grossit avec le projet à compiler

Si vous êtes sur un langage interprété, vous devez installer le runtime requis pour exécuter le code. 

Cela signifie que la taille du binaire ne peut pas être réduit à l'infini à cause de sa structure. Vous pouvez jouer sur le code mort, les dépendances inutiles, optimiser les éléments media, etc. La commande nm aide à comprendre ce que contient le binaire et le poids des éléments. Il liste les symbols présents : Text, données en lecture seule, les segments de données, etc. Lors du build, vous pouvez voir le contenu du binaire. 

Source du post : https://www.linkedin.com/feed/update/urn:li:activity:7457317533680001024/

Quelques astuces pour optimiser le poids des binaires Go : https://oneuptime.com/blog/post/2026-01-07-go-reduce-binary-size/view

Microsoft déploie les nouvelles builds Go : 1.26.2-1 et 1.25.9-1

Soumis par francoistonic le
Image

Microsoft annonce les nouvelles builds Go produites par ses équipes : 1.26.2-1 et 1.25.9-1. Ces builds se basent sur les versions officielles de Go. Microsoft inclut dans ces builds les corrections de sécurité. La principale évolution, côté Microsoft, est le retrait de Windows Server 2019 et une mise à jour avec la branche la plus récente du langage. Les builds incluent tous les changelogs de la branche officielle. 

Annonce : https://devblogs.microsoft.com/go/go-1-26-2-1-and-1-25-9-1-microsoft-builds-now-available/

FOSDEM 2026 : the state of Go, quoi de neuf dans Go ?

Soumis par francoistonic le
Image

Pour lancer la 2e journée, la session State of Go a démarré dès 9h. À l’édition 2025, c’était une session particulièrement attendue et il ne fallait pas être en retard pour espérer trouver une place. Cette année, malheureusement, la programmation de la track Go le dimanche matin n’a pas aidé l’audience. La salle était vide à 20 %. Espérons une meilleure exposition en 2027.

Maartje Eyskens fut l’animatrice de la session et n’est pas fan de l’IA. C’est la 12e année que Go a les honneurs de la FOSDEM. L’objectif de la session était d’évoquer en 30 minutes les principales nouveautés de Go depuis la version 1.24. La version 1.25 est sortie en août 2025 et la 1.26 le sera en février.

Tout d’abord, il y a () sur function extension. L’idée est que () peut déterminer la destination du type voulu et créer une nouvelle variable. Sur la partie outil, nous avons deux nouveaux analyseurs dans go vet : waitgroup et hostport. La commande Go doc peut maintenant démarrer une documentation serveur : go doc -http. Pour rappel, godoc avait été déprécié en 2019. Bah, finalement, il revient. Go tool permet de faire moins de pre-builds pour la release. Seul l’essentiel est intégré : le compilateur et le linker.

Cette amélioration en permet une autre : une réduction des binaires : Go 1.24 pesait 75 Mo sur Linux AMD64, en 1.25, on tombe à 57 Mo !

Go mod permet maintenant d’ignorer les directives. Et surtout, Go mod va mieux gérer les anciennes versions. L’équipe du langage veut mettre en avant la rétrocompatibilité et le support des versions n- x du langage !

Sur la partie librairie standard, plusieurs nouveautés et améliorations :

  • synctest.Run permet de démarrer une goroutine dans une bubble
  • synctest.Wait attend toutes les goroutines
  • protection Cross-Site Request Forgery
  • Parse rejette les URL avec des : mal formés
  • relecture : nouvelles méthodes Type/Value.Fields, Type/Value.Methods, Type.Ins et Type.Outs
  • des changements sur le chiffrement : SecP256r1MLKEM768 et SecP384r1MLKEM1024 par défaut, post-quantique, hybride clé publique chiffrée (HPKE)

Plusieurs fonctions expérimentales sont disponibles :

  • simd/archsimd : une seule instruction pour de multiples données, type vecteurs 128, 256 et 512 bits
  • runtimesecret (attention : prudence si vous l’utilisez)
  • profile peut trouver les goroutines manquantes avec goroutineleak profile. Version finale attendue pour Go 1.27.

Un bug de compilation depuis la 1.21 permet de compiler et d’exécuter un code incorrect à cause d’un problème de délai sur la vérification d’un pointeur nil. Normalement, c’est désormais fixé.

L’autre focus des équipes Go est la performance et la réduction des binaires. Un des projets les plus importants est le projet Green Tea. Il s’agit d’un garbage collector en expérimentation : jusqu’à 40 % plus rapide. Sur le chiffrement, le langage améliore les performances crypto/sha1 et crypto/sha3. cgo a subi une sévère optimisation : les overheads des appels cgo sont réduits de 30 %. L’encodage et le décodage JPEG ont été entièrement réécrits. Go promet aussi une allocation mémoire plus rapide sur les petites allocations.

Sur les plateformes supportées, il y a du nouveau :
Go 1.25 nécessite au minimum macOS 12
Go 1.26 retire Windows ARM32 (attention à la casse en production)
Go 1.26 : ajout d’un race detector sur Linux RISC-V 64
Go 1.27 : macOS 13 minimum, retrait de PPC64 big endian

Quel futur pour Go ? Maartje Eyskens évoque plusieurs éléments :

  • le plus important est jsonv2 qui est une refonte totale du parsing JSON. Le paquet JSON est un des plus utilisés mais il est plutôt mauvais et les équipes veulent coller aux spécifications JSON les plus récentes et proposer une implémentation moderne. Seuls json.Marshal() et Unmarshal() étaient correctement implémentés… Il n’y a pas d’UTF-8, accepte la publication des member names (c’est mal), trop de problèmes avec .Decode(), pas de JSON streaming sur les données trop grandes…

Attention : la version actuelle continuera à être présente et à fonctionner. L’équipe veut éviter les casses de code et l’obligation de tout réimplémenter.

Page de la session : https://fosdem.org/2026/schedule/event/T9HSYY-the-state-of-go/

Go : résultats du Go Developer Survey 2025

Soumis par francoistonic le
Image

Go vient de publier son Go Developer Survey 2025. Il donne un état des lieux du développement Go et de qui sont les développeurs Go. Peu de surprises pour cette édition 2025 : le développeur type a entre 25 et 45 ans, il est plutôt satisfait du langage, il travaille en entreprise (petite ou grande). Il utilise plutôt Visual Studio Code sur macOS ou Linux. Il utilise parfois l'IA mais ce n'est pas une priorité. Il développe en priorité des CLI ou des services API / RPC. 

1 / Le développeur Go est développeur de métier (87 %). Il est âgé entre 25 et 45 ans (68 %) avec une expérience dans le développement de 6 ans ou plus. Le développeur Go code des projets persos et/ou open source à 72 %.

2 / Où travaille notre développeur ? La situation est assez éclatée : plutôt dans les entreprises assez petites (de 2 à 500 personnes), pour 51 %. Très peu d'indépendants (moins de 10 %). Le secteur technologique est largement devant le financier. Les répondants vivent plutôt aux États-Unis (23 %), en Allemagne (11 %). La France pèse 5 % du survey.

3 / Une bonne satisfaction ? Oui à 91 %. Mais les développeurs travaillent aussi avec Python (18 %). Rust pointe à 11 %. Dommage que l'étude ne détaille pas plus.

4 / Quelles sont les applications développées ? Les CLI et API/RPC sont les projets les plus développés. Les bibliothèques et frameworks, ainsi que les sites web, sont relativement courants. Les applications desktop sont peu présentes, à peine 12 %. Par contre, l'IA est peu utilisée dans le développement Go. Si l'IA est utilisée pour coder, étonnamment, ChatGPT est le premier service (45 %) puis Copilot et Claude Code. L'écriture de code est un des usages, mais aussi le fait de trouver une réponse à des demandes sur le langage, ou de comprendre un concept de Go ou encore de fixer un problème.

5 / Quelles sont les défis pour bien coder en Go ? Les réponses sont assez dispersées. Nous trouvons : respecter les bonnes pratiques, trouver les bons modules et paquets Go, bien tester le code. L'expérience de développement avec Go pourrait être améliorée, dixit l'équipe du langage. Est-ce que la documentation du langage est souvent utilisée ? Les commandes de base sont utilisées de mémoire (test, build, run, install, mod, fmt). A contrario, les commandes doc et work sont les moins utilisées et, dans ce cas, la documentation est consultée.

6 / Poste de travail et plateformes cibles : le développeur Go développe beaucoup sur macOS (60 %), Linux est juste derrière. Par contre, 96 % des apps Go sont déployées sur Linux. L'architecture cible est x86 (85 %) et ARM64 (53 %). L'outil le plus utilisé est Visual Studio Code, mais GoLand et IntelliJ ne sont pas loin. Si le cloud est utilisé, AWS, et le cloud de l'entreprise ou personnel, sont largement utilisés. Azure est cité seulement par 14 %, GCP est troisième à 26 %.

Etude complète : https://go.dev/blog/survey2025