L’équipe de Go a récemment publié les résultats de son enquête semestrielle auprès des développeurs, fournissant des informations précieuses sur l’utilisation du langage de programmation Go et les défis auxquels sont confrontés les développeurs. L’enquête, qui s’est déroulée de mi-juillet à mi-août 2023, a permis de recueillir les retours d’expérience des développeurs et de mieux comprendre les piles technologiques couramment utilisées avec Go, l’intérêt pour les outils de développement en IA/ML, les défis liés à la construction de microservices, et plus encore.Go est un langage de programmation compilé et concurrent inspiré de C et Pascal. Développé par Google, Go veut faciliter et accélérer la programmation à grande échelle : en raison de sa simplicité 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é 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 multicœurs en exploitant immédiatement l'augmentation de puissance correspondante.
Environnements de développement
Comme les années précédentes, la majorité des personnes interrogées ont déclaré travailler avec Go sur les systèmes Linux (63 %) et macOS (58 %). De petites variations de ces chiffres d'une année à l'autre dépendent très probablement de qui trouve et répond à cette enquête (en particulier sur le blog Go), car l'équipe n'a pas observé de tendances cohérentes d'une année sur l'autre dans l'échantillon aléatoire provenant de VS Code.
Nous continuons de constater que les nouveaux membres de la communauté Go sont plus susceptibles de travailler avec Windows que les développeurs Go plus expérimentés. Nous interprétons cela comme un signal selon lequel le développement basé sur Windows est important pour l'intégration de nouveaux développeurs dans l'écosystème Go, et c'est un sujet sur lequel notre équipe espère se concentrer davantage en 2024.
Les personnes interrogées continuent de se concentrer fortement sur les déploiements Linux. Compte tenu de la prédominance de Go pour le développement cloud et les charges de travail conteneurisées, cela n’est pas surprenant mais reste une confirmation importante. L'équipe a trouvé peu de différences significatives basées sur des facteurs tels que la taille de l'organisation ou le niveau d'expérience; en effet, même si les développeurs Go novices semblent plus susceptibles de développer sur Windows, 92 % d'entre eux continuent de déployer sur des systèmes Linux. La conclusion la plus intéressante de cette analyse est peut-être que les développeurs Go plus expérimentés ont déclaré qu'ils déployaient sur une plus grande variété de systèmes (notamment WebAssembly et IdO), bien qu'il ne soit pas clair si cela est dû au fait que de tels déploiements sont difficiles pour les nouveaux développeurs Go ou au fait que des développeurs Go expérimentés utilisent Go dans un plus large éventail de contextes. L'équipe a également observé que l'IdO et le WebAssembly ont augmenté régulièrement ces dernières années, chacun passant de 3 % en 2021 à 6 % et 5 % en 2023, respectivement.
Le paysage de l’architecture informatique a changé au cours des dernières années, et cela se reflète dans les architectures actuelles avec lesquelles les développeurs Go disent travailler. Si les systèmes compatibles x86 représentent encore la majorité des développements (89 %), ARM64 est également désormais utilisé par une majorité des répondants (56 %). Cette adoption semble être en partie motivée par Apple Silicon ; Les développeurs macOS sont désormais plus susceptibles de déclarer qu'ils développent pour ARM64 que pour des architectures x86 (76 % contre 71 %). Cependant, le matériel Apple n’est pas le seul facteur à l’origine de l’adoption d’ARM64 : parmi les personnes interrogées qui ne développent pas du tout sur macOS, 29 % déclarent néanmoins développer pour ARM64.
Pile technologique
Pour mieux comprendre le Web de logiciels et de services avec lesquels les développeurs Go interagissent, l'équipe a posé plusieurs questions sur les piles technologiques. Et de donner des précision :
Nous partageons ces résultats avec la communauté pour montrer quels outils et plates-formes sont couramment utilisés aujourd'hui, mais nous pensons que chacun devrait prendre en compte ses propres besoins et cas d'utilisation lors de la sélection d'une pile technologique. Plus clairement : nous n’avons pas l’intention que les lecteurs utilisent ces données pour sélectionner des composants de leur pile technologique parce qu’ils sont populaires, ni qu’ils évitent les composants parce qu’ils ne sont pas couramment utilisés.
Les bases de données sont des composants extrêmement courants des systèmes logiciels. 91 % des personnes interrogées ont déclaré que les services Go sur lesquels ils travaillent en utilisaient au moins un. Le plus souvent, il s'agissait de PostgreSQL (59 %), mais avec un pourcentage à deux chiffres de répondants déclarant utiliser six bases de données supplémentaires, on peut affirmer sans se tromper qu'il n'y a pas seulement quelques bases de données standard que les développeurs Go doivent prendre en compte. Nous pouvons constater à nouveau des différences en fonction de la taille de l'organisation, les répondants des petites organisations étant plus susceptibles de déclarer utiliser PostgreSQL et Redis, tandis que les développeurs des grandes organisations sont un peu plus susceptibles d'utiliser une base de données spécifique à leur fournisseur de cloud.
Un autre composant courant que les répondants ont déclaré utiliser était les caches ou les magasins de valeurs-clés; 68 % des personnes interrogées ont déclaré travailler sur un logiciel Go intégrant au moins un de ces éléments. Redis était clairement le plus courant (57 %), suivi de loin par etcd (10 %) et memcached (7 %).
Comment les développeurs démarrent de nouveaux projets Go
Dans le cadre de son expérimentation avec les modèles de projet, l'équipe voulait comprendre comment les développeurs Go se lancent aujourd'hui dans de nouveaux projets. Les personnes interrogées ont dit que leurs plus grands défis consistaient à choisir une manière appropriée de structurer leur projet (54 %) et à apprendre à écrire du Go idiomatique (47 %). Comme l’ont formulé deux répondants :
« Trouver une structure appropriée et les bons niveaux d'abstraction pour un nouveau projet peut s'avérer assez fastidieux ; chercher l'inspiration dans des projets communautaires et d'entreprise de haut niveau peut être assez déroutant car chacun structure son projet différemment » — Développeur professionnel Go avec 5 à 9 ans d'expérience Go
« Ce serait formidable si [Go disposait d'une] chaîne d'outils pour créer la structure de base [d'un projet] pour le Web ou la CLI comme « go init <nom du projet> » » — Développeur professionnel Go avec 3 à 4 ans d'expérience
« Ce serait formidable si [Go disposait d'une] chaîne d'outils pour créer la structure de base [d'un projet] pour le Web ou la CLI comme « go init <nom du projet> » » — Développeur professionnel Go avec 3 à 4 ans d'expérience
Une majorité des personnes interrogées ont déclaré qu'elles utilisaient des modèles ou qu'elles copiaient/collaient le code de projets existants lorsqu'elles démarraient un nouveau projet Go (58 %). Parmi les répondants ayant moins de cinq ans d’expérience Go, cette proportion est passée à près des ⅔ (63 %). Ceci est également étayé par les demandes de fonctionnalités communes pour les modèles de projet : une majorité des personnes interrogées ont demandé 1) une structure de répertoires préconfigurée pour organiser leur projet et 2) un exemple de code pour les tâches courantes dans le domaine du projet. Ces résultats correspondent bien aux défis que les développeurs ont déclaré avoir rencontrés dans la section précédente. Les réponses à cette question aident également à distinguer la différence entre la structure du projet et les modèles de conception, avec près de deux fois plus de personnes interrogées déclarant vouloir que les modèles de projet Go fournissent la première plutôt que la seconde.
Objectifs des développeurs pour la gestion des erreurs
L'équipe Go a expliqué que plutôt que de poser des questions sur les modifications spécifiques apportées à la gestion des erreurs dans Go, nous souhaitions mieux comprendre les objectifs de niveau supérieur des développeurs et savoir si l'approche actuelle de Go s'est avérée utile et utilisable. Nous avons constaté qu'une majorité des personnes interrogées apprécient l'approche de Go en matière de gestion des erreurs (55 %) et déclarent que cela les aide à savoir quand vérifier les erreurs (50 %). Ces deux résultats étaient plus forts pour les personnes interrogées ayant plus d'expérience avec Go, ce qui suggère que soit les développeurs apprécient l'approche de Go en matière de gestion des erreurs au fil du temps, soit qu'il s'agit d'un facteur conduisant les développeurs à quitter l'écosystème Go (ou au moins à cesser de répondre aux enquêtes liées à Go). De nombreux répondants à l'enquête ont également estimé que Go nécessite beaucoup de code passe-partout fastidieux pour vérifier les erreurs (43 %) ; cela reste vrai quelle que soit l’expérience Go antérieure des répondants. Il est intéressant de noter que lorsque les personnes interrogées déclarent apprécier la gestion des erreurs de Go, il est peu probable qu'elles disent que cela entraîne également beaucoup de code standard. Notre équipe a émis l'hypothèse que les développeurs de Go peuvent à la fois apprécier l'approche du langage en matière de gestion des erreurs et la trouver trop verbeuse, mais seulement 14 % des personnes interrogées étaient d'accord avec les deux affirmations.
Les problèmes spécifiques cités par les personnes interrogées incluent la difficulté de savoir quels types d'erreurs vérifier (28 %), la volonté d'afficher facilement une trace de pile avec le message d'erreur (28 %) et la facilité avec laquelle les erreurs peuvent être entièrement ignorées (19 %). Environ ⅓ des personnes interrogées étaient également intéressées par l’adoption de concepts issus d’autres langages, comme celui de l'opérateur Rust ? (31%).
L'équipe Go n'a pas l'intention d'ajouter des exceptions au langage, mais comme il s'agit d'une demande courante de manière anecdotique, nous l'avons incluse comme choix de réponse. Seulement 1 personne interrogée sur 10 a déclaré qu'elle souhaiterait pouvoir utiliser des exceptions dans Go, et cela était inversement lié à l'expérience : les développeurs Go expérimentés étaient moins susceptibles d'être intéressés par les exceptions que les personnes interrogées plus récentes dans la communauté Go.
Comprendre les cas d'utilisation du ML/AI
Aider les ingénieurs à écrire de meilleurs logiciels
Il est indéniable que nous sommes dans un cycle de battage médiatique autour des possibilités de l’IA/ML. Nous voulions prendre du recul pour nous concentrer sur les défis plus larges auxquels les développeurs sont confrontés et sur les domaines dans lesquels ils pensent que l'IA pourrait s'avérer utile dans leur travail habituel. Les réponses étaient un peu surprenantes, surtout compte tenu de l’accent actuel de l’industrie sur les assistants de codage.
Premièrement, nous voyons quelques cas d'utilisation de l'IA qui, selon environ la moitié des personnes interrogées, pourraient être utiles : générer des tests (49 %), suggérer les meilleures pratiques in situ (47 %) et détecter les erreurs probables au début du processus de développement (46 %). Un thème fédérateur de ces principaux cas d’utilisation est que chacun pourrait contribuer à améliorer la qualité et la fiabilité du code qu’un ingénieur écrit. Un quatrième cas d'utilisation (aide à la rédaction de documentation) a suscité l'intérêt d'environ ⅓ des personnes interrogées. Les cas restants constituent une longue liste d’idées potentiellement fructueuses, mais celles-ci présentent nettement moins d’intérêt général que les quatre premières.
Lorsque nous examinons la durée d'expérience des développeurs avec Go, nous constatons que les personnes interrogées novices sont plus intéressées par l'aide à la résolution des erreurs du compilateur et par l'explication de ce qu'un morceau de code Go fait plus que les développeurs Go expérimentés. Il s’agit peut-être de domaines dans lesquels l’IA pourrait contribuer à améliorer l’expérience de démarrage des nouveaux Gophers ; par exemple, un assistant IA pourrait aider à expliquer en langage naturel ce que fait un bloc de code non documenté, ou suggérer des solutions communes à des messages d'erreur spécifiques. À l’inverse, nous ne constatons aucune différence entre les niveaux d’expérience pour des sujets tels que « détecter les erreurs courantes » : les développeurs Go débutants et expérimentés déclarent qu’ils apprécieraient des outils pour les aider.
Source : résultats de l'enquête
Et vous ?
Quelles sont les fonctionnalités spécifiques de Go qui attirent les développeurs novices vers le développement web ? Comment l’introduction des génériques a-t-elle influencé votre flux de travail quotidien en Go ? Quels sont les obstacles les plus importants que vous rencontrez lors de la gestion des erreurs en Go ? Quelles meilleures pratiques en Go souhaiteriez-vous voir plus largement adoptées par la communauté ? Comment les outils d’optimisation pourraient-ils être améliorés pour aider davantage les développeurs Go à améliorer les performances de leurs applications ? Quels sont les défis spécifiques rencontrés par les mainteneurs de modules open source Go, et comment la communauté peut-elle les soutenir ? En quoi les résultats de cette enquête pourraient-ils influencer les futures mises à jour du langage Go ?