Évaluer la naturalité dans la réparation automatique de programme

La réparation automatique de programme, ou APR, est un domaine de recherche en pleine expansion qui vise à corriger les bugs de logiciels automatiquement. C'est perçu comme un outil utile pour les Développeurs qui passent beaucoup de temps à traquer et à réparer manuellement les bugs. Récemment, une nouvelle méthode appelée réparation de programme neurale (NPR) a été introduite, utilisant la technologie d'apprentissage profond et de grands ensembles de données pour corriger des bugs jamais rencontrés auparavant.

Un des défis avec le NPR est d'évaluer à quel point ça fonctionne. Les chercheurs utilisent souvent un ensemble de données connu sous le nom de Defects4J, qui contient des bugs du monde réel pour les tests. Cependant, cet ensemble de données est limité à un petit nombre de bugs, ce qui peut ne pas représenter toutes les différentes sortes de bugs qui existent dans le logiciel réel.

Pour pallier cette limitation, certains chercheurs ont commencé à enrichir l'ensemble de données en créant de nouveaux bugs qui sont similaires en sens à ceux qui existent déjà. Ils font ça en apportant des modifications aux programmes buggés d'origine pour créer de nouveaux programmes buggés, mais similaires. Bien que cette approche augmente la variété des bugs pour tester les méthodes NPR, les chercheurs ont découvert que toutes ces modifications ne sont pas réalistes. Si les changements sont non Naturels, ils peuvent donner des résultats trompeurs sur l'efficacité des systèmes NPR.

#L'importance des Transformations de code naturelles

Le principe ici est qu'il faut tester les corrections de bugs sur des extraits de code réalistes. Si les modifications apportées aux bugs ne ressemblent pas à du code que tu pourrais vraiment trouver dans un logiciel du monde réel, alors les résultats des tests pourraient ne pas être fiables. Pour analyser ça, les chercheurs ont examiné la "naturalité" des changements apportés au code.

Dans une étude récente, les chercheurs ont parlé avec des développeurs de logiciels expérimentés pour recueillir des avis sur ce qui rend un morceau de code naturel ou non naturel. Ils ont découvert que de nombreux changements apportés au code pouvaient être facilement identifiés comme ne correspondant pas aux pratiques de codage courantes, ce qui soulève des drapeaux rouges sur leur efficacité pour évaluer les systèmes NPR.

Par exemple, si une correction de bug dans un programme introduit des noms de variables bizarres qui ne suivent pas les conventions de nommage standards, ça pourrait embrouiller un développeur qui essaie de comprendre le code, rendant plus facile de le classer comme non naturel. De plus, si un programme réparé semble trop compliqué ou s'écarte des modèles de codage connus, il est probable qu'il soit perçu comme non naturel.

#Recueillir des avis de développeurs

Dans l'étude, des interviews ont été menées avec des développeurs seniors pour établir un ensemble clair de critères pour évaluer la naturalité des transformations de code. Les développeurs ont exprimé que maintenir la lisibilité du code et respecter les conventions de codage sont cruciaux. Si un changement réduit la lisibilité ou viole des conventions, il est probable qu'il soit jugé non naturel.

Avec ces insights, les chercheurs ont commencé à évaluer la "naturalité" de nombreuses transformations de code qui avaient été appliquées à des bugs existants. Ils voulaient voir non seulement comment ces transformations fonctionnaient mais aussi si elles semblaient réalistes aux yeux d'un développeur.

#Analyser les transformations de code

Un total de 1178 transformations ont été évaluées par un groupe de développeurs. Les résultats ont montré qu'environ 58,8 % de ces transformations étaient considérées comme naturelles. En revanche, environ 19,3 % étaient jugées non naturelles, ce qui signifie qu'elles incluaient des changements maladroits qui ne se produiraient probablement pas dans des scénarios de codage réels.

La plupart des transformations non naturelles tombaient dans une catégorie connue sous le nom de transformations "au niveau de l'instruction". Celles-ci changeaient souvent significativement la structure du code, conduisant à une perte de lisibilité. Par exemple, une transformation qui réorganise le code à l'intérieur d'une instruction if peut techniquement corriger le bug mais peut aussi rendre le but de ce code confus.

L'étude a également exploré comment différents types de transformations ont impacté l'évaluation des systèmes NPR. Elle a révélé que des transformations non naturelles pouvaient donner de fausses alertes, suggérant que les systèmes NPR étaient moins efficaces qu'ils ne le sont vraiment. Cela a soulevé des questions sur la fiabilité de l'utilisation de code purement transformé pour évaluer la robustesse de ces systèmes.

#Impact sur les systèmes NPR

Cinq systèmes NPR ont été évalués contre les bugs d'origine et transformés. Les résultats ont révélé que ces systèmes pouvaient générer moins de correctifs valables ou plausibles lorsqu'ils étaient testés contre des transformations non naturelles. En fait, les systèmes NPR ont montré une chute substantielle de performance lorsqu'ils étaient confrontés au code transformé.

Cela signifie que si les transformations de code appliquées aux bugs étaient non naturelles, cela affectait négativement la capacité des systèmes NPR à suggérer des corrections viables. Les chercheurs ont découvert que l'ensemble de données d'origine et l'ensemble de données transformé reflétaient des différences significatives dans les métriques de performance. Les systèmes ont mieux performé lorsqu'ils étaient évalués contre des transformations naturelles plutôt que non naturelles.

#Le besoin de meilleures approches

Les résultats soulignent le besoin de meilleures méthodes pour évaluer la performance des réparateurs automatiques de bugs. Cela suggère que les chercheurs devraient se concentrer sur les transformations naturelles lors de la création de tests pour les systèmes NPR. Cela pourrait aider à garantir que les résultats sont plus représentatifs de la performance réelle.

Une solution possible serait d'introduire des directives plus structurées pour créer des transformations préservant le sens qui tiennent également compte de la naturalité. De telles améliorations mèneraient à des évaluations plus fiables des systèmes NPR et à une meilleure compréhension de leur efficacité à corriger des bugs dans des environnements logiciels réels.

#Automatiser l'évaluation de la naturalité

En plus des évaluations manuelles, les chercheurs ont exploré comment la technologie pourrait potentiellement automatiser l'évaluation des transformations de code. Ils ont dérivé une nouvelle métrique conçue pour évaluer la naturalité basée sur le concept d'Entropie Croisée calculée à partir de divers modèles de langage.

En comparant le code d'origine avec les versions transformées, ils ont trouvé que cette métrique pouvait aider à identifier quand une transformation est probablement non naturelle. Des tests initiaux ont suggéré que les évaluations automatisées pourraient donner des résultats utiles, simplifiant le processus d'évaluation et réduisant le besoin de révisions manuelles.

#Conclusion

En conclusion, cette étude met en lumière l'importance d'évaluer la naturalité des transformations de code utilisées dans la réparation automatique de programme. Elle préconise une approche plus systématique pour tester ces systèmes, en intégrant des insights de développeurs expérimentés et en utilisant des méthodes automatisées pour l'évaluation.

En donnant la priorité aux transformations de code naturelles, chercheurs et développeurs pourraient s'assurer que les systèmes de réparation automatique de programme fonctionnent efficacement dans le monde réel. Les investigations continues sur les évaluations automatisées de la naturalité amélioreront probablement le domaine et mèneront à des solutions logicielles plus fiables.