Le carnet du grincheux

Je suis un utilisateur de l'IA, j'avoue. Et ce que je lis ici et là sur cet outil me déprime. Je suis pris entre ceux qui prétendent que jamais ils ne seront touchés par l'IA et les béats d'admiration qui considèrent qu'il ne faut plus apprendre que cela dans les universités et les grandes écoles.

Mon point de vue est radicalement différent. Je considère qu'il faut être bon dans sa matière sans jamais avoir touché à l'IA pour l'utiliser efficacement par la suite. Pourquoi ?

J'utilise cet outil pour du code informatique critique et contraint (que je saurais écrire moi-même) en C ou assembleur ou pour optimiser des composants électroniques écrits en VHDL 2008. Comme il s'agit dans les deux cas de codes complexes, je tiens mon IA par la bride. J'avoue que même comme cela, elle arrive à m'écrire des énormités. Exemple :

ffff003c: 34 00 40 pshs U
ffff003f: 33 e4 leau ,S
ffff0041: 32 78 leas -8,S
ffff0043: ae 48 ldx 8,U
ffff0045: 6f 84 clr ,X
ffff0047: 6d 84 tst ,X
ffff0049: 26 54 bne ffff009f <memory_count.isra.0+0x63>
ffff004b: 10 6f clrq

Je ne sais pas si vous voyez bien le souci. Le stagiaire Claude, pourtant avec les réglages au maximum, m'écrit sans rigoler 0 à l'adresse pointée par X, puis teste cette valeur par rapport à 0 avant de brancher à l'adresse $FFFF009F si la valeur est non nulle. Trois instructions qui ne servent à rien puisque la valeur est toujours nulle. Nous sommes dans un cas avec un seul fil d'exécution et de la mémoire à l'endroit pointé par X.

Il trouvait sans doute cela joli. Je ne compte plus les opérations inutiles. Un peu plus loin, il m'a écrit ceci :

ffff0068:       86 ff           lda     #$ff
ffff006a:       a7 84           sta     ,X
ffff006c:       34 00 02        pshs    A
ffff006f:       a6 84           lda     ,X
ffff0071:       81 ff           cmpa    #$ff
ffff0073:       35 00 02        puls    A
ffff0076:       26 27           bne     ffff009f <memory_count.isra.0+0x63>
ffff0078:       cd 00 00 00     ldq     #$000000ff

où l'on voit qu'il prend la peine de sauvegarder le registre A sur la pile, de le restaurer par PULS A puis de l'écraser par LDQ, Q étant un registre trente-deux bits formé par la concaténation de A, B, E et F tous de huit bits.

Lorsqu'on regarde le code généré, que ce soit en C, en assembleur, en Fortran ou en VHDL, c'est une succession de patches sur des patches jusqu'à arriver à un résultat à peu près conforme à la demande initiale (et encore), mais la plupart du temps tellement non maintenable qu'il faut le reprendre plusieurs fois malgré un fichier de description de toutes les étapes à respecter.

L'IA n'est pas capable de concevoir un code informatique correct à partir d'un seul "prompt". Il faut lui tenir la main et critiquer tout ce qu'elle écrit. Il faut donc être capable de le faire soi-même. Dire à des jeunes aujourd'hui, étudiez l'IA et surtout rien d'autre est inepte parce que cela revient à les contraindre à utiliser un outil qu'ils ne maîtriseront jamais faute de le comprendre. Et dites-vous bien que je vous parle de l'IA utilisé en informatique. En électronique, c'est largement pire.

L'IA est un excellent serviteur et un mauvais maître.