Évaluer les capacités de génération de code de GitHub Copilot

GitHub Copilot est un outil qui aide les programmeurs à écrire du code en suggérant des solutions en fonction du contexte donné dans les commentaires de code ou les noms de fonctions. Cet article examine à quel point Copilot est efficace pour créer du code en le testant sur une plateforme de codage populaire appelée LeetCode. On se concentre sur quatre langages de programmation : Java, C++, Python3 et Rust. En utilisant un grand ensemble de problèmes de programmation, on vise à savoir à quel point Copilot est fiable pour générer du code, la justesse de ses suggestions et comment sa performance varie selon le langage de programmation et la difficulté des problèmes.

#Méthodologie

Pour analyser la performance de Copilot, on a utilisé l'ensemble de problèmes de LeetCode, qui inclut une variété de défis de codage. Ces défis sont triés en trois niveaux de difficulté : facile, moyen et difficile, en fonction du temps qu'il faut généralement pour résoudre chacun. Les problèmes faciles peuvent être résolus en moins de 15 minutes, les problèmes moyens prennent moins de 40 minutes, et les problèmes difficiles prennent plus de 40 minutes. Cependant, cette classification n'est pas toujours la même, selon qui écrit le problème.

On a collecté des données sur 1760 problèmes pour chacun des quatre langages de programmation. Pour chaque problème, on a demandé à Copilot de générer autant de suggestions que possible et on a testé ces suggestions pour vérifier leur justesse et leur efficacité, en mesurant à la fois le temps d'exécution et l'utilisation mémoire. Au total, on a généré plus de 50 000 soumissions de code sur une période de deux mois.

#Fiabilité de la génération de code

On a d'abord examiné à quel point Copilot est fiable pour générer du code. Cela signifie regarder à quelle fréquence il ne réussit pas à produire de code pour un problème particulier et combien de suggestions il peut fournir pour chaque problème. D'après nos résultats, on a observé que Copilot avait du mal à générer du code en Python3, avec de nombreux cas où il ne produisait pas de solution. Pour Java et C++, Copilot échouait rarement à générer du code.

Le nombre de suggestions fournies pour chaque problème variait aussi selon le langage. Dans l'ensemble, Copilot avait tendance à donner plus de suggestions pour les problèmes de Java et C++ par rapport à Python3 et Rust. Le nombre moyen de suggestions pour Java et C++ était d'environ dix par problème, tandis que Python3 avait généralement environ six suggestions, quelle que soit la difficulté du problème.

#Justesse du code

Ensuite, on a regardé à quel point les suggestions de Copilot étaient correctes. On s'est fié aux tests intégrés de LeetCode pour vérifier si le code généré par Copilot était juste. Une solution était marquée comme "Correcte" si elle passait tous les tests, "Partiellement Correcte" si elle passait certains tests, et "Incorrecte" si elle ne passait aucun test. Globalement, on a trouvé que les solutions de Copilot étaient souvent correctes, surtout en Java et C++.

En termes de langages de programmation, les solutions en Java et C++ avaient les meilleurs taux de succès. Python3 et Rust étaient moins performants, ce qui est surprenant étant donné que Python3 est largement utilisé. On soupçonne que Copilot a eu des difficultés avec Python3 car il a généré moins de suggestions, ce qui rendait moins probable de trouver une solution correcte.

La justesse des solutions de Copilot dépendait également de la difficulté du problème. Pour les problèmes plus faciles, Copilot s'en sortait mieux, tandis que pour les problèmes plus difficiles, le taux de succès diminuait. Cette tendance est similaire aux expériences de codage humaines, où les problèmes plus difficiles ont tendance à être plus délicats pour tout le monde, y compris l'IA.

#Classement des suggestions

Copilot fournit plusieurs suggestions pour chaque problème de codage, et on a analysé comment chaque suggestion performait en fonction de son rang. La première suggestion (rang 0) était souvent la plus correcte, mais ce n'était pas toujours la meilleure. Dans certains cas, des suggestions de rang inférieur avaient aussi des réponses correctes.

Cela signifie que lorsqu'on utilise Copilot, ça vaut le coup de regarder plus que juste la première suggestion. Il y avait des variations dans la performance des suggestions selon les langages de programmation ; par exemple, tandis que le rang 0 était le meilleur pour Java et C++, ce n'était pas vrai pour Python3 et Rust, où d'autres rangs performaient parfois mieux.

#Sujets des problèmes

Les problèmes LeetCode sont classés par sujets comme Arrays, Strings, et Trees. On a examiné comment Copilot performait selon ces sujets pour voir si certaines zones étaient plus difficiles. On a trouvé que les problèmes impliquant des Trees étaient les plus durs pour Copilot, en partie parce qu'ils incluent souvent des images dans leurs descriptions, que Copilot ne pouvait pas interpréter.

D'un autre côté, les problèmes liés au tri, comme le Bucket Sort, avaient un taux de justesse élevé. Dans tous les sujets, Java et C++ avaient généralement de meilleures performances que Python3 et Rust.

#Efficacité du code de Copilot

On a aussi regardé à quel point le code généré par Copilot était efficace par rapport aux soumissions humaines. L'efficacité était mesurée en termes de temps d'exécution et d'utilisation mémoire. On a découvert que le code de Copilot était souvent plus efficace que la soumission humaine moyenne, se situant bien dans des limites acceptables.

En général, le code généré par Copilot avait un temps d'exécution moyen qui le plaçait dans les meilleurs pourcentages par rapport aux soumissions humaines sur LeetCode. Cela suggère que Copilot ne se contente pas de créer du code correct, mais le fait aussi de manière efficace, ce qui signifie qu'il utilise moins de temps et de mémoire.

#Comparaisons avec des recherches précédentes

Cette étude s'appuie sur des recherches antérieures qui examinaient la performance de Copilot mais avec des ensembles de données plus petits. Notre plus grand ensemble de données nous a aidés à découvrir que Copilot performe mieux dans l'ensemble, particulièrement dans des langages comme Java et C++. Les études précédentes se concentraient uniquement sur les suggestions les mieux classées, mais on a élargi notre analyse à toutes les suggestions générées, ce qui a conduit à une vue plus complète des capacités de Copilot.

#Comprendre la performance de Copilot en Python3

On a noté que la performance de Copilot en Python3 n'était pas aussi forte que dans d'autres langages. Bien qu'il existe une quantité importante de code Python3 disponible en ligne, il peut manquer de qualité à cause du nombre de débutants utilisant le langage. Beaucoup de ces débutants écrivent un code moins optimal, ce qui pourrait affecter la façon dont Copilot a appris à générer des solutions.

De plus, Python3 est moins strict que des langages comme Java et C++, permettant plus de flexibilité dans le codage. Cette flexibilité pourrait conduire à une plus grande variété de solutions possibles, ce qui rendrait plus difficile pour Copilot de générer du code correct de manière constante.

#Menaces à la validité

Bien qu'on ait pris des mesures pour s'assurer que notre évaluation était exhaustive, il y a certaines limitations. Les tests de LeetCode peuvent ne pas couvrir tous les cas particuliers, donc il y a une possibilité de mal classer des solutions incorrectes. De plus, toutes les soumissions sur LeetCode ne sont pas écrites par des humains, car certaines peuvent être produites par d'autres outils d'IA. Cela pourrait fausser nos comparaisons.

En outre, les métriques utilisées pour mesurer l'efficacité temporelle et mémoire sont basées sur les systèmes internes de LeetCode, qui pourraient varier en fiabilité. Enfin, Copilot est un modèle non déterministe, ce qui signifie qu'il peut produire des sorties différentes à chaque fois pour la même entrée, donc nos résultats peuvent ne pas toujours être reproductibles.

#Conclusion

En résumé, notre étude fournit un aperçu complet de la performance de GitHub Copilot lors de la génération de code pour des problèmes de LeetCode. On a trouvé qu'il est généralement fiable et produit des solutions correctes, surtout en Java et C++. Bien que Copilot ait du mal en Python3 par rapport à d'autres langages, il génère quand même du code efficace.

À l'avenir, il peut être utile d'élargir les tests pour inclure plus de langages de programmation et différents types de défis de codage pour valider encore davantage ces résultats. Nos résultats peuvent servir de point de référence pour de futures études visant à examiner les capacités d'outils d'IA comme Copilot dans des environnements de codage.