<linkrel="alternate"lang="fr"xml:lang="fr"title="Arbres ; Pragmatisme et Formalisme"type="text/html"hreflang="fr"href="/Scratch/fr/blog/2010-05-24-Trees--Pragmatism-and-Formalism/"/>
<linkrel="alternate"lang="en"xml:lang="en"title="Trees; Pragmatism and Formalism"type="text/html"hreflang="en"href="/Scratch/en/blog/2010-05-24-Trees--Pragmatism-and-Formalism/"/>
Quand la théorie est plus pratique que la pratique
</h2>
</div>
<divclass="flush"></div>
<divclass="flush"></div>
<divid="afterheader">
<divclass="corps">
<divclass="intro">
<p><abbrtitle="Trop Long À Lire"><spanclass="sc">tlàl</span></abbr> :</p>
<ul>
<li>J’ai essayé de programmer un simple filtre ;</li>
<li>J’ai été bloqué pendant deux jours ;</li>
<li>J’ai arrêté de penser comme un robot ;</li>
<li>J’ai utilisé un papier et un stylo ;</li>
<li>J’ai fait un peu de maths ;</li>
<li>J’ai résolu le problème en 10 minutes ;</li>
<li>Conclusion: Pragmatisme n’est pas : «n’utilisez jamais la théorie».</li>
</ul>
</div>
<h2id="rsum-plus-long-que-le--abbr-titletrop-long--liresctllscabbr">Résumé (plus long que le <abbrtitle="Trop Long À Lire"><spanclass="sc">tlàl</span></abbr>)</h2>
<p>Je devais résoudre un problème à mon travail. Au début cela
semblait assez facile. J’ai donc commencé à programmer
tout de suite. Je suis alors entré dans un cercle infernal d’essais
et de réparations. Voilà à quoi ressemblait cet étrange état
de boucle infini :</p>
<blockquote>
<p>– Plus que ça a réparer et ça devrait être bon.<br/>
– Très bien, maintenant ça doit marcher.<br/>
– Oui !!<br/>
– Ah mince! J’ai oublié ce détail…<br/>
<code>répéter jusqu'à la mort</code></p>
</blockquote>
<p>Après deux jours à me prendre pour <ahref="http://fr.wikipedia.org/wiki/Sisyphe">Sisyphe</a>, je me suis arrêté pour repenser le problème.
J’ai pris un stylo et une feuille de papier. Je me suis souvenu de de ce que j’avais appris sur les arbres pendant mon doctorat.
Finalement, le problème fut résolu en moins de 20 minutes.</p>
<p>Je pense que la leçon à retenir de cette expérience est de se souvenir que la méthodologie la plus efficace pour résoudre ce problème <em>pragamtique</em> était la méthode <em>théorique</em>.
Ça ne signifie pas que la méthode théorique est toujours la meilleure, mais en tout cas, il ne faut pas l’écarter.</p>
<p>À première vue, cela m’a paru simple. J’étais certain de pouvoir y arriver en me fixant les règles suivantes :</p>
<ol>
<li>ne pas utiliser <spanclass="sc">xslt</span> ;</li>
<li>ne pas utiliser de parseur <spanclass="sc">xml</span> ;</li>
<li>résoudre le problème en utilisant un simple script perl</li>
</ol>
<p>Vous pouvez essayer si vous le souhaitez. Si vous attaquez ce problème directement en écrivant le programme, ce ne sera certainement pas si simple.
Je peux le dire, parce que c’est ce que j’ai fait.
Et je dois dire que j’ai perdu une journée de travail complète en m’y prenant de la sorte.
En réalité, il y avait pas mal de petits détails dont je ne parle pas qui m’ont induis en erreur et qui m’ont fait perdre encore plus de temps.</p>
<p>Pourquoi étais-je incapable de résoudre ce problème si simple en aparence ?</p>
<p>Voici comment je m’y suis pris :</p>
<ol>
<li>Réfléchir</li>
<li>Écrire le programme</li>
<li>Essayer le programme</li>
<li>Vérifier les résultats</li>
<li>Trouver un bug</li>
<li>Résoudre le bug</li>
<li>Reprendre à l’étape 3</li>
</ol>
<p>Il s’agissait d’une méthode de travail standard pour un ingénieur en informatique. L’erreur venait de la première étape.
J’ai d’abord pensé à comment résoudre le problème mais avec des yeux d’<em>ingéinieur pragmatique</em>. Je me suis simplement dit :</p>
<blockquote>
<p>Ça à l’air de pouvoir se résouvre avec un petit script de <em>search&replace</em> en perl
Commençons à écrire le code maintenant.</p>
</blockquote>
<p>C’est la deuxième phrase qui est complètement fausse. Parce que j’avais mal commencé et que cette méthodologie de travail ne fonctionne pas lorsque l’on part vraiment mal.</p>
<h2id="rflchir">Réfléchir</h2>
<p>Après un certain temps, j’ai arrêté de programmer et je me suis dit : «Maintenant, ça suffit !».
J’ai pris une feuille et un stylo et j’ai commencé à dessiner des arbres.</p>
<p>J’ai commencer par simplifier un peu en enlevant le maximum de verbiage.
Tout d’abord en renommant <code><item name="Menu"></code> par un simple <code>M</code> par exemple.
<p>Puis, je me suis fait la réflexion suivante :</p>
<p>Dans les distances d’éditions sur les arbres, chaque opération atomique correspond à un simple <em>search and replace</em> sur mon fichier <spanclass="sc">xml</span> source<supid="fnref:nb"><ahref="#fn:nb"rel="footnote">2</a></sup>.
On considère trois opérations atomiques sur les arbres :</p>
<ul>
<li><em>substitution</em>: renommer un nœud</li>
<li><em>insertion</em>: ajouter un nœud</li>
<li><em>délétion</em>: supprimer un nœud</li>
</ul>
<p>Une des particularité avec les transformations sur les arbres est celle-ci :
supprimer un nœud et tous ses enfants deviendront les enfants du père de ce nœud.</p>
<p>Un exemple:</p>
<preclass="twilight">
r - x - a
\ \
\ b
y - c
</pre>
<p>Si vous supprimez le nœud <code>x</code>, vous obtenez</p>
<spanclass="MetaTagAll"><spanclass="MetaTagAll"><</span><spanclass="MetaTagAll">a</span><spanclass="MetaTagAll">></span></span>value for a<spanclass="MetaTagAll"><spanclass="MetaTagAll"></</span><spanclass="MetaTagAll">a</span><spanclass="MetaTagAll">></span></span>
<spanclass="MetaTagAll"><spanclass="MetaTagAll"><</span><spanclass="MetaTagAll">b</span><spanclass="MetaTagAll">></span></span>value for b<spanclass="MetaTagAll"><spanclass="MetaTagAll"></</span><spanclass="MetaTagAll">b</span><spanclass="MetaTagAll">></span></span>
<spanclass="MetaTagAll"><spanclass="MetaTagAll"><</span><spanclass="MetaTagAll">c</span><spanclass="MetaTagAll">></span></span>value for c<spanclass="MetaTagAll"><spanclass="MetaTagAll"></</span><spanclass="MetaTagAll">c</span><spanclass="MetaTagAll">></span></span>
<p>Par conséquent, s’il existe un transducteur déterministe à un état qui permet de transformer mes arbres ;
je suis capable de transformer le <spanclass="sc">xml</span> d’un format à l’autre en utilisant une simple liste de <em>search and replace</em>.</p>
<h1id="solution">Solution</h1>
<p>Transformer cet arbre :</p>
<preclass="twilight">
R - C - tag1
\ \
\ tag2
E -- R - C - tag1
\ \ \
\ \ tag2
\ E ...
R - C - tag1
\ \
\ tag2
E ...
</pre>
<p>en celui-ci :</p>
<preclass="twilight">
tag1
/
M - V - M - V - tag2 tag1
\ /
M --- V - tag2
\ \
\ M
\ tag1
\ /
V - tag2
\
M
</pre>
<p>peut-être fait en utilisant le transducteur déterministe à un état suivant: </p>
<blockquote>
<p>C →ε<br/>
E → M<br/>
R → V </p>
</blockquote>
<p>Ce qui peut-être traduit par les simples directives Perl suivantes :</p>
<p>Même si cela peut sembler paradoxal, parfois la solution la plus efficace à un problème pragmatique est d’utiliser une méthodologie théorique.</p>
<hr/><divclass="footnotes">
<ol>
<liid="fn:1">
<p>Normalement, je fais parti des 10% qui ont fourni une implémentation sans bug.<ahref="#fnref:1"rev="footnote">↩</a></p>
</li>
<liid="fn:nb">
<p>J’ai programmé un outil qui calcule automatiquement le poids de chaque élément des matrices d’édition à partir de données.<ahref="#fnref:nb"rev="footnote">↩</a></p>