Ma façon d’utiliser l’« IA »

• Au cours de l’année écoulée, en interagissant chaque semaine pendant plusieurs heures avec des grands modèles de langage, j’ai été constamment impressionné par leur capacité à résoudre des tâches de plus en plus difficiles
  • En conséquence, ma vitesse d’écriture de code a augmenté d’au moins 50 % dans mes projets de recherche comme dans mes projets personnels
• Les personnes qui parlent en ligne de l’utilité des LLM sont pour la plupart soit excessivement optimistes, soit excessivement pessimistes
• Plutôt que de débattre de l’avenir, je veux présenter 50 exemples de conversations utilisées au cours de l’année écoulée pour améliorer mes capacités de recherche et m’aider dans mes projets de programmation grâce aux LLM
• Mes usages des LLM
  • Construire une application web complète avec des technologies que je n’avais jamais utilisées auparavant
  • Apprendre à utiliser divers frameworks sans les avoir essayés moi-même au préalable
  • Convertir des dizaines de programmes en C ou en Rust afin d’améliorer les performances d’un facteur de 10 à 100
  • Réduire de larges bases de code pour simplifier fortement des projets
  • Écrire le code des premières expériences pour presque tous mes articles de recherche au cours de l’année passée
  • Automatiser presque toutes les tâches monotones ou les scripts ponctuels
  • Remplacer presque entièrement les recherches web pour l’installation et la configuration de nouveaux packages ou projets
  • Remplacer environ 50 % des recherches web pour le débogage des messages d’erreur
• En les classant, cela se résume à deux catégories
  1. Aide à l’apprentissage : cela me permet de faire des choses qui auraient auparavant été difficiles
  2. Automatisation des tâches ennuyeuses : cela me permet de me concentrer sur ce que je fais le mieux et de résoudre des problèmes difficiles
• Le plus important, c’est qu’il s’agit de cas où j’ai réellement obtenu de l’aide grâce aux LLM
  • Ils ne servent pas à montrer des capacités impressionnantes, mais viennent de mes besoins concrets pour accomplir un vrai travail

Nuance

• Une chose qu’Internet gère mal, c’est la nuance. Je ne vais pas affirmer que les LLM d’aujourd’hui domineront le monde, ni parler de ce que les modèles du futur pourront faire
  • Je vais seulement discuter de la question de savoir si les modèles actuels me sont utiles
• On peut se demander pourquoi j’écris un texte pour justifier l’utilité des modèles de langage. Mais dans le milieu universitaire, dans le logiciel et dans les médias, il semble y avoir beaucoup de gens qui déclarent largement que les LLM n’apportent absolument rien, qu’ils ne sont qu’un nouveau cycle de hype, et qu’ils disparaîtront dans quelques années sans avoir eu le moindre impact sur le monde
  • Je vais soutenir qu’ils ont tort, parce que les LLM actuels sont déjà utiles
• À l’inverse, certains affirment aussi que les modèles actuels peuvent remplacer tous les programmeurs et que les gens ne devraient plus apprendre à programmer
  • Je ne cherche pas explicitement à réfuter leur thèse
• Je comprends parfaitement que les LLM puissent avoir de nombreux effets néfastes. Je parle de désinformation, d’abus, de surveillance, de remplacement d’emplois, etc. Je prévois bientôt d’écrire un texte sur mes réflexions concernant les effets nuisibles des LLM. Mais c’est une question distincte de celle de savoir si les modèles de langage peuvent être utiles
• Je comprends très bien pourquoi on pourrait ne pas vouloir utiliser les LLM, parce qu’ils hallucinent, ressassent des faits et manquent de robustesse, donc peuvent échouer. Mais ce texte ne porte pas là-dessus
  • Je pense que les modèles peuvent être utiles malgré ces échecs
• Le caractère éthique de l’entraînement de ces modèles est sujet à caution. On peut penser aux données de personnes utilisées sans leur permission, ou à celles et ceux payés au rabais pour entraîner explicitement ces modèles. Je suis d’accord pour dire que c’est un problème
  • Mais ce texte ne porte pas là-dessus
• Comme je l’ai dit à plusieurs reprises, ce texte parlera uniquement de la question de savoir si les modèles qui existent actuellement sont utiles

Mon parcours

• Je ne suis généralement pas quelqu’un qui croit facilement à quoi que ce soit. Il y a dix ans, dans la communauté sécurité, j’ai vu de près la hype autour de la crypto, mais j’ai complètement évité d’écrire des articles sur la blockchain. Je n’ai jamais possédé de bitcoin. Je suis sceptique face à toutes les affirmations
• Quand quelqu’un m’a dit pour la première fois que cette technologie d’IA serait très utile et changerait profondément la manière de travailler au quotidien, ma réaction a été : « Je ne le croirai que lorsque je l’aurai vu de mes propres yeux »
• Je suis chercheur en sécurité. Au cours des dix dernières années, mon travail quotidien a consisté à montrer toutes les manières spectaculaires dont les modèles d’IA échouent face à des environnements sur lesquels ils n’ont pas été entraînés. J’ai montré qu’en perturbant légèrement l’entrée de modèles de machine learning, on pouvait produire des sorties gravement erronées, ou que la plupart des modèles de machine learning mémorisent certains exemples précis de leur jeu de données d’entraînement et les répètent à l’usage. Je comprends parfaitement les limites de ces systèmes
• Malgré cela, j’affirme que les grands modèles de langage actuels ont produit le plus grand gain de productivité depuis la création d’Internet. Si, aujourd’hui, pour une tâche de programmation choisie au hasard, je devais choisir entre avoir accès à Internet ou à un modèle de langage de pointe, je choisirais le modèle de langage dans plus de la moitié des cas

[ Comment j’utilise les LLM ]

Construire des applications complètes pour moi

• L’an dernier, j’ai créé un quiz pour tester à quel point GPT-4 pouvait bien prédire la capacité à résoudre une poignée de tâches. Ce quiz a eu pas mal de succès et a dépassé les dix millions de pages vues.
• J’ai demandé à GPT-4 d’écrire l’essentiel de la première version de cette application. Je m’y suis pris en commençant par demander la structure de base de l’application, puis en construisant lentement différentes fonctionnalités au fil d’une série de questions
• Cette conversation représente au total 30 000 mots et exploitait pleinement les capacités du modèle GPT-4 le plus récent à l’époque
  • [J’omets les prompts et les réponses réels]
• Dans ma conversation avec GPT-4, j’ai formulé mes demandes de différentes manières
  • Cela allait de messages décrivant en toutes lettres ce que je voulais et demandant au modèle l’implémentation complète, à des messages demandant des modifications précises ("Au lieu de comparer au score moyen, pouvez-vous donner le percentile en utilisant un KDE ?")
  • Cela incluait aussi des messages posant des questions complètement incomplètes en copiant-collant un message d’erreur (par ex. "Plotting: numpy.linalg.LinAlgError: singular matrix"), ou demandant une simple réponse ponctuelle ("Comment ajouter à une page un iframe en JavaScript avec un contenu chargé depuis une chaîne de caractères ?")
• Pourquoi les modèles de langage sont efficaces
  • Cette approche fonctionne parce que les modèles de langage résolvent bien les choses que d’autres personnes ont déjà résolues auparavant
  • 99 % de ce quiz n’était rien d’autre que du HTML basique avec un backend de serveur web Python que quelqu’un d’autre aurait très bien pu écrire
• Si ce quiz était intéressant et apprécié, ce n’était pas à cause de la technologie derrière, mais à cause de son contenu. Et dès lors que toutes les parties ennuyeuses sont automatisées, il devient très facile de créer un quiz
• Je suis convaincu que, sans l’aide des modèles de langage, je n’aurais probablement pas créé ce quiz
  • Parce que je n’avais aucun intérêt à consacrer du temps à écrire toute l’application web depuis zéro
  • Et pourtant, je suis quelqu’un qui sait programmer !
• Je pense que même les modèles actuels suffisent déjà à permettre à la grande majorité des gens de réaliser des tâches significatives qu’ils n’auraient auparavant jamais pu résoudre, simplement en demandant une solution
• Je présenterai plus loin quelques autres exemples où des modèles ont écrit des applications entières pour moi, et je préciserai clairement lors de leur publication qu’elles ont été créées avec l’aide de modèles de langage

Jouer le rôle de tuteur pour de nouvelles technologies

• Autrefois, j’essayais de suivre les nouveaux frameworks, mais le temps dont dispose une personne est limité.
• Dans mon métier, je passe la majeure partie de mon temps à suivre les avancées les plus récentes de la recherche, pas l’évolution des derniers frameworks JavaScript.
• Quand je lance un nouveau projet en dehors de mon domaine de recherche précis, j’ai généralement deux options :
  • la première consiste à utiliser ce que je connais,
  • la seconde à apprendre une nouvelle méthode — généralement meilleure.
• C’est là que les modèles de langage sont utiles. La plupart des nouveaux frameworks ou outils comme Docker, Flexbox ou React ne sont pas nouveaux pour tout le monde. Il existe dans le monde entier des dizaines, voire des centaines de milliers de personnes qui les comprennent à fond. Il en va de même pour les modèles de langage actuels.
• Au lieu de lire un tutoriel statique écrit pour un lecteur donné et visant un objectif précis, on peut interagir avec un modèle de langage pour apprendre ce dont on a besoin afin de résoudre sa tâche.
• En début d’année, en construisant un framework d’évaluation de LLM, je voulais exécuter du code généré par des LLM dans un environnement restreint.
  • Docker était l’outil parfait pour ça, mais je ne l’avais jamais utilisé auparavant.
• Utiliser Docker n’était pas l’objectif du projet, c’était simplement un outil nécessaire pour atteindre cet objectif.
  • Je voulais seulement comprendre 10 % de Docker afin d’avoir la certitude de l’utiliser en toute sécurité, de la manière la plus basique possible.
• Dans les années 1990, il aurait fallu acheter un livre sur l’utilisation de Docker en partant des principes de base, lire les premiers chapitres, puis en sauter une partie pour finir par comprendre comment faire ce qu’on voulait.
  • Ces dix dernières années, cela s’est amélioré : on cherche des tutoriels en ligne expliquant comment utiliser Docker, on les suit, puis on cherche les messages d’erreur pour voir si d’autres ont eu le même problème.
• Mais aujourd’hui, il suffit de demander à un modèle de langage de vous apprendre Docker.
  • Après avoir configuré et lancé Docker, je me suis rendu compte qu’il y avait des problèmes de permissions sous Linux. Je voulais les résoudre, donc j’ai demandé de l’aide au modèle.
  • C’est ainsi que j’ai découvert Podman, puis j’ai demandé au modèle de réécrire du code spécifique à Docker en une version équivalente pour Podman.
  • Et quand j’ai voulu comprendre comment passer le GPU de l’hôte dans un conteneur Docker, je lui ai aussi demandé.

Démarrer un nouveau projet

• Quand j’étais enfant, mon premier langage de programmation était Java. J’adorais vraiment programmer, mais je détestais profondément me retrouver face à une page vide pour un nouveau projet. Surtout en Java !
  • Rien que compiler un programme Hello World était difficile : il fallait comprendre à quoi servait public static void main string args, où placer les parenthèses, quelles lettres devaient de nouveau être en majuscule, et pourquoi il y avait des accolades et des crochets partout.
• Alors j’ai fait ce que n’importe quel enfant aurait fait : j’ai demandé à mon père de le faire à ma place.
• Vingt ans plus tard, je déteste toujours autant démarrer un nouveau projet avec un framework que je ne connais pas bien.
  • Cela prend beaucoup trop de temps d’éliminer le boilerplate, et je ne comprends pas vraiment ce que je suis en train de faire.
• Par exemple, récemment, j’ai voulu essayer d’écrire du code CUDA pour benchmarker sur GPU les performances d’une recherche gloutonne naïve, en comparaison avec l’implémentation CPU efficace et optimisée de quelqu’un d’autre.
• Mais je ne savais pas comment écrire un programme CUDA.
  • Je sais écrire en C, et je comprends comment fonctionnent les GPU, les kernels, l’agencement mémoire, etc.
  • En revanche, je ne savais pas comment écrire concrètement le code qui envoie du travail au GPU.
  • J’ai donc demandé au modèle d’écrire une première version du programme CUDA.
  • Était-ce parfait ? Absolument pas ! Mais c’était un point de départ. Et c’est exactement ce que je voulais.
• On voit bien ici qu’une grande partie du code est erronée.
  • En réalité, ce n’est pas du tout un problème.
  • Parce que je ne cherche pas une solution parfaite, mais un point de départ.
  • Si les modèles s’améliorent encore à l’avenir, ce sera formidable.
  • Mais même avec ce qu’on a aujourd’hui, c’est déjà d’une grande aide.
• Dans un tout autre registre, j’utilise un Raspberry Pi Pico W pour un autre projet personnel sur lequel je travaille chez moi.
  • C’était la première fois que j’en utilisais un.
  • Je voulais notamment faire du réseau avec.
  • Bien sûr, on peut sûrement trouver en ligne un bon tutoriel expliquant comment faire ce que je voulais.
  • Mais ces derniers temps, quand on cherche sur Internet, les cinq premiers résultats sont souvent juste des fermes à contenu remplies de code bogué datant de 2008, vaguement mises à jour pour le SEO et qui ne fonctionnent toujours pas.
• J’ai donc demandé à la place à un modèle de langage de m’apprendre à faire ce que je voulais.
  • J’avais déjà travaillé avec des microcontrôleurs auparavant, donc je comprenais à peu près leur fonctionnement.
  • Mais je n’avais jamais travaillé avec un Pico W.
  • Il me suffisait de disposer de quelque chose pour m’aider à démarrer avec toutes les dépendances ; ensuite, je pouvais me débrouiller.
• Le premier programme « hello world » que j’écris toujours pour un nouveau microcontrôleur, c’est faire clignoter une LED.
  • Cela permet de tester si on peut compiler et téléverser du code sur l’appareil, si toutes les broches sont correctement configurées et, plus globalement, si on maîtrise les bases.
  • Il suffit donc de demander un programme qui fait simplement clignoter la LED. (Encore une fois, est-ce que cela existe sur Internet ? Très probablement. Mais dans ce cas, il faudrait que je le cherche moi-même.)
• Une fois ce code exécuté, je sais quoi faire à partir de là.
  • Je sais comment fonctionne Python (qu’on le croie ou non !).
  • Donc il me suffit de terminer la partie spéciale MicroPython, puis je peux reprendre l’édition directement à partir de là.
• Et quand je tombe sur un autre problème nécessitant un traitement particulier, il me suffit de demander de l’aide au modèle.
  • Par exemple, ici, la suite a consisté à demander au modèle d’écrire un script de connexion au Wi‑Fi.
• Et quand je me retrouve de nouveau bloqué, par exemple parce qu’il faut se connecter à un serveur MQTT, je redemande simplement de l’aide au modèle.
• Je fais désormais cela en permanence. Même l’exemple au tout début de cette section n’est pas hypothétique.
  • Je demande comment utiliser Flexbox, parce que ma nouvelle manière d’apprendre la mise en page HTML consiste à utiliser des div au lieu de tableaux.

Simplifier du code

• En tant que chercheur en sécurité, je me retrouve souvent à recevoir un nouveau dépôt contenant des milliers de lignes de projet de recherche écrit par quelqu’un d’autre, puis à devoir comprendre comment cela fonctionne pour pouvoir l’attaquer.
  • Si tout le monde écrivait du code propre, ce ne serait pas si difficile, mais le monde dans lequel nous vivons n’est pas comme ça.
  • Les chercheurs ne sont pas incités à publier du code propre.
  • Du coup, les gens livrent souvent du code pourri tant qu’il fonctionne. (Moi aussi.)
• Je ne peux pas partager ici d’exemples liés à la recherche, mais je peux donner un exemple tiré d’un projet personnel sur lequel je travaille.
  • J’ai une obsession peu saine pour le Jeu de la vie de Conway.
  • Récemment, je cherchais un moyen rapide d’évaluer certains motifs du Jeu de la vie en Python.
  • Il existe pour cela un excellent outil en C++ appelé golly, mais je n’avais pas envie de réécrire mon code Python en C++.
• golly propose un outil CLI qui fait ce que je voulais.
  • Tout ce dont j’avais besoin, c’était de savoir comment l’appeler correctement.
  • La première étape a donc consisté à prendre du code C++ prenant en charge environ 50 options de ligne de commande différentes, et à le réduire pour qu’il fasse exactement la seule chose dont j’avais besoin.
  • J’ai donc déversé les 500 lignes de C++ dans le LLM et je lui ai demandé un fichier plus court accomplissant la même tâche.
• Et alors, qu’est-ce que ça a donné ? Cela a parfaitement fonctionné.
  • Ensuite, j’ai demandé un wrapper Python autour du code C++. Là aussi, ça a très bien marché.
• C’est typiquement le genre de chose si pénible que l’auteur lui-même ne l’aurait jamais faite.
  • Mais comme on peut maintenant simplement le demander, je me suis retrouvé avec quelque chose 100 fois plus rapide que le code Python d’origine.
• Je fais ce genre de chose assez souvent. J’ai un autre exemple qui fait exactement la même chose en Python.
• Aucune de ces tâches n’est difficile.
  • Mais à chaque fois que je fais cela, je gagne un temps considérable.
  • Et c’est pour cela, je pense, qu’un des aspects les plus impressionnants des LLM aujourd’hui réside là.
  • Ce n’est pas spectaculaire, et on ne gagne pas beaucoup de points Internet en disant « voici la manière ennuyeuse dont j’utilise les LLM pour me simplifier la vie », mais c’est bien ce qui se passe dans la réalité.

Automatiser les tâches monotones

• Il y a beaucoup de tâches qui ne demandent pas de réflexion, qui sont ennuyeuses, mais qu’il faut faire
• L’une des principales raisons pour lesquelles on remet un travail à plus tard, c’est qu’on sait que l’accomplir sera agaçant et pénible
  • Les LLM réduisent énormément cette douleur, et comme on sait qu’il ne reste qu’à résoudre les problèmes intéressants, il devient bien plus facile de se mettre à quelque chose
  • Ici, je vais examiner des problèmes tout à fait ordinaires que j’ai résolus en demandant à un LLM
• Par exemple, récemment, j’ai dû désassembler un programme Python écrit pour Python 3.9
  • La plupart des désassembleurs Python ne fonctionnaient qu’avec des versions antérieures à Python 3.7 et ne s’exécutaient pas sur des binaires 3.9
• Le désassemblage n’est pas vraiment une tâche difficile. L’essentiel consiste à reconstituer le flux de contrôle en suivant les goto sans faire d’erreurs
  • Au lieu de passer du temps à convertir manuellement des milliers d’op-codes pour des centaines de lignes de code, j’ai demandé au LLM de le faire à ma place
  • Et il l’a vraiment très bien fait ! Bien, bien mieux que je ne l’aurais cru possible
• Un autre exemple, c’est quand il faut prendre des données non structurées et les formater dans un format structuré
  • Par exemple, en travaillant sur un projet, j’avais besoin d’une liste de titres de livres avec les noms des auteurs
  • J’ai donc trouvé des données en ligne dans un format non structuré et j’ai demandé au LLM de les formater
• Ou encore, récemment, en écrivant un billet de blog sur la manière dont j’ai contourné une défense, je voulais montrer le diff complet du code que j’avais dû modifier
  • J’ai donc collé (1) le diff et (2) un exemple précédent sur la façon d’HTMLifier un diff, puis j’ai demandé au LLM de me fournir ce diff dans le format précédent
• Autre exemple : dans le cadre de mon travail, je dois souvent générer des citations pour des ressources que j’utilise régulièrement
  • Google Scholar le rend facile pour les articles : il suffit de copier-coller la citation
  • Mais citer une page web est un peu pénible
  • Dernièrement, je demande souvent au LLM de générer la citation. (Pour être clair, je vérifie que c’est exact !)
• Je pourrais encore donner au moins 100 exemples de ce genre. Mais je pense que l’idée est claire
• Je comprends tout à fait qu’on puisse regarder cela et dire : « C’est tout ?? »
  • Mais il faut se rappeler qu’il y a à peine 5 ans, ils arrivaient tout juste à produire des paragraphes cohérents, pas à résoudre un problème entier

Faire de tous les utilisateurs des « power users »

• Si vous avez déjà vu quelqu’un de bien moins à l’aise que vous utiliser un outil, cela peut être assez pénible
  • Vous pouvez les voir passer des minutes, parfois des heures, sur des tâches qu’on pourrait automatiser avec un usage astucieux de macros ou d’applications parallèles
• Mais apprendre les formules magiques nécessaires pour faire cela prend du temps et c’est difficile
• Par exemple, récemment, j’ai voulu écrire un programme Python qui gère les entrées clavier d’un clavier Apple Lisa
  • J’ai trouvé en ligne quelqu’un qui avait écrit quelque chose en C pour faire cela, avec beaucoup de lignes comme #define KEYNAME key_code
  • Je voulais convertir cela en dictionnaire Python associant les codes entiers aux chaînes correspondantes
• J’utilise Emacs. Je sais comment résoudre ce problème dans Emacs. Ce ne serait probablement pas très difficile. Voici la capture des principales touches que je viens d’enregistrer pour produire cet effet :
  C-h C-s #def [enter] M-f [delete] C-d M-f C-[space] M-f C-w C-a C-y : " M-f ", C-g C-] } C-[ {
• Pour moi, c’est presque naturel, mais il m’a fallu passer plus de la moitié de ma vie à me familiariser suffisamment avec Emacs pour que cela le devienne. Mais maintenant, si un LLM est connecté à l’éditeur, que faut-il taper ?
  C-h C-h rewrite these #defines to a dictionary of {keycode: string, ...}
• Et soudain, le texte se réécrit sous mes yeux !
• Dans ce genre de cas, je pense que l’utilité potentielle des LLM est plus grande pour les non-experts que pour les experts
  • Le modèle élève le niveau de tout le monde, et si l’on ne pouvait auparavant rien faire du tout, on peut soudain faire beaucoup plus

Les utiliser comme référence d’API

• Les vrais programmeurs lisent le manuel de référence quand ils veulent savoir comment fonctionne un outil
  • Mais je suis un programmeur paresseux, alors je préfère qu’on me serve simplement la réponse
  • Du coup, maintenant, je demande au modèle de langage
• Quand je montre ce genre d’exemples, certaines personnes réagissent de manière défensive en disant : « Le LLM n’a rien fait que vous ne puissiez pas déjà faire avec les outils que vous avez ! »
  • Et elles ont raison
  • Mais il n’y a rien qu’un moteur de recherche puisse faire qu’on ne puisse faire avec un livre physique, ni rien qu’un livre physique puisse faire qu’on ne puisse faire en lisant le code source
• Mais chacun de ces outils rend les choses plus faciles que le précédent
  • Et quand quelque chose devient plus facile, on le fait plus souvent, et d’une manière qualitativement différente
• Exemples, avec les prompts
  • Je demande « quel $ en Bash donne tous les arguments restants » et j’obtiens une réponse. (Juste après, une autre question suit : « comment l’utilise-t-on » !)
  • Ou, quand je veux savoir comment mettre du texte en rouge en LaTeX, je ne cherche plus et ne lis plus la documentation : je demande au modèle
  • Et je fais pareil quand je veux savoir à quelles commandes LLDB correspondent différentes commandes GDB
  • Ou quand je veux comprendre comment fonctionne une commande find
  • Ou comment utiliser lpr
  • Ou comment re-lier des commandes LaTeX
• En réalité, c’est l’une des façons dont j’utilise le plus souvent les LLM
  • La seule raison pour laquelle je ne peux pas enchaîner des milliers d’exemples de plus, c’est que j’ai des outils intégrés dans Emacs et dans le shell pour interroger un LLM
  • Donc, dans 90 % des cas, quand je veux faire l’une de ces choses, je n’ai même pas besoin de quitter l’éditeur

Rechercher des choses difficiles à trouver

• Rechercher du contenu sur Internet était autrefois une compétence difficile à apprendre
  • Quels mots précis veut-on inclure dans la requête ? Faut-il les mettre au pluriel ? Au singulier ? Au passé ?
  • Quels mots ne veut-on pas voir apparaître sur la page ? Veut-on X AND Y, ou bien X OR Y ?
• Ce n’est plus le cas
  • Je ne me souviens plus de la dernière fois où j’ai rédigé une requête avec OR sur Google
  • Je ne me souviens plus non plus de la dernière fois où j’ai utilisé un signe moins (-) pour éliminer un sous-ensemble de résultats
    = Aujourd’hui, dans la plupart des cas, il suffit d’écrire ce qu’on cherche et le moteur de recherche le trouve.
• Cependant, les moteurs de recherche ne fonctionnent toujours pas avec des requêtes 100 % en langage naturel
  • J’ai toujours l’impression de jouer à une sorte de Reverse-Jeopardy, en essayant d’utiliser les mots-clés qui apparaîtraient dans la réponse plutôt que dans la question
  • C’est une compétence que nous avons presque tous apprise puis oubliée
• Les modèles de langage sont aujourd’hui simplement meilleurs pour certaines tâches simples, et leur nombre augmente avec le temps
  • Il suffit de taper « donc + correspond à add, mais alors ~ c’est quoi ? » et on vous répond que c’est inv
• C’est le genre de chose qu’il est très difficile de chercher avec un moteur de recherche classique
  • Je sais qu’il existe une manière de trouver la réponse
  • Je pourrais probablement taper quelque chose comme « python documentation metaclass add », puis chercher ~ dans la page pour obtenir la réponse
  • Mais poser directement la question qu’on a à un LLM fonctionne aussi
• Cela ne fait gagner que quelques secondes à chaque fois, mais quand on est en train de résoudre un problème de code et qu’on essaie déjà de gérer un million de choses à la fois, le simple fait de déverser le problème à résoudre et d’obtenir une réponse cohérente est remarquable
• Cela ne veut pas dire qu’ils sont parfaits pour ça aujourd’hui
  • Les modèles de langage ne savent quelque chose que si cette information a été répétée suffisamment souvent en ligne
  • Et comme « suffisamment souvent » varie selon le modèle, il faut encore dépenser quelques cycles mentaux à se demander s’il vaut mieux demander au modèle ou à Internet
  • Mais les modèles vont continuer à s’améliorer
• Ou bien, à chaque fois qu’un conflit aléatoire se produit, je vais juste déverser ce que je vois dans le modèle et lui demander une explication
  • Ici, taper « Remote wildcard transfer issue » revient à faire exactement cela
• Dans un tout autre registre, l’an dernier, en écrivant un billet de blog, je voulais mettre la première lettre du premier mot en grand et faire s’enrouler le reste du texte autour
  • Cela s’appelle une lettrine. Mais je ne le savais pas
  • Je connaissais simplement l’effet que je voulais, alors j’ai demandé au modèle de langage « je veux que ça ressemble à un joli livre avec le texte qui s’enroule autour du O », et il m’a donné exactement ce que je voulais
  • Cela aussi entre dans la catégorie des choses que je n’ai faites que grâce aux LLM
  • Je n’aurais probablement pas jugé utile de passer beaucoup de temps à comprendre comment faire
  • Mais comme je pouvais le demander au modèle, je l’ai fait, et cela a rendu mon billet un peu plus joli

Résoudre des tâches ponctuelles

• Il y a deux sortes de programmes
  • D’abord, il y a les programmes qu’on veut bien faire. Ils vont exister pendant un certain temps, il faudra les maintenir pendant des années, donc la propreté du code compte
  • Ensuite, il y a les programmes qui existent pendant 25 secondes. Ils aident à accomplir une tâche puis sont immédiatement jetés
• Quand la qualité du code m’importe peu et que le programme est totalement autonome, je les écris désormais presque entièrement avec des LLM
• Avertissement : dans la plupart de ces cas aussi, on pourrait répondre « c’est tout ? »
  • Mais comme je l’ai dit plus haut, le temps qu’on peut investir dans un projet donné au cours d’une journée est limité
  • Et si je peux économiser du temps et de l’énergie mentale sur l’écriture d’un programme que je ne réutiliserai jamais, je le ferai
• L’exemple le plus courant est probablement l’aide à la génération de graphiques pour visualiser des données produites par une expérience de recherche
  • J’ai des dizaines d’exemples comme ça. Peut-être plus proche de 100 que de 0. Ils se ressemblent tous fondamentalement, donc je n’en mets qu’un ici
• Un autre exemple similaire, c’est quand on a des données dans un format et qu’on veut les convertir dans un autre
  • En général, c’est quelque chose qu’on ne fait qu’une seule fois, et une fois terminé, on jette le script obtenu
• Si le script souhaité est assez simple, je demande souvent au LLM d’écrire l’ensemble
  • Par exemple, ici, je lui ai demandé d’écrire un script qui lit un article à voix haute, afin de vérifier qu’il n’y a pas de problèmes de grammaire absurdes
• La plupart du temps, quand je ne sais pas très bien ce que je veux, je commence par demander au modèle du code initial, puis j’itère à partir de là
  • Par exemple, ici, il y a une tâche ponctuelle où il faut traiter rapidement des données
  • En 2022, j’aurais passé deux minutes à écrire ça en Python, puis attendu qu’il tourne pendant des heures puisqu’il ne devait s’exécuter qu’une fois
  • L’optimiser aurait pris plus de temps que l’exécution du programme Python
  • Mais maintenant ? Je suis à peu près certain que je passerais les mêmes deux minutes à demander du code Rust pour traiter mes données
• Ou encore, il y a un autre exemple où je demande au modèle de télécharger un dataset et d’effectuer un traitement initial
  • Est-ce que ce serait facile à faire moi-même ? Probablement
  • Mais ce n’est pas le genre de tâche auquel j’ai envie de penser
  • J’ai envie de réfléchir à la recherche que je veux mener sur ce dataset
  • Supprimer les distractions a une valeur bien supérieure aux quelques minutes économisées
• Une autre fois, j’écrivais un programme pour pouvoir imprimer en 3D une image pixellisée sous forme de petits cubes
  • Pour cela, je voulais convertir un PNG en fichier STL, mais ce n’était pas l’objet du projet
  • C’était juste une étape intermédiaire nécessaire. J’ai donc demandé au LLM de régler ça
• Dans un autre cas, récemment, je voulais configurer un nouveau projet avec Docker Compose
  • J’avais des problèmes, je voulais simplement que ça fonctionne quoi qu’il arrive, et je verrais plus tard ce qui n’allait pas
  • J’ai donc fini par faire plusieurs allers-retours en copiant simplement les messages d’erreur un par un, jusqu’à obtenir une solution qui marche.
• Souvent aussi, je me surprends à commencer par demander une solution complète, puis à demander des indices sur la manière de la modifier
  • Dans cette conversation, par exemple, je commence par demander un programme qui parse du HTML, puis je demande à partir de là une référence API ou des pistes pour l’améliorer
• Une autre fois, je voulais suivre la quantité de mémoire et de CPU utilisée par mon ordinateur au fil du temps
  • J’aurais pu passer quelques minutes à trouver les bonnes commandes et à les assembler dans un script qui fasse ce que je voulais, mais j’ai simplement demandé au modèle de le faire à ma place
• Récemment, je bricolais un peu d’électronique : j’avais un programme en C qui tournait sur Arduino, mais je voulais le faire fonctionner sur un Raspberry Pi Pico en MicroPython
  • Il n’y a rien d’intéressant dans ce processus de conversion. Il faut juste qu’il soit fait
  • Donc, au lieu de le faire moi-même, j’ai demandé au modèle de le faire à ma place
• Pour un autre projet, j’avais besoin de classer certaines images avec un joli modèle de ML dans une boucle interactive
  • J’aurais pu l’écrire moi-même, mais j’aurais aussi bien pu demander au modèle de le faire à ma place

M’expliquer quelque chose

• Je me suis récemment mis à m’intéresser à l’électronique
  • Quand j’étais plus jeune, je bricolais avec des appareils électroniques et j’ai suivi quelques cours à l’université
  • Mais maintenant que j’essaie de faire de vrais projets, il est difficile d’avancer à cause des milliers de petites choses que je ne connais pas
• Je pourrais lire un livre d’électronique pratique, et sans doute acquérir ainsi une vraie compréhension du sujet, mais je n’ai pas envie de passer mon temps comme si j’étais en train d’étudier
  • La moitié de la raison pour laquelle je fais de l’électronique, c’est pour faire une pause après avoir passé toute la journée à lire et écrire des articles
• Ce qui est bien avec les LLM ici, c’est que, même s’ils ne sont pas aussi érudits que la personne la plus compétente au monde, il y a des milliers, voire des millions de gens qui connaissent la réponse aux questions d’électronique que je peux me poser
  • Donc le modèle de langage connaît probablement lui aussi la réponse
  • Et il est toujours prêt à me donner une réponse à n’importe quelle question, ce qui me permet de profiter de la partie amusante sans me débattre avec les détails
  • Bien sûr, je pourrais probablement obtenir la réponse en cherchant sur Internet avec un peu plus d’effort, mais après une journée passée à travailler sur du code de recherche complexe, le confort de simplement demander au modèle est très appréciable
• Voici donc une collection d’exemples où j’ai posé au modèle de langage des questions élémentaires sur le fonctionnement de l’électronique
  • Est-ce que ces réponses sont parfaites ? Qui sait
  • Mais est-ce mieux que de ne rien savoir du tout ?
• (Ce texte devient assez long, et à ce stade je suis probablement autant fatigué de l’écrire que vous de le lire. Donc je vais simplement laisser ces exemples ici, sans plus d’explications.)
  • Questions de base sur la conception de PCB
  • Questions de base sur la soudure
  • Questions de base sur les condensateurs
  • Questions de base sur les LED
  • Questions de base sur les disquettes
• Je pourrais continuer, mais je pense que vous avez compris l’idée

Résoudre des tâches à partir de solutions déjà connues

• Presque tout a déjà été fait par quelqu’un
  • Il est très rare que ce qu’on veuille faire soit réellement nouveau
  • Et les modèles de langage sont très doués pour proposer des solutions à des choses qu’ils ont déjà vues
• Dans un projet récent, j’avais besoin d’améliorer les performances d’un morceau de code Python
  • (1) J’ai demandé au LLM de le réécrire en C, puis
  • (2) je lui ai demandé de construire une interface permettant d’appeler le code C depuis Python
• Ces tâches ne sont pas « difficiles »
  • Convertir du Python en C me prendrait sans doute 1 à 2 heures
  • Et même si je ne sais pas exactement comment fonctionne l’API Python->C, je pourrais le découvrir en lisant la documentation
  • Mais si je devais le faire moi-même, je ne le ferais probablement jamais
  • Comme ce n’est pas sur le chemin critique, il vaut mieux attendre et laisser l’ordinateur résoudre le problème plutôt que passer du temps à accélérer des choses qu’on n’a pas besoin d’exécuter souvent
• Mais pour des programmes simples, convertir du Python en C est (en grande partie) un processus mécanique, et il existe exactement une convention standard d’appel Python->C
  • Donc je vais simplement demander au LLM de le faire à ma place.
• Depuis, je pars du principe que c’est quelque chose que je peux faire, et en gros, chaque fois que j’ai besoin d’un bout de code rapide, je décris ce que je veux en Python et je demande du C optimisé
• D’autres fois, je fais la même chose, mais je demande du Rust plutôt que du C si j’ai l’impression qu’il me sera plus facile d’évaluer la justesse du résultat Rust par comparaison avec le résultat C
• Autre exemple : paralléliser une fonction Python avec une bibliothèque de multiprocessing n’est pas difficile
  • Il faut écrire un peu de code boilerplate, et ensuite ça se met globalement en place tout seul
  • Mais écrire ce code est un peu pénible et détourne de la vraie tâche qu’on veut accomplir
  • Maintenant, chaque fois que j’en ai besoin, je demande simplement au LLM de le faire à ma place
• Ou bien, souvent, quand je teste une API, je commence par écrire une requête curl pour faire tourner les choses au départ
  • Et une fois que ça marche et que je veux répéter l’opération de façon programmatique, je convertis ça en Python
  • Avant, je faisais souvent quelque chose de vraiment moche en appelant simplement os.popen() pour exécuter la commande curl, ce qui n’est pas une bonne solution
  • Il vaudrait mieux convertir ça avec la bibliothèque Python requests. Mais comme cela prend du temps, je ne le faisais pas
  • Maintenant, il me suffit de demander au LLM de le faire à ma place, et j’obtiens plus vite un programme plus propre
• Pour un projet futur dont je parlerai probablement ici, j’avais besoin de savoir quels types de choses les gens utilisent avec de simples émetteurs radio
  • Et comme ce que je veux vraiment, c’est une réponse d’humain médian, le LLM est un choix parfait !

Corriger les erreurs courantes

• Avant 2022, quand un message d’erreur apparaissait dans un outil ou une bibliothèque connue, je suivais en gros ce protocole :
  1. Copier le message d’erreur
  2. Le coller dans Google
  3. Cliquer sur le premier lien Stack Overflow
  4. Vérifier que la question correspond bien à ce que je veux demander ; sinon, revenir à l’étape 2
  5. Appliquer à mon travail la solution la mieux classée
  6. Si ça ne marche pas, retourner à l’étape 2, modifier les termes de recherche, prier, etc.
• Pour être honnête, les outils qui cassent se trouvent généralement à cinq étapes de la tâche qu’on essaie réellement de résoudre, et je me moque complètement de savoir comment ils fonctionnent : je veux juste qu’ils marchent
• Et en 2024, à quoi ça ressemble ?
  1. Copier le message d’erreur
  2. Demander au LLM : « Comment corriger cette erreur ? [erreur] »
  3. Appliquer la solution étape par étape proposée par le LLM
  4. Si ça ne marche pas, lui dire : « Ça n’a pas marché »
• Je n’ai pas de copie à montrer comme exemple ici. (Ou alors je n’ai pas réussi à en retrouver en cherchant pendant une heure.) Mais il y a en fait une bonne raison à cela : j’ai intégré ce processus directement dans mon workflow
  • J’utilise Emacs
  • J’ai configuré mon environnement pour que, chaque fois qu’un programme s’exécute et se termine avec un code d’état non nul (c’est-à-dire qu’un problème est survenu), il appelle automatiquement le LLM le plus rapide du moment pour lui demander d’expliquer la réponse, tout en lui demandant en même temps un patch que je puisse appliquer directement pour corriger le bug dans le code
  • Les modèles d’aujourd’hui ne sont pas encore assez bons pour battre l’auteur sur cette tâche dans la plupart des cas, mais ils s’en rapprochent de plus en plus
  • Et de temps en temps, quand le LLM corrige un bug dû à une faute de frappe quelque part, dont je sais qu’elle aurait été un cauchemar à traquer, cela procure une bonne surprise

Récapitulatif

• Toutes les conversations liées ci-dessus représentent moins de 2 % de l’ensemble des conversations que j’ai eues avec des LLM l’année dernière
• Si je n’ai pas lié les autres conversations, ce n’est pas parce qu’elles montrent des échecs du modèle (même s’il y en a bien sûr beaucoup)
  • (1) soit elles répètent les mêmes schémas que les conversations déjà liées
  • (2) soit il n’est pas facile d’expliquer ce qui s’y passe ni de voir directement pourquoi elles sont utiles
• Je m’attends à continuer à utiliser de plus en plus ces modèles à l’avenir
• À titre indicatif, j’ai effectué 30 % de requêtes LLM en plus via l’interface web en 2024 qu’en 2023, et je ne peux pas agréger l’augmentation des requêtes API, mais j’estime qu’elle a été d’au moins un facteur 2 ou 3

Évaluer non pas ce que les LLM ne peuvent pas faire, mais ce qu’ils peuvent faire

• Lorsqu’on évalue des candidats en entretien, il faut se concentrer sur ce qu’ils savent faire plutôt que sur ce qu’ils ne savent pas faire
• Si on pose des questions triviales à un LLM, il peut sembler incompétent. Par exemple, si on lui pose une question en chinois, parlé par un milliard de personnes, il peut avoir du mal à répondre correctement
• Même en informatique, il y a de nombreux domaines que j’ignore, comme ne connaître des requêtes SQL que l’instruction SELECT
• J’ai du mal à comprendre ceux qui affirment en ligne que les LLM sont survendus au motif qu’ils ne parviennent pas à accomplir une task précise
  • Ils ne savent pas compter le nombre de mots d’une phrase
  • Ils ne savent pas écrire un poème dont tous les mots commencent par « a »
  • Ils ne savent pas multiplier des nombres à deux chiffres
  • Ils ne savent pas choisir un élément aléatoire dans une liste
• Mais on peut se demander si, dans des cas réels, on a déjà pensé qu’un LLM était l’outil adapté pour ce genre de tâches
• De la même manière qu’on ne dit pas qu’un humain est inutile au motif qu’il ne peut pas faire une division d’entiers 64 bits de tête, il n’est pas pertinent de balayer les LLM parce qu’on a construit un problème qu’ils ne savent pas résoudre
• L’important est de savoir s’il existe des tasks pour lesquelles les LLM peuvent apporter de la valeur
• Les programmeurs savent déjà très bien que, selon l’objectif, certains langages sont plus utiles que d’autres
  • Pour écrire un système d’exploitation, le C est plus adapté que Python
  • On ne dit pas que Python est mauvais parce qu’il ne peut pas aligner des variables sur des frontières de 32 octets. C’est simplement un autre niveau d’abstraction
• Les LLM, de la même façon, opèrent à un très haut niveau d’abstraction
  • Il est difficile d’attendre d’un LLM qu’il résolve des tâches qu’un programme simple peut déjà résoudre
  • En revanche, on peut s’attendre à ce qu’il résolve d’autres types de tâches

Conclusion

• Les deux motivations de cet article
  • Affirmer que les LLM m’apportent déjà personnellement beaucoup de valeur
  • Montrer des exemples d’usage à ceux qui trouvent l’idée des LLM intéressante sans savoir comment cela pourrait les aider
• La valeur des LLM
  • Les LLM ne peuvent pas tout faire, mais même les modèles actuels apportent déjà une valeur considérable
  • Par exemple, ils peuvent diagnostiquer une erreur CUDA et expliquer comment réinstaller des packages, réécrire un programme en C ou enseigner un sujet précis
  • Ce sont des choses qu’un étudiant peut faire après quelques heures d’effort, mais aucun étudiant n’est disponible à tout moment pour répondre à des questions. Un LLM, si
• L’évolution des LLM et la situation actuelle
  • Il y a seulement cinq ans, le mieux que savaient faire les LLM était de produire des paragraphes plausibles en anglais, sans aucune utilité pratique
  • Aujourd’hui, les LLM améliorent d’au moins 50 % la productivité sur des tâches de programmation et éliminent les corvées
  • Grâce aux LLM, j’ai mené à bien plusieurs projets que je n’aurais même pas essayé de lancer.
• Réponse aux critiques sur l’utilité des LLM
  • Je m’oppose à l’idée selon laquelle « les LLM sont survendus et n’apportent aucune valeur concrète »
  • Personnellement, les LLM m’apportent une grande valeur
  • Même avec 20 ans d’expérience en programmation, les LLM augmentent fortement ma productivité
  • Je pense que beaucoup d’autres personnes, au-delà de moi, peuvent elles aussi bénéficier des LLM
• Perspectives
  • Les modèles actuels apportent déjà beaucoup de valeur
  • Pour les cinq prochaines années, j’éprouve à la fois de l’attente et de la crainte face à l’évolution des LLM
  • Je traiterai de ces prévisions dans un prochain article

[edunga1]

Je trouve ce texte très parlant. L’auteur en fait un usage tellement poussé qu’on en est presque fatigué rien qu’à le lire..;

La seule raison pour laquelle on ne peut pas enchaîner des milliers d’exemples supplémentaires comme celui-ci, c’est que des outils pour interroger un LLM sont intégrés à la fois dans Emacs et dans le shell

Moi aussi, j’ai l’impression de ne jamais quitter la fenêtre du terminal. J’imagine que tous les développeurs paresseux l’utilisent de cette façon.
Pour un problème simple, j’utilise copilot.vim : j’ouvre n’importe quel buffer, je laisse l’autocomplétion se faire et ça me guide vers la réponse.
Si je ne me souviens pas d’une commande shell, il y a la commande ?? de copilot-cli, donc plus besoin de faire une recherche.
Les outils de complétion de code comprennent mon intention et produisent du code avant même que j’aie à demander.

Comme le dit le texte, je sais comment formuler une recherche, mais je préfère les LLM parce qu’on peut leur poser des questions librement, sans avoir à y mettre les formes.

[galadbran]

J’utilise aussi copilot-vim ! Je me demande de quel copilot-cli vous parlez.

[edunga1]

https://www.npmjs.com/package/@githubnext/github-copilot-cli
c'est ça !

https://docs.github.com/ko/copilot/…
Il existe aussi une version d'extension pour GitHub CLI, mais la façon de l'utiliser est un peu différente.

[galadbran]

C'est agréable de pouvoir aussi profiter de l'aide de Copilot en ligne de commande, merci !

[wedding]

Je le confie à ChatGPT quand je sais comment le faire, mais que j’ai la flemme de taper.
Je pense qu’il faut savoir relire et évaluer le résultat pour bien s’en servir.

[xguru]

L’auteur souligne deux usages clés des LLM : 1. l’aide à l’apprentissage 2. l’automatisation des tâches ennuyeuses.
En ce moment, c’est exactement pareil pour moi. Si je repense aux choses que j’ai faites récemment :

1. Concevoir un organisateur de jeu de société en code OpenSCAD

• Plutôt que de le faire avec Fusion, le fait qu’il écrive le code OpenSCAD le rend plus facile à réutiliser plus tard.
• Si je lui demande de gérer les paramètres, il factorise aussi très bien en fonctions, ce qui permet de l’utiliser dans plein de contextes différents.

2. Écrire un script Python d’automatisation pour extraire des images d’un PDF scanné de cartes et les ajuster comme je le souhaite

• Je m’en sers pour diverses tâches quand je scanne un jeu de société qui n’aura probablement pas de version coréenne afin de le localiser en français.

3. Écrire du JavaScript pour copier le panier d’une boutique en ligne

• J’automatise la saisie côté service de réexpédition pour les achats effectués sur plusieurs boutiques de jeux de société à l’étranger.

Bien sûr, ce sont des choses possibles même sans LLM, mais c’est simplement plus rapide de lui demander, donc c’est parfait pour du life hacking.

[helloppfm]

Je m’y retrouve sur bien des points.
C’est assez similaire à ce que je ressens en utilisant l’IA.