Des coroutines pour Go

• Article qui discute de la nécessité et de la forme d’un package de coroutines pour Go
• Les coroutines sont un modèle de concurrence qui s’exécute simultanément sur des piles distinctes et permet des données partagées ainsi que des points de synchronisation explicites
• L’article fournit des exemples de coroutines en Lua et en Python, en soulignant les différences entre les deux langages
• En comparant coroutines, threads et générateurs, l’article montre que les coroutines offrent de la concurrence sans parallélisme
• L’article explore des cas d’usage des coroutines en Go, comme l’itération sur des collections génériques
• Il présente une implémentation simple de coroutines en Go à l’aide de channels et de goroutines
• Des exemples d’usage des coroutines sont fournis, notamment un parseur de chaînes et un crible de nombres premiers
• L’article se conclut par une discussion sur la possibilité d’une implémentation optimisée des coroutines dans le runtime de Go
• Les coroutines servent à créer des flux de contrôle non parallèles exécutés simultanément
• L’article explique la différence entre coroutines et goroutines
• Les coroutines peuvent servir à créer des pipelines et des filtres pour le traitement des données
• Un exemple d’implémentation d’un crible de nombres premiers avec des coroutines est présenté
• L’article aborde des améliorations possibles des coroutines, comme la gestion des paniques et l’annulation
• À travers des exemples, il montre comment les coroutines peuvent simplifier le code et en faciliter l’organisation
• L’article traite de l’implémentation des coroutines dans le langage de programmation Go
• Les coroutines sont des threads légers que l’on peut suspendre et reprendre
• L’API des coroutines inclut des fonctions comme New, resume, cancel et yield
• Les coroutines permettent de créer une nouvelle forme de concurrence sans introduire de parallélisme
• Leur efficacité est optimisée à travers différentes implémentations
• Une implémentation fondée sur les channels prend environ 190 ns par basculement
• Une implémentation fondée sur le compilateur réduit ce temps à 118 ns par basculement
• L’implémentation la plus efficace utilise un basculement direct de coroutine et atteint 20 ns par basculement
• L’article souligne l’importance de l’optimisation des coroutines pour les performances
• Les coroutines sont utiles pour traiter progressivement des valeurs répétées
• Une implémentation des coroutines en Go offre aux développeurs un outil puissant

[GN⁺]

Commentaires sur Hacker News

• Discussion sur les cas d’usage des itérateurs de fonctions en Go et sur la manière de les écrire pour les utiliser dans des boucles for.
• Certains commentateurs expriment des inquiétudes concernant la complexité et la lisibilité de la solution proposée.
• D’autres soutiennent que les coroutines devraient être une fonctionnalité du langage, et non une bibliothèque.
• La discussion porte aussi sur la différence entre coroutines et green threads, ainsi que sur les avantages et inconvénients de chacune.
• Certains commentateurs se demandent si les coroutines sont vraiment nécessaires en Go, affirmant que les goroutines et les canaux bloquants suffisent.
• L’article évoque également la possibilité d’ajouter à Go des structures de données génériques courantes comme Set, qui pourraient tirer parti des itérateurs.
• Le point central de l’article est d’explorer s’il est possible d’implémenter efficacement des coroutines en Go sans introduire de nouvelles constructions du langage.