Plus le temps passe, et plus l’intelligence artificielle révolutionne des domaines divers et variés. Ces derniers temps, dans le sillage des impressionnants algorithmes de génération de langage, nous avons aussi vu émerger de nouveaux outils spécialisés dans la programmation informatique..
Dans ce domaine par définition codifié à outrance, l’IA affiche un potentiel absolument délirant et extrêmement concret. Elle peut par exemple être utilisée pour rendre les suggestions des systèmes d’autocomplétion extrêmement pertinentes. C’est par exemple ce que fait le Copilot d’OpenAI.
D’autres variantes peuvent même générer des bouts de code fonctionnels à partir d’une simple indication en langage courant. Exactement comme les générateurs d’image de type DALL-E, mais pour du code informatique. C’est notamment le cas de Codex, un autre programme signé OpenAI.
Sans surprise, de très nombreux spécialistes y voient donc le futur de la programmation. Mais comme souvent avec le machine learning, il va falloir manœuvrer délicatement. Car la route qui nous mènera à cette révolution annoncée est parsemée d’ornières techniques, réglementaires et éthiques, et les premiers points de fiction commencent déjà à émerger.
À l’heure actuelle, le cas de figure le plus parlant est certainement celui du Copilot cité en tête d’article. Ce programme développé en partenariat avec Microsoft et GitHub permet de générer spontanément du code en fonction du contexte pour aider un développeur en temps réel, bien au-delà de ce que propose la simple autocomplétion traditionnelle.
Grâce à ses performances bluffantes, il a fait son petit bout de chemin dans l’industrie ; il est désormais utilisé par un nombre croissant de professionnels. Mais il a aussi pris quelques libertés problématiques ; il fait en ce moment l’objet d’une action en justice, car plusieurs développeurs l’accusent d’avoir pillé ouvertement leur travail sans leur en attribuer la paternité (voir notre article).
Une béquille à double tranchant
Et récemment, une étude repérée par TechCrunch a encore prouvé que cet outil n’est pas une panacée. Dans leur papier, des chercheurs rattachés à l’Université de Stanford affirment que les développeurs qui travaillent avec des systèmes génératifs comme Copilot ont plus de chances d’introduire des vulnérabilités dans leurs programmes.
Pour parvenir à cette conclusion, les chercheurs ont recruté 47 développeurs aux profils très différents. Certains étaient n’avaient même pas encore complété leurs études, tandis que d’autres étaient des professionnels chevronnés avec une expérience considérable dans cette industrie.
Ils leur ont ensuite assigné plusieurs problèmes dans trois langages informatiques courants (Python, C, et JavaScript). Tous relevaient de la cybersécurité. À partir de là, le groupe a été scindé en deux. La première moitié était un groupe de contrôle qui a travaillé sans l’aide d’un outil basé sur l’IA. L’autre partie avait pour consigne d’utiliser Codex.
Instinctivement, on pourrait penser que le second groupe s’en serait mieux sorti grâce à la contribution de l’IA… mais c’était en fait tout l’inverse. D’après les chercheurs, ceux qui ont utilisé Codex avaient davantage tendance à produire du code vulnérable ou tout simplement incorrect.
Et il y a une autre tendance statistique encore plus préoccupante qui a émergé. Après la phase de test initiale, les chercheurs ont demandé aux participants s’ils considéraient que leur code était sécurisé. Et l’aide de Codex semble avoir donné un faux sentiment de sécurité à certains développeurs. Par rapport au groupe de contrôle, le second groupe affichait une confiance nettement plus importante dans ses résultats erronés. Oups.
Un problème de vision globale
Les auteurs ont toutefois tenu à préciser que leurs travaux ne remettent absolument pas en question le potentiel de Codex et des autres systèmes de ce genre. Le problème, ce n’est pas qu’ils proposent des extraits de code intrinsèquement dangereux ; c’est plutôt un problème de vision d’ensemble du côté des humains.
Lorsqu’il programme le tout « à la main », le développeur gère l’intégralité du processus de réflexion. Un peu comme un artisan qui construit sa propre maison, il peut ainsi tout construire comme il l’entend. Cela signifie qu’il connaît l’emplacement de chaque vis, chaque rivet et chaque câble sur le bout des doigts.
C’est un avantage considérable lorsqu’il s’agit de s’assurer que tout fonctionne exactement comme prévu. Puisqu’il a lui-même bâti la structure, il sait où sont les points de fragilité; il peut donc et peut donc boucher les trous en conséquence. Mais la donne change radicalement si ce même artisan délègue une partie de sa tâche à un employé. Un programme comme Copilot, est certes volontaire et compétent; mais il n’est pas au courant des enjeux du projet à l’échelle globale.
Certes, il pourra fournir rapidement des éléments que notre artisan n’avait pas l’envie ou la capacité de réaliser lui-même. Mais il y a un revers de la médaille. Pour le cerveau de l’opération, cela implique de fournir un effort supplémentaire. Il doit impérativement vérifier que chaque élément généré par son assistant correspond parfaitement aux attentes. Car ce n’est pas tout de produire des pièces individuelles de bonne qualité. Chacune doit aussi s’emboîter avec la suivante, sous peine de laisser un trou béant dans la structure globale. Une vulnérabilité, en somme.
En résumé : notre artisan doit aussi devenir chef de chantier. Pour travailler avec l’IA, il doit vérifier scrupuleusement sa production. Car si le développeur s’appuie sur cet outil comme un invalide sur sa canne, il perd cette vision d’ensemble si importante dans le processus de développement.
Faire aveuglément confiance à l’IA est très risqué
Ces travaux ne portaient que sur un outil en particulier. Mais ces conclusions valent aussi pour tous les autres systèmes de ce genre. Et pour les auteurs de ces travaux, cela signifie qu’il va falloir redoubler de vigilance. Pas question de se reposer entièrement sur ces algorithmes avant qu’ils arrivent à maturité.
« Les développeurs qui les utilisent pour réaliser des tâches en dehors de leur propre champ d’expertise devraient être préoccupés », explique Neil Perry, doctorant à Stanford et co-auteur de l’étude dans une interview à TechCrunch. « Et ceux qui les utilisent pour accélérer des tâches qu’ils maîtrisent déjà doivent vérifier avec soin leurs productions et la façon dont elles s’intègrent au projet global », martèle-t-il.
Si ces vulnérabilités ont tendance à apparaître, c’est que ces systèmes ne sont pas spécialisés dans la cybersécurité. Ce sont des développeurs plutôt généralistes. Ils sont nourris à partir de milliards de lignes de code disponibles en accès libre.
Megha Srivastava, seconde co-autrice du papier, suggère donc une piste intéressante. Pour elle, les entreprises qui veulent appliquer ces outils à la cybersécurité feraient mieux de changer d’approche. Elles pourraient les entraîner elles-mêmes à partir de code soigneusement trié au préalable. Cela éviterait de leur faire ingurgiter du code provenant des quatre coins du web.
Mais c’est peut-être un peu tard, sachant que plusieurs de ces outils sont déjà dans la nature. Selon les auteurs, le plus important, c’est donc que les développeurs fassent très attention à l’aspect sécuritaire dès qu’ils publient un extrait de code, peu importe sa fonction.
L’importance d’une formation solide
Les auteurs citent un dernier enjeu de ces travaux : l’éducation. En effet, ces outils présentent aussi un intérêt évident pour la formation des jeunes développeurs. Mais ils peuvent aussi donner un sentiment de maîtrise et de compréhension qui peut être trompeur. Il convient donc d’utiliser ces outils avec parcimonie pendant la formation. Car dans le cas contraire, il y a un risque de donner naissance à une génération entière de développeurs aux fondamentaux approximatifs, entièrement dépendants de ces outils et incapables d’avoir un regard critique sur ses productions.
Le message est donc clair : il s’agit d’un outil fantastique, mais il va falloir faire preuve d’humilité et de patience pour exploiter tout son potentiel. « Ces outils de génération de code basés sur l’IA représentent une avancée très excitante, et c’est parfaitement compréhensible que de nombreux développeurs souhaitent les utiliser », conclut Perry. « Mais ils apportent aussi des problèmes dont il faudra tenir compte à l’avenir. Il va falloir continuer d’explorer ces problèmes, et développer de nouvelles techniques pour les résoudre. »
Le texte de l’étude est disponible ici.
🟣 Pour ne manquer aucune news sur le Journal du Geek, abonnez-vous sur Google Actualités. Et si vous nous adorez, on a une newsletter tous les matins.
L’IA codera comme les programmes qu’on lui fait ingurgiter. D’où l’importance des bonnes pratiques de codage et des commentaires. Vivement qu’on avance !