An LLM-based Technique for Detection of Code Clones Across Open Source Microservice Repository Forks

Dans le vaste monde collaboratif du développement de logiciels, les programmeurs construisent souvent de nouvelles applications en prenant du code existant et en l'adaptant à un usage différent. Cette pratique, connue sous le nom de « forking » (création de fourches), est le moteur de l'innovation en open source, permettant aux équipes de se tenir sur les épaules de géants plutôt que de repartir de zéro. Cependant, à mesure que ces projets grandissent et se ramifient, une complexité cachée apparaît : le code qu'ils contiennent peut devenir un réseau de doublons enchevêtrés. Certaines copies sont des répliques exactes, ligne par ligne, tandis que d'autres sont des versions habilement réécrites qui font la même chose mais paraissent totalement différentes en surface. On appelle cela des clones de code. Pour les mainteneurs de grands systèmes logiciels, en particulier ceux construits comme une collection de petits services indépendants, identifier ces doublons est une tâche monumentale. Les outils traditionnels sont excellents pour repérer les copies exactes, mais ils échouent souvent à reconnaître quand deux morceaux de code ont été refactorisés pour remplir la même fonction de manières entièrement différentes. Comprendre où et comment ces doublons existent est crucial, car cela révèle comment le logiciel évolue, où se situent les risques d'incohérence et quel effort est réellement requis pour maintenir un système en bon fonctionnement.

Une équipe de chercheurs s'est récemment donné pour mission de résoudre ce problème en testant un nouveau type d'outil numérique : les grands modèles de langage. Ce sont les mêmes systèmes d'intelligence artificielle puissants qui peuvent écrire des histoires ou répondre à des questions, mais ici, ils ont été entraînés pour comprendre la logique du code informatique. Les chercheurs voulaient voir si ces modèles pouvaient agir comme un microscope sophistiqué, capable de repérer non seulement le code identique, mais aussi le code sémantiquement similaire que les outils traditionnels ne voient pas. Ils ont concentré leur enquête sur des projets de microservices open source, qui sont des systèmes logiciels modernes composés de nombreuses parties petites et interchangeables. Pour commencer, ils devaient apprendre à ces modèles à reconnaître les différents types de clones de code. Ils ont rassemblé un ensemble massif de données de dix mille paires de fragments de code C++, dont la moitié était connue pour être fonctionnellement identique mais syntaxiquement différente, et l'autre moitié était sans rapport. Ils ont testé trois modèles d'intelligence artificielle différents, allant d'un système à usage général à deux modèles spécialisés conçus spécifiquement pour les tâches de codage. Ils ont également expérimenté différentes manières d'interroger les modèles pour accomplir la tâche, essayant tout, des instructions simples aux invites complexes fournissant des exemples et demandant des scores de confiance.

Les résultats de ce test initial se sont révélés révélateurs. Les chercheurs ont constaté que les modèles de codage spécialisés étaient bien supérieurs au modèle à usage général. Parmi eux, un modèle nommé Codestral est apparu comme le plus précis, atteignant la précision globale la plus élevée de 65,5 % et surpassant à la fois l'autre modèle spécialisé et le système à usage général. Cependant, l'étude a aussi mis en évidence une limite significative : même le meilleur modèle commettait des erreurs. Il manquait fréquemment les doublons mêmes qu'il était censé trouver, échouant à les reconnaître environ quarante pour cent du temps. Bien qu'il soit efficace pour identifier le code qui est nettement différent, il était trop prudent lorsqu'il s'agissait de repérer les similitudes subtiles. Ce taux élevé de détections manquées signifiait que, pour l'instant, ces outils puissants ne sont pas encore assez fiables pour être utilisés comme méthode unique de gestion de code dans un cadre professionnel automatisé. Ce sont des assistants utiles, mais ils ne peuvent pas encore remplacer le jugement humain ou les méthodes de détection établies.

Armés du modèle le plus performant et de la méthode de prompting la plus efficace, les chercheurs ont ensuite tourné leur attention vers le monde réel. Ils ont sélectionné vingt-deux paires de dépôts de microservices open source, où l'un était le projet original et l'autre une fourche qui avait été modifiée par un groupe de développeurs différent. Ils ont injecté ces bases de code dans leur système pour cartographier précisément quels types de doublons existaient entre l'original et la fourche. Les conclusions ont brossé un tableau clair de l'évolution de ces projets. Le type de doublon le plus courant qu'ils ont trouvé était la copie exacte, où le code est resté inchangé. Le deuxième plus courant était le clone de Type-3, où le code avait été modifié par des ajouts ou des suppressions tout en conservant sa fonctionnalité d'origine. Étonnamment, le code complètement réécrit qui fait la même chose d'une manière totalement différente était moins courant que les autres types dans ces projets spécifiques. Cela suggère que lorsque les développeurs créent une fourche d'un microservice, ils ont tendance à conserver la structure centrale plutôt qu'à réinventer complètement la roue.

Pour s'assurer que leurs découvertes automatisées étaient dignes de confiance, les chercheurs ont comparé les résultats du modèle à une revue manuelle de trois des projets par des experts humains. Les examinateurs humains ont confirmé que le modèle était généralement correct pour identifier les types de doublons les plus courants, bien que les chiffres spécifiques variaient selon la technologie sous-jacente utilisée par le modèle pour lire le code. L'étude a conclu que, bien que l'intelligence artificielle offre une nouvelle façon prometteuse de comprendre les relations sémantiques profondes entre les morceaux de code, elle n'est pas encore une solution parfaite. La technologie est suffisamment puissante pour voir des motifs que les humains et les outils plus anciens pourraient manquer, mais elle lutte encore avec l'enjeu critique de rater entièrement un doublon. Pour l'instant, ces modèles servent de guide pour aider les développeurs à naviguer dans l'histoire complexe de leur code, plutôt que comme une autorité finale. La voie à suivre consiste à affiner ces outils pour réduire leurs erreurs et à combiner leur compréhension sémantique avec les méthodes traditionnelles afin de créer une image plus complète de l'évolution des logiciels.