Le code…

Voi­là, c’est comme le muguet, ça revient régu­liè­re­ment : on veut intro­duire une ini­tia­tion au codage infor­ma­tique dans les ensei­gne­ments fon­da­men­taux (ceux qui sont maî­tri­sés au bre­vet, donc acquis en pri­maire ou au collège).

Bon.

Pre­mière chose : ça n’a rien de nouveau.

En 1987, j’ai sou­ve­nir d’a­voir fait des des­sins sur un écran de télé avec un TO7/70. Ça res­sem­blait à ça :

La tor­tue Logo, sym­bole du plan Infor­ma­tique pour tous, c’é­tait ludique et mine de rien, ça implé­men­tait plein de choses utiles comme bases de la pro­gram­ma­tion : les nombres, les opé­ra­tions sur les nombres (y com­pris des opé­ra­tions que, à l’é­poque, je voyais que très suc­cinc­te­ment : l’ad­di­tion en CP, c’é­tait le maxi­mum qu’on nous deman­dait), les boucles et mêmes les fonctions.

Est-ce que ça a fait de moi un bon pro­gram­meur ? Non. Je suis pas un bon pro­gram­meur, et c’est pas seule­ment parce que je n’ai plus tou­ché un pro­gramme entre Infor­ma­tique pour tous et mes pre­miers pas de Basic à domicile.

Je suis pas un bon pro­gram­meur, parce que je pense trop comme l’or­di­na­teur : je réflé­chis trop en suite d’ins­truc­tions et pas assez en fonc­tion d’abstractions utiles. L’exemple cari­ca­tu­ral, c’est la dif­fi­cul­té éter­nelle que j’ai à employer des lan­gages à objets : j’ai ten­dance à mul­ti­plier les fonc­tions et à gérer des variables innom­brables, là où de simples classes d’ob­jets feraient l’af­faire beau­coup plus lisi­ble­ment, et c’est sans doute parce que je reste très atta­ché à ce que va faire l’or­di­na­teur avec mes don­nées et son pro­ces­seur — c’est pas un hasard si, à la fac, un des rares domaines où je brillais était… l’assembleur !

Mine de rien, ça rejoint mon deuxième point : apprendre le code sera-t-il utile ?

Dans un pre­mier temps, il y eut le binaire. Puis il y eut l’as­sem­bleur, qui per­met­tait d’é­crire des ins­truc­tions vague­ment lisibles qu’un pro­gramme allait trans­for­mer en lan­gage binaire exé­cu­table. Puis, il y eut des lan­gages de rela­ti­ve­ment bas niveau, encore proches de la machine, avec des variables simples res­sem­blant vague­ment aux registres, des ins­truc­tions rap­pe­lant encore des empla­ce­ments mémoire (en Basic par exemple, on débu­tait les lignes de code par un numé­ro et les ins­truc­tions de bran­che­ment étaient de simples goto), mais déjà plus lisibles. Puis les lan­gages de plus haut niveau, avec des variables typées, des opé­ra­tions plus variées, des fonc­tions, des objets, qui ouvraient des concepts incon­nus de la machi­ne¹. Par­mi ceux-ci, cer­tains n’a­vaient plus rien à voir avec la façon dont opé­rait l’or­di­na­teur, je pense par exemple au Pro­log et au Lisp.

Aujourd’­hui, la pro­gram­ma­tion d’ap­pli­ca­tions simples n’est qua­si­ment plus affaire de code. On des­sine des fenêtres et des objets, on ajoute des bouts de codes appe­lés par des évé­ne­ments sur ces objets.

Bien sûr, je sim­pli­fie et je cari­ca­ture le pro­pos, mais quand on demande dans l’é­vo­lu­tion des pro­grammes sco­laires que “L’é­lève [soit] capable de réa­li­ser de petites appli­ca­tions uti­li­sant des algo­rithmes simples”, j’ai juste envie de dire : c’est bon, des petites appli­ca­tions et des algo­rithmes simples, y’a pas besoin de savoir coder. Il suf­fit de savoir cli­quer, des­si­ner, et savoir écrire un for ou un while.

Aujourd’­hui, une bonne part de l’al­go­rith­mique n’a plus rien à voir avec l’or­di­na­teur. Il y a des types qui pensent l’al­go­rithme, par­fois avec des outils bien plus proches des mathé­ma­tiques que du codage — je me suis arrê­té au λ‑calcul, mais je sup­pose qu’il y a d’autres trucs du même genre. Puis ces algo­rithmes sont trans­for­més par le pro­gram­meur dans un lan­gage de haut niveau (Lisp, PHP, C♯ ou autre) adap­té au pro­blème du moment, puis l’or­di­na­teur com­pile tout ça pour obte­nir le fichier exé­cu­table. Le pro­gram­meur peut d’ores et déjà être consi­dé­ré comme une sorte de pré-com­pi­la­teur, qui trans­forme un algo­rithme abs­trait ou pure­ment mathé­ma­tique en lan­gage for­mel que l’or­di­na­teur puisse com­pi­ler ou interpréter.

La ten­dance est tou­jours à déve­lop­per non seule­ment des lan­gages plus “humains”, mais aus­si des briques logi­cielles plus puis­santes, per­met­tant d’ap­pe­ler des fonc­tions tou­jours plus com­plexes avec des écri­tures tou­jours plus intel­li­gibles. Je prends un exemple tout bête juste parce que c’est chez des potes (et que pour une fois j’ai com­pris à quoi ça sert), mais y’a des mecs qui déve­loppent une librai­rie d’ex­pres­sions régu­lières lisibles pour .Net, Magex. Il n’y a pas si long­temps, véri­fier si un texte est une adresse inter­net HTTP ou FTP, pour vali­der un for­mu­laire par exemple, deman­dait de taper un truc du genre :

m/(http(s)?|ftp)://(www.)?[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+/

qui est, disons-le, d’une lisi­bi­li­té assez médiocre (d’ailleurs je vais même pas m’emmerder à taper du Perl juste pour voir si ça marche, c’est là à titre d’illus­tra­tion) ; Magex per­met d’écrire :

const string allowedChars = @"!#$%&'*+/=?^_`{|}~-";
magicWand.Alternative(
Magex.New().String("http").Character('s').Repeat.AtMostOnce(),
Magex.New().String("ftp"))
.String("://")
.Group(Magex.New().String("www.")).Repeat.AtMostOnce()
.CharacterIn(Characters.Alphanumeric, allowedChars);

ce qui est tout de même légè­re­ment plus clair : même sans avoir étu­dié Magex ou le lan­gage uti­li­sé, si vous lisez l’an­glais, vous avez des chances de com­prendre glo­ba­le­ment de quoi ça parle.

Main­te­nant, pre­nons le temps de voir à long terme. Les mioches d’au­jourd’­hui, à qui on va incul­quer des bases de code, ils vont vivre leur vie à la fin des années 2020, voire plu­tôt dans les années 2030. D’i­ci là, de nou­veaux pro­grès auront été faits, de nou­velles librai­ries auront été déve­lop­pées, de nou­velles abs­trac­tions for­melles auront été mises au point. Sou­ris-cla­vier, ils ne connaî­tront pro­ba­ble­ment pas : ils auront toute leur vie employé des appa­reils tac­tiles où ils auront mani­pu­lé direc­te­ment des objets à l’é­cran, et ils auront pro­ba­ble­ment des machines capables de recon­naître des gestes faits dans le vide au milieu d’une pièce. Pour tout ce qui est modé­li­sa­tion, les tablettes gra­phiques sont déjà autant uti­li­sées que la pro­gram­ma­tion ; demain, ça se fera direc­te­ment avec les doigts.

Mieux : ces temps-ci, la recon­nais­sance vocale pro­gresse spec­ta­cu­lai­re­ment — dic­tez une adresse à Google Maps aujourd’­hui et com­pa­rez avec ce qu’on fai­sait il y a ne serait-ce que cinq ans, tiens. D’i­ci à ce que ces jeunes soient en âge d’u­ti­li­ser leurs com­pé­tences, il n’est pas déli­rant d’i­ma­gi­ner qu’a­près avoir des­si­né un for­mu­laire du bout du doigt, tout ce qu’ils auront à faire pour véri­fier qu’il contient une URL, c’est dire à haute voix (et même pas for­cé­ment en articulant) :

Véri­fie que la chaîne com­mence par http puis peut-être s, ou ftp, puis deux-points slash slash, puis des carac­tères alpha­nu­mé­riques, ponc­tua­tion, opé­ra­teurs mathé­ma­tiques, car­ré, dol­lar, pour cent, esper­luette, cha­peau, sou­li­gné, accent grave, acco­lades, barre ver­ti­cale ou tilde.

Le code leur sera-t-il vrai­ment utile ? Pour ceux qui feront de vrais pro­grammes, sans doute, ne serait-ce que parce que c’est une école de la rigueur appli­quée, indis­pen­sable pour apprendre à s’ex­pri­mer sans ambi­guï­té (“les gens intel­li­gents auront com­pris” marche mal avec les ordi­na­teurs, au moins pour l’ins­tant et pro­ba­ble­ment encore dans un futur proche).

Pour ceux qui seront simples uti­li­sa­teurs ou qui ne feront que des appli­ca­tions simples comme gérer un por­te­feuille de vente en ligne, fran­che­ment, j’en doute.

Vou­loir géné­ra­li­ser l’ap­pren­tis­sage du code au temps du plan Infor­ma­tique pour tous, c’é­tait osé : les ordi­na­teurs coû­taient cher, per­sonne n’en avait ou presque et rares étaient ceux qui en avaient l’u­ti­li­té. On a beau­coup raillé Infor­ma­tique pour tous : “mon fils a appris à des­si­ner un cercle sur une télé avec une “tor­tue”, ils feraient mieux de lui apprendre les divi­sions et le pas­sé simple” était une opi­nion facile, mais répan­due. C’é­tait une ère où il fal­lait un esprit vision­naire pour ima­gi­ner qu’on aurait tous, aujourd’­hui, accès à un ordi­na­teur et que beau­coup d’entre nous pour­rions avoir un jour ou l’autre l’u­ti­li­té de bases de pro­gram­ma­tion — que ce soit pour modi­fier un élé­ment d’un blog, pour ana­ly­ser des images ou pour sup­pri­mer auto­ma­ti­que­ment les Raw après avoir fait son edi­ting sur des Jpeg. Mais beau­coup d’entre nous avons appris quelques fon­de­ments de la pro­gram­ma­tion, mine de rien, en fai­sant une fonc­tion “rec­tangle” avec lar­geur et hau­teur en para­mètres, et en l’ap­pe­lant quatre fois pour faire une fenêtre.

Vou­loir géné­ra­li­ser l’ap­pren­tis­sage du code aujourd’­hui, je n’ar­rive pas à me défaire du sen­ti­ment que c’est appli­quer une solu­tion des années 80 aux pro­blèmes des années 2020. C’est comme si, dans ma géné­ra­tion, on avait dit “bon, l’or­di­na­teur se déve­loppe, ça va être impor­tant de com­prendre com­ment ça marche, on va faire une ini­tia­tion à l’as­sem­bleur et au Basic”. Les raille­ries de l’é­poque ne doivent pas mas­quer une chose : Logo était un lan­gage de haut niveau, plu­tôt intel­li­gible et décon­nec­té de la machine, et les pro­gram­meurs d’au­jourd’­hui uti­lisent prin­ci­pa­le­ment ce type de langages.

Vou­loir ensei­gner les bases de code, qui vont sans doute se faire avec l’ap­pli­ca­tion bête et méchante de petits algo­rithmes en Ada ou en C, c’est une idée de diri­geants sexa­gé­naires dépas­sés, qui demandent à leurs enfants tren­te­naires ce qu’ils font et ce qu’ils auraient dû avoir à l’é­cole pour être effi­caces au bureau ; ça n’est pas la vision à long terme de celui qui essaye d’i­ma­gi­ner ce que les enfants qui naissent aujourd’­hui auront sur leur plan de tra­vail dans vingt ans.

C’est vou­loir ensei­gner à nos enfants ce qui nous a man­qué pour maî­tri­ser nos outils, au lieu de leur apprendre ce qui leur sera utile pour maî­tri­ser les leurs.

¹ À ma connais­sance, le plus haut niveau de pro­gram­ma­tion implé­men­té direc­te­ment sur un pro­ces­seur (et donc dis­po­nible en assem­bleur) s’est trou­vé sur le Sparc, capable grâce à son sys­tème de fenêtres de registres de faire des appels de fonc­tions direc­te­ment en interne, sans empi­ler les para­mètres en mémoire vive.

² Je me suis ren­du compte en reli­sant que j’ai fait une erreur. Si le break est pré­sent dès le début de l’exé­cu­tion, les ver­sions assem­bleur et Basic ren­voient 1, alors que la ver­sion C ren­voie 0 (elle fait le test avant la boucle, les deux autres le font en fin de boucle). J’au­rais dû faire un do{}while() et pas un while(){} pour que ça soit vrai­ment le même pro­gramme. Oui, je viens de débo­guer une simple image d’illus­tra­tion dont on a rien à foutre. Non, j’ai même pas honte.