Le demi-cercle (épisode 22 — non-conclusions)

Entrée:
9A1ABC131
1112 3124
1112111

Sortie:
AAAAAAAAAABC111
12 344
121

Tu t’es assis devant le clavier et tu mets en place un nouveau projet dans l’EDI. Audrey, Farid et Jérémie observent silencieusement la manœuvre. Farid, assis en tailleur sur sa chaise, se lance :
– Donc c’est assez simple, tu vas lire les caractères deux par deux, ce qui va te donner à chaque fois un couple : longueur, caractère…

Jérémie l’interrompt :
– Sauf quand la longueur se trouve être 1.
– J’allais y venir, justement. Quand la longueur est 1…

Audrey interrompt :
– Si on commençait par écrire un test ?

Tu es prêt. Tu dis :
– Je vous écoute.

Audrey : Quel serait le cas le plus simple ?
Farid : Une séquence de 2 caractères identiques : 2A
Jérémie : Pas de séquence du tout.
Farid : Ça n’est pas possible.
Jérémie : Relis la spéc’. C’est parfaitement possible.
Farid : Admettons. Vous allez tester le cas vide. C’est bizarre.
Audrey : Au moins ça nous mettra en route. Quand on a une ligne vide en entrée, produire une ligne vide en sortie.

Tu écris le test. Tu le fais passer. Vous discutez du nom à donner à la fonction. Farid suggère DecodeLigne. Audrey suggère : Decodage. Jérémie suggère : LigneDecodee, parce que, dit-il, cela respecte mieux la convention Command / Query. Discussion. Farid conteste le fait que la fonction soit une requête plutôt qu’une commande, puisqu’elle va produire un résultat sur la sortie standard.

Tu dis :
– Eh bien si toutes les personnes qui ont contribué à XXL étaient aussi exigeantes pour leur nom de méthode, on aurait du beau code.

Jérémie : On n’aurait pas d’application, tu veux dire. Vu le temps que ça prend de trouver le bon nom…
Audrey : C’est plus un souci de cohérence qu’une question d’exigence, à vrai dire.
Farid : On avance ou quoi ?
Audrey : Qu’est-ce que tu proposes ?
Farid : Quand on a la séquence 2A en entrée, on doit produire la ligne AA.
Toi : OK. Je mets ça en dur dans la méthode.
Audrey : Facile. Maintenant quand on a la séquence 9B, on doit produire, eh bien neuf Bs à la suite.
Toi : OK.
Jérémie : Il suffit de convertir le premier caractère en nombre entier, et ensuite d’imprimer autant de fois le second caractère.
Toi : Très bien.
Jérémie : Je pense qu’on a un souci dans notre expérimentation.
Farid : Lequel ?
Jérémie : L’exercice est trop simple. Ça ne veut plus rien dire.
Farid : Trop simple, c’est pas si sûr. On est seulement deux à avoir passé le test du juge en ligne.
Jérémie : Je ne parle pas de la première partie, mais de la partie qu’on est en train de faire ensemble…
Audrey : Il faudrait savoir ce que tu veux, Jérémie.
Toi : Est-ce qu’on peut au moins finir l’exercice avant de déclarer qu’il est trop simple ?
Farid : Oui.
Audrey : Test suivant. Quand on a la séquence 1AB1, on devrait retrouver AB en sortie…
Jérémie : Hmm. Je pense qu’on devrait plutôt aller dans l’autre direction…
Audrey : Qu’est-ce que tu veux dire ?
Jérémie : Quand on a en entré 2A2B, on devrait avoir AABB en sortie. Tu vois ce que je veux dire ? D’abord traiter plusieurs séquences répétitives dans la même ligne, avant de traiter les séquences de caractères uniques.
Audrey : Si tu veux.

Après vingt-cinq minutes et trois changements de driver, votre programme est capable de résoudre la moitié des cas spécifiés. Tu te demandes ce qui rend le travail aussi facile, à part la simplicité de l’exercice. Tu contemples le code et ses tests.

C’est la même salle tapissée de rouge que lors de l’exercice précédent, à ceci près que les étagères se trouvent maintenant sur la droite, et que la chaise est placée derrière la table et non plus devant. Il y a également une boîte sur la table. Mais au sol, rien de renversé. C’est comme si cette pièce était l’envers de la précédente, vue depuis un miroir en quelque sorte, mais que, de ce côté là du miroir, les occupants savaient s’y prendre pour remodeler l’espace et ranger chaque chose à sa place.

Il y a trois agents à l’entrée de la pièce, et un visiteur. On peut reconnaître immédiatement les agents à leur tenue de travail. L’un d’eux explique :
– Pour aménager l’espace, il suffit de produire assez de lumière sur la partie de la pièce qui nous intéresse. Le deuxième poursuit :
– Dès que vous changez l’angle de l’éclairage, vous apercevez de nouvelles perspectives dans la pièce. Lorsque vous tenez une perspective intéressante, vous fixez l’éclairage, puis vous aménagez la pièce.
Le troisième enchaîne :
– À moins qu’il s’agisse de cloisonner la pièce. Dans ce cas il vous faut des éclairages supplémentaires.

Jérémie : Hey ! On ne s’endort pas ! Il reste du travail.
Toi : Pardon. Alors…
Jérémie : Je peux passer le clavier à nouveau ? J’ai peut être une idée pour ce qui suit.
Farid (se lève pour prendre la place de Jérémie) : Je prends le clavier.
Jérémie (va s’asseoir à la table de gauche) : OK. Merci.
Audrey : Quand on a 1ABC1 en entrée, on devrait avoir ABC en sortie.
Jérémie : En fait, c’est comme si chaque fois le premier caractère était une commande.
Toi : Hmmm ?
Jérémie : Oui : 2, c’est la commande qui dit : lis deux caractères dans la ligne et imprime les. 3 c’est la commande qui dit : lis trois caractères dans la ligne et imprime les. 4, c’est…
Toi : OK. Je comprend. Mais je ne vois pas l’intérêt.
Farid : Et, 1 c’est quelle commande ?
Jérémie : C’est la commande qui dit : lis tous les caractères qui suivent dans la ligne et imprime les jusqu’à ce que ce tu trouves 1.
Toi : Et qu’est-ce que tu fais du cas où on veut imprimer 1 ?
Audrey : Excusez moi : on pourrait faire passer le test, pour commencer ?
Jérémie : Non, parce que, une fois qu’on a un langage de commande on peut abstraire la solution du fait que ce sont des lignes de caractères en entrée, on pourrait traiter chaque élément de l’entrée comme une commande, suivie de ses paramètres. Vous voyez l’idée ?
Farid : Euh… Et alors ?
Toi : Et qu’est-ce que ça nous apporterait ?
Jérémie : Ce serait plus générique.
Audrey (se lève) : Les gars, excusez-moi si je vous coupe dans votre délire, mais : est-ce qu’on peut faire passer ce test, histoire de faire avancer la solution de l’exercice, ou bien est-ce que vous voulez continuer à discuter d’abstractions ?
Jérémie : Non, mais attends Audrey, on est peut-être sur un truc.
Audrey : Je croyais que l’objectif était de faire passer le programme sur le juge en ligne ?
Jérémie : Ça n’empêche pas !
Toi : Audrey a raison, Jérémie. Il faut revenir à ce test.
Jérémie : OK. Mais on loupe quelque chose.
Farid : Il est quarante-cinq.
Jérémie : OK. OK. Finissons.

Vous finissez le programme, en y ajoutant les cas de séquences de caractères non répétés, sans oublier le cas du caractère 1 qui s’échappe à lui même. Puis vous soumettez le programme au juge en ligne, qui l’approuve. Audrey dit :
– Et voilà le travail !

Jérémie dit :
– Il n’y a plus qu’à comparer les résultats. Je propose qu’on passe en revue chaque programme.

Vous passez chaque programme en revue, et consignez vos remarques dans un compte-rendu :

Programme de Jérémie : conforme à la spécification, passe le test en ligne — ne comporte pas de test unitaire — une seule méthode, trop longue pour tenir dans la page — choix de noms de variables — mélange anglais français — difficile à comprendre et à faire évoluer.

Programme de Farid : conforme à la spécification, passe le test en ligne — ne comporte pas de test unitaire, testé manuellement — découpage en 2 méthodes — conception non optimisée pour la mémoire — choix discutable de noms de variables et de méthodes — difficile à comprendre et à faire évoluer.

Programme de ToF : non conforme à la spécification, ne passe pas le test en ligne — comporte 10 tests unitaires — un test ne passe pas — plutôt facile à comprendre — possibilité d’étendre en ajoutant des tests (TDD).

Programme d’Audrey : n.a — étudier possibilité d’expressions régulières pour résoudre le problème.

Programme réalisé à 4 : conforme à la spécification, passe le test en ligne — comporte des tests unitaires — séparation des sujets (lecture / écriture, interprétation) — possibilité d’étendre et de refactorer — noms de variables standards.

L’après-midi touche à sa fin. Farid demande :
– Bon. Et maintenant qu’est-ce qu’on fait de ce résultat ?

Jérémie : On le transmet à JB et on fixe une réunion pour lui en parler.
Toi : Je ne suis pas sûr que ce soit très utile : on n’a pas vraiment de conclusion à apporter sur l’expérimentation.
Jérémie : On en sait déjà plus que ce matin !
Audrey : Qu’est-ce qu’on sait exactement ?
Jérémie : Qu’on n’a pas tous le même niveau…
Audrey : Pardon ? Le même niveau en quoi ?
Jérémie : Laisse-moi finir au moins ! Qu’on n’a pas tous le même niveau face à ce type de problème.
Audrey : Pour moi, cette expérience montre clairement que si on travaille en isolation, on produit un résultat moins satisfaisant qu’en groupe.
Farid : Ah bon ? À quoi tu peux dire ça ?
Audrey : Facile : en plus de passer l’épreuve du juge en ligne, le programme qu’on a écrit en groupe a des tests; il est plus clair; chacun de nous le comprend, et serait capable de le faire évoluer.
Jérémie : Oui mais le deuxième problème était nettement plus simple.
Farid : C’est difficile de comparer chaque programme, en fait…
Audrey : Lequel préférerais-tu avoir à maintenir, Farid ?
Farid : Le mien, je crois.
Audrey : Parce que tu penses qu’il est de meilleure qualité ?
Farid : Pas forcément, mais j’aurais plus de mal à m’approprier le code des autres.
Jérémie : Justement, ce qu’il faudrait, c’est faire un exercice de maintenance, dans lequel chacun apporte une modification sur le code de quelqu’un d’autre.
Toi : Quel genre de modification ?
Jérémie : Je ne sais pas, moi, par exemple imaginez que la spéc’ change pour prendre en compte une convention différente, du texte non pas en ASCII mais en Unicode…
Audrey : Oui, eh bien sans tests, ça n’irait pas très loin…
Toi : Bon, qu’est-ce qu’on présente à JB ? On n’a toujours rien conclu.
Audrey : La conclusion est évidente : Si ce qu’on cherche, c’est finir la tâche au plus vite, il vaut mieux travailler en solo. Si on cherche à écrire un programme maintenable, coder en équipe est plus efficace.
Toi : Ce n’est même pas certain qu’on puisse finir la tâche si on travaille tout seul.
Audrey : Pour moi c’est clair. Je ne sais pas ce qu’il vous faut de plus.
Farid : Bon, en tout cas moi il faut que je rentre.

Tu décides d’imprimer le compte-rendu, ainsi que le code de chaque programme. Tu te rends à l’imprimante qui se trouve près de l’ascenseur. L’étage se vide progressivement. Certains vont par les escaliers, d’autres attendent l’ascenseur en se souhaitant une bonne soirée, à demain. L’ascenseur se fait attendre un peu. On commente son algorithme. On décide de finalement prendre les escaliers. Au milieu de la première volée de marches, on entend la porte de l’ascenseur s’ouvrir. Bref, tant pis, on rentre chez soi.

Le code et le compte-rendu sont déjà disponibles sur l’imprimante.


(à suivre)
Episodes Précédents :
1 — Si le code pouvait parler
2 — Voir / Avancer
3 — Communication Breakdown
4 — Driver / Navigator
5 — Brown Bag Lunch
6 — Conseils à emporter
7 — Crise / Opportunité
8 — Le Cinquième Étage
9 — Que faire ?
10 — Soit… Soit…
11 — Boîtes et Flêches
12 — Le prochain Copil
13 — La Faille
14 — Poussière
15 — L’hypothèse et la Règle
16 – Déplacements
17 — Jouer et ranger
18 — Arrangements
19 — Mise au point
20 — Expérimentation
21 — Échantillons

Un commentaire sur “Le demi-cercle (épisode 22 — non-conclusions)”

  • Super série! <3
    1. Laisser un commentaire

      Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *


      Ce formulaire est protégé par Google Recaptcha