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 col­lège).

Bon.

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

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

logo
“Cercle” (en fait un tri­acon­ta­kai­hexa­gone) en Logo — ici l’implémentation de LibreOf­fice, qui sup­porte le mul­ti­lingue.

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’addition en CP, c’était le maxi­mum qu’on nous deman­dait), les boucles et mêmes les fonc­tions.

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 à domi­cile.

Je suis pas un bon pro­gram­meur, parce que je pense trop comme l’ordinateur : je réflé­chis trop en suite d’instructions 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’objets feraient l’affaire beau­coup plus lisi­ble­ment, et c’est sans doute parce que je reste très atta­ché à ce que va faire l’ordinateur 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’assembleur, 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’avaient plus rien à voir avec la façon dont opé­rait l’ordinateur, je pense par exemple au Pro­log et au Lisp.

Aujourd’hui, la pro­gram­ma­tion d’applications 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’évolution 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’algorithmique n’a plus rien à voir avec l’ordinateur. Il y a des types qui pensent l’algorithme, par­fois avec des outils bien plus proches des mathé­ma­tiques que du codage — je me suis arrê­té au λ-cal­cul, 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’ordinateur 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’ordinateur puisse com­pi­ler ou inter­pré­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’appeler 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’expressions 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’illustration) ; 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’anglais, 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’aujourd’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’ici 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’ici à ce que ces jeunes soient en âge d’utiliser leurs com­pé­tences, il n’est pas déli­rant d’imaginer qu’aprè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 arti­cu­lant) :

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’exprimer sans ambi­guï­té (“les gens intel­li­gents auront com­pris” marche mal avec les ordi­na­teurs, au moins pour l’instant 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’apprentissage 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’utilité. 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’utilité 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’appelant quatre fois pour faire une fenêtre.

Vou­loir géné­ra­li­ser l’apprentissage du code aujourd’hui, je n’arrive 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’ordinateur se déve­loppe, ça va être impor­tant de com­prendre com­ment ça marche, on va faire une ini­tia­tion à l’assembleur 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’aujourd’hui uti­lisent prin­ci­pa­le­ment ce type de lan­gages.

Version très simplifiée de l'évolution des langages : compter les secondes jusqu'à un événement, version avant-hier (assembleur), hier (Basic), aujourd'hui (C) et peut-être demain.
Ver­sion très sim­pli­fiée de l’évolution des lan­gages : comp­ter les secondes jusqu’à un évé­ne­ment, ver­sion avant-hier (assem­bleur), hier (Basic), aujourd’hui² © et peut-être demain.

Vou­loir ensei­gner les bases de code, qui vont sans doute se faire avec l’application 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’imaginer 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écution, 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’aurais 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’illustration dont on a rien à foutre. Non, j’ai même pas honte.