<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Xavier Pigeon on Medium]]></title>
        <description><![CDATA[Stories by Xavier Pigeon on Medium]]></description>
        <link>https://medium.com/@xavier.pigeon?source=rss-3f1d2583bd2c------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*PafIDpG-PomH7wzLOM0CDg.jpeg</url>
            <title>Stories by Xavier Pigeon on Medium</title>
            <link>https://medium.com/@xavier.pigeon?source=rss-3f1d2583bd2c------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Fri, 20 Nov 2026 12:51:42 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@xavier.pigeon/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Tromperies de marchandise pour des Transformations Agiles mal engagées]]></title>
            <link>https://medium.com/@xavier.pigeon/tromperies-de-marchandise-pour-des-transformations-agiles-mal-engag%C3%A9es-8f38b8300274?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/8f38b8300274</guid>
            <category><![CDATA[craftsmanship]]></category>
            <category><![CDATA[craftsman]]></category>
            <category><![CDATA[software-development]]></category>
            <category><![CDATA[agile]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Tue, 06 Aug 2019 16:57:48 GMT</pubDate>
            <atom:updated>2019-12-27T16:36:08.474Z</atom:updated>
            <content:encoded><![CDATA[<p>Une transformation agile n’est décidément pas chose aisée, entre acculturation et immunité au changement : il faut désapprendre pour réapprendre, ainsi qu’accepter les vertus du changement permanent pour la dynamique bénéfique d’ouverture qu’il favorise. Et dans ce contexte, on ne devrait jamais sous-estimer la portée des fondamentaux. Nous allons nous intéresser non pas aux valeurs déjà énormément reprises et diffusées, mais aux principes du <a href="https://agilemanifesto.org/">Manifeste pour les Développements Logiciels Agiles</a>. Nous verrons ainsi que de très nombreuses transformations sont mal engagées car aux antipodes de ces principes. Cela peut paraître surprenant, ce n’en est pas moins un constat général. Nous en tirerons un apprentissage pour mieux réussir de futures transformations.</p><h3>Des erreurs qui coûtent cher</h3><p>Un collègue avait un jour écrit un message où il se demandait comment la version française du manifeste agile pouvait être à ce point éloignée du sens du <a href="https://agilemanifesto.org/principles.html">texte original</a>. Et les erreurs conceptuelles commencent dès le premier principe !</p><blockquote>Our highest priority is to satisfy the customer through early and continuous delivery of valuable software. — <a href="https://agilemanifesto.org/principles.html">Agile Manifesto</a></blockquote><p>La <a href="https://agilemanifesto.org/iso/fr/principles.html">traduction française</a> en est : “ Notre plus haute priorité est de satisfaire le client en livrant rapidement et régulièrement des fonctionnalités à grande valeur ajoutée. ” Cette traduction soulève trois problèmes majeurs.</p><h4>Livrer rapidement</h4><p>Livrer tôt, ce n’est pas livrer rapidement. Beaucoup d’organisations qui passent à l’Agilité pensent que cette approche va réduire leur coût de développement parce que les équipes vont livrer rapidement, et même plus rapidement qu’auparavant. Or ce n’est pas ce qu’il faut faire : il faut livrer tôt, c’est-à-dire que quand une fonctionnalité est réalisée, il ne faut pas attendre pour la livrer. On en tire ainsi un retour sur investissement plus tôt et plus grand.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/976/1*6-zGoG5znRUwCoepXsoctg.png" /><figcaption>Retour sur investissement (<a href="http://chrysocode.io/">chrysocode.io</a>)</figcaption></figure><p>Si un changement doit être livré rapidement, la pression sur les délais fait que le travail est bâclé et que le produit livré n’est pas de qualité. Au contraire, en livrant tôt un changement abouti, ce dernier a un pouvoir de levier sur la satisfaction des utilisateurs d’autant plus fort (cf. <a href="https://fr.wikipedia.org/wiki/Mod%C3%A8le_de_Kano">modèle de Kano</a>). De plus, on peut recueillir les retours des utilisateurs sur un produit de qualité, et ces retours seront d’autant plus utiles qu’ils porteront sur le contenu fonctionnel plutôt que les défauts.</p><p>En bref : ne pas confondre vitesse et précipitation.</p><h4>Livrer régulièrement</h4><p>Livrer continuellement, ce n’est pas livrer régulièrement. En planifiant des itérations de plusieurs semaines, voire de plusieurs mois, on se donne le temps d’un cycle en V dans l’intervalle d’une itération pour livrer seulement à la fin de l’itération. Vous avez sous doute déjà rencontré ces <em>burndown charts</em> de sprint qui ressemblent à un créneau ou une marche d’escalier. Entre parenthèses, l’atterrissage à zéro du reste-à-faire est fortement susceptible d’être remplacé par une explosion en plein ciel…</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*QYXF5mVLkito3Re3cLuBKA.png" /><figcaption>Burndown chart de sprint, avec une ruée de fin d’itération pour “livrer rapidement et régulièrement” (<a href="http://chrysocode.io/">chrysocode.io</a>)</figcaption></figure><p>Livrer régulièrement autorise à continuer de concevoir le code source comme s’il devait l’être en une seule fois. Et plus un système logiciel grossit, plus il devient difficile de l’adapter pour implémenter de nouvelles exigences. Au contraire, livrer continuellement, c’est concevoir le code en étant capable de l’adapter et de livrer n’importe quand, sans délai, ni surcoût.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*MalzIgtCtzFNS3pfOutE8A.png" /><figcaption>Coût du changement (<a href="http://chrysocode.io/">chrysocode.io</a>)</figcaption></figure><p>Pourquoi faut-il revoir la manière de concevoir le code ? Parce que chaque itération apporte son lot de changements qui déstabilisent l’existant des itérations précédentes, et que cet existant doit pouvoir évoluer en permanence et sur la durée, facilement et avec un niveau de confiance important et légitime dans la qualité des livrables.</p><p>Alors que faut-il changer dans la manière de concevoir le code pour livrer continuellement ? Il faut recourir à des méthodes qui sont elles-mêmes itératives et incrémentales, et qui intègrent complètement les tests au processus de développement comme un facteur décisif de la qualité logicielle. Les méthodes de conception logicielle issues du <em>Software Craftsmanship</em> — artisanat du code et compagnonnage logiciel —, sont seules à proposer cela, de sorte que bien maîtrisées, elles permettent de rendre un code source malléable et perméable au changement.</p><ul><li><a href="https://fr.wikipedia.org/wiki/Test_driven_development">Test-Driven Development</a> (TDD) : c’est une méthode de conception logicielle pour des conceptions simples et émergentes, et qui procède par changements minimaux et remaniements successifs.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*sj9yflwzIClZ5HT8CCi4xQ.png" /><figcaption>Cycle glogal de TDD (<a href="https://gearsoftesting.org/">GearsOfTesting.org</a> : <a href="https://gearsoftesting.org/tempo-of-testing.html">tempo des tests</a>)</figcaption></figure><ul><li><a href="https://en.wikipedia.org/wiki/Behavior-driven_development">Behavior-Driven Development</a> (BDD) : c’est une méthode de conception logicielle qui étend TDD, par l’apport de pratiques additionnelles, et qui explore et spécifie les besoins, en mettant l’accent sur la collaboration et en s’appuyant sur les tests et leur scénarisation.</li></ul><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ychayc_z6pFgRkLUC_C6sA.png" /><figcaption>Cycle global de BDD (étendu) (<a href="https://gearsoftesting.org/">GearsOfTesting.org</a> : <a href="https://gearsoftesting.org/tempo-of-testing.html">tempo des tests</a>)</figcaption></figure><ul><li>Architecture Hexagonale : c’est un style d’architecture dont les règles favorisent l’indépendance et la testabilité du modèle métier et de sa logique, en le préservant de toute corruption par des préoccupations techniques.</li><li><a href="https://en.wikipedia.org/wiki/Domain-driven_design">Domain-Driven Design</a> (DDD) : c’est un enrichissement du paradigme de la conception orientée objet, dont l’objectif est d’endiguer et briser la complexité accidentelle (complexité informatique qui ne répond pas à un besoin), en fournissant un référentiel de pratiques destinées à faire face aux problématiques récurrentes des projets d’entreprise.</li></ul><blockquote>Livrer continuellement, c’est concevoir le code en étant capable de l’adapter et de livrer n’importe quand, sans délai, ni surcoût.</blockquote><h4>Débit de fonctionnalités</h4><p>Un logiciel ne se réduit pas à des fonctionnalités, autrement dit un produit n’est pas égal à la somme de ses fonctionnalités. Tout développeur sait que la construction de n’importe quel produit logiciel induit beaucoup plus de choses que simplement des considérations fonctionnelles. Un exemple ? Bien concevoir la structure du logiciel, bien tester le comportement des composants et leur intégration, outiller et industrialiser tout ce qui est répétitif, etc. Pire encore, livrer rapidement des fonctionnalités, surtout à grande valeur ajoutée, laisse croire qu’on aurait trouvé une recette magique pour livrer bien, vite et pas cher. Or, agilité ou pas, tout bon gestionnaire de projet sait pertinemment qu’un projet réussi peut satisfaire à différents degrés les critères suivants mais jamais tous les quatre à la fois : périmètre, délais, coût, qualité.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pp-iIC1163MkLjSaOZiPDg.png" /><figcaption>Triangle de fer dans le rouge (<a href="http://chrysocode.io/">chrysocode.io</a>)</figcaption></figure><p>Par ailleurs, un logiciel de valeur n’est pas composé que de fonctionnalités à grande valeur ajoutée. Toutes les fonctionnalités n’ont pas la même valeur, loin s’en faut. Certaines auront une faible valeur, à tel point que le besoin était tacite et qu’il procédait de l’évidence dans l’esprit du client ; et pourtant, sans elles, le produit ne pourrait pas exister et n’aurait aucune valeur. D’autres fonctionnalités sont fortement attendues au regard d’un besoin explicite, et si elles ont plus de valeur que les premières, ont-elles la plus grande valeur ? Rien n’est moins sûr. Les fonctionnalités à la plus forte valeur ajoutée sont sans doute celles qui créent la surprise et de l’enchantement en ouvrant la voie d’un besoin nouveau et réinventé. En bref, même si toutes les fonctionnalités doivent être utiles, un produit de valeur regroupe des fonctionnalités aux valeurs hétérogènes.</p><p>Lus comme une mesure de la performance et de la productivité des équipes, les indicateurs clés de performance qui mesurent le nombre de fonctionnalités livrées par itération, ou encore le nombre de points d’estimation correspondants, institutionnalisent la confusion entre valeur et débit. Ces indicateurs ne devraient servir qu’à objectiver la prévisibilité d’une organisation.</p><h4>Problème de communication et de compréhension</h4><p>Le premier principe ne les nomme pas, et pourtant, il parle pour moitié des développements itératifs et incrémentaux : itératifs car on veut livrer tôt, incrémentaux car on veut livrer continuellement. Or on observe que beaucoup de transformations sont en fait alignées sur les erreurs conceptuelles de la traduction de ce principe : elles se focalisent sur le débit de fonctionnalités. Dans ces conditions, il est impossible de recueillir les bénéfices attendus des développements agiles. Les transformations laborieuses, voire en échec, le sont-elles à cause de ces erreurs ? Je ne saurais l’affirmer avec certitude, et ce ne peut être le seul facteur. Toutefois, ces erreurs n’aident pas à clarifier la nature des changements inhérents à toute transformation vers les Développements Agiles, d’autant qu’elles sont lues et reprises massivement en formation. Et la tâche n’est pas aisée d’expliquer à un décisionnaire que les équipes de développement vont désormais livrer moins mais mieux et continuellement, un produit utile, prêt à l’emploi, et non un débit de fonctionnalités à qualifier, et aussi changer leurs méthodes d’ingénierie pour relever le défi, quand la promesse d’une Agilité mal interprétée laissait miroiter le contraire.</p><h3>Un Manifeste du développement logiciel</h3><p>Dans de nombreuses transformations, l’Agilité est exclusivement affaire d’organisation. Or une transformation bien menée devrait toujours comporter des coaches aux expertises complémentaires :</p><ul><li>l’organisation de l’entreprise,</li><li>l’organisation dans les équipes,</li><li>l’ingénierie logicielle.</li></ul><p>Pourtant, quelque part, c’était inscrit dès le départ, le manifeste nous rappelle explicitement dans son titre que l’Agilité est intrinsèquement liée à la programmation : “Manifesto for Agile <strong>Software Development</strong>”.</p><p>Ce n’est pas un hasard si tous les principes du manifeste relèvent aussi du <em>Software Craftsmanship</em>. Quelques uns d’entre eux sont encore plus teintés de ses apports que d’autres : sans artisanat du code, il est impossible d’y satisfaire. De fait, sans une ingénierie logicielle exigeante, toute transformation agile est vaine.</p><ul><li>Le premier principe bien sûr, à cause des développement itératifs et incrémentaux.</li><li>Principe 9 : “Continuous attention to technical excellence and good design enhances agility.” Comment arrive-t-on à l’excellence technique et à bien concevoir des logiciels ? Par la pratique, l’entraînement et le partage : le compagnonnage logiciel est à l’origine de communautés de pratiques pour les développeurs, qu’elles soient externes ou internes, et de l’animation de dojos de programmation.</li><li>Principe 10 : “Simplicity — the art of maximizing the amount of work not done — is essential.” Comment simplifie-t-on les logiciels et évite-t-on d’en faire des usines à gaz ? Comment appliquer la loi de Pareto au logiciel ? En cassant la complexité, et <a href="https://fr.wikipedia.org/wiki/Test_driven_development">TDD</a>/<a href="https://en.wikipedia.org/wiki/Behavior-driven_development">BDD</a>/<a href="https://en.wikipedia.org/wiki/Domain-driven_design">DDD</a> sont des armes de choix pour y parvenir.</li><li>Principe 11 : “The best architectures, requirements, and designs emerge from self-organizing teams.” Comment fait-on émerger de meilleures architectures ? En partageant les aspirations du <em>Software Craftsman</em>, ou Artisan Développeur, au sein de son équipe, notamment professionnalisme, pragmatisme et fierté.</li></ul><blockquote>Sans ingénierie logicielle exigeante, toute transformation agile est vaine, nulle et non avenue.</blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pPEx8aTkGu0vGSXtsTWx0w.png" /><figcaption>Roue du dojo du Software Craftsmanship (<a href="http://chrysocode.io/">chrysocode.io</a>)</figcaption></figure><h3>Conclusion</h3><p>Le <a href="https://agilemanifesto.org/">Manifeste pour les Développements Logiciels Agiles</a> apporte un éclairage substantiel sur une approche novatrice du logiciel. Il aide à réfléchir aux changements d’envergure à apporter dans la manière de produire des logiciels à sa rédaction en 2001, et il offre un guide quant à la nature de ces changements. Pour autant, ce n’est pas une solution clé en main, mais bien plutôt un cadre de réflexion général : il faut savoir l’interpréter correctement pour que sa proposition de valeur se traduise en avantages réels pour les organisations, qu’il s’agisse d’avantages humains ou économiques.</p><p>Les réflexions de cet article sont au cœur de mon activité, sachant que je suis <a href="https://chrysocode.io/">consultant indépendant en Stratégie IT</a> et que j’interviens notamment en tant que <a href="https://chrysocode.io/conseil.html">Coach Craftsmanship</a>. Or j’ai pu constater deux phénomènes préjudiciables qui éloignent les organisations des avantages attendus d’une transformation agile.</p><ol><li>Des organisations financent parfois une transformation agile uniquement pour rassurer les actionnaires et séduire les profils à recruter. Dès lors, l’accompagnement mis en place ne sert qu’à acheter une étiquette, un coup de tampon, une vitrine. C’est une Agilité de façade qui n’influera jamais sur l’avenir de ces organisations, sinon à précipiter leur chute en consommant plus vite leurs ressources (temps et finances).</li><li>De nombreux cabinets de conseil sont sollicités pour déployer des dispositifs de transformation agile, mais autant ils peuvent être au fait des changements managériaux agiles, autant ils ne savent parfois pas du tout quoi faire des principes du manifeste qui touchent à l’ingénierie logicielle. Aussi les passent-ils simplement sous silence, de sorte que la transformation observée n’est que partielle et éphémère, même si ce n’est jamais communiqué.</li></ol><p>En réponse à cela, les trois erreurs majeures exposées pourraient servir à identifier ce qui serait parmi les axes principaux de toute transformation pour des Développments Agiles.</p><p>En vous livrant cette analyse, je mets de nouveau à jour ce que je perçois depuis un moment déjà comme les limites et les failles du manifeste. Si je devais poursuivre ma démarche en le révisant, l’adaptant, l’actualisant, je voudrais partir d’une image mentale plus exacte et précise. Puis je commencerais, par exemple, par fusionner le <a href="https://agilemanifesto.org/">manifeste agile</a> et celui du <a href="http://manifesto.softwarecraftsmanship.org/">Software Craftsmanship</a>. Aussi je vous livre dans un premier temps cette infographie des principes illustrés du manifeste agile. Grâce à la licence choisie, vous êtes libres de l’insérer, de l’afficher, de l’imprimer et de la diffuser comme bon vous semble.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wlPJeTxTaIr1xs1RZUD_Uw.png" /><figcaption>Principes illustrés du Manifeste Agile (<a href="http://xavierpigeon.com/">xavierpigeon.com</a>)</figcaption></figure><h4>Formats imprimables</h4><ul><li><a href="https://flic.kr/p/2h9Z2uW">Format A4</a></li><li><a href="https://flic.kr/p/2h9XhPK">Format A3</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8f38b8300274" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Du Test First Design au Test-Driven Development]]></title>
            <link>https://medium.com/@xavier.pigeon/du-test-first-design-au-test-driven-development-a07b05fdff6?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/a07b05fdff6</guid>
            <category><![CDATA[tdd]]></category>
            <category><![CDATA[software-craftsmanship]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[agile-testing]]></category>
            <category><![CDATA[test-driven-development]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Thu, 14 Feb 2019 16:16:58 GMT</pubDate>
            <atom:updated>2020-02-19T22:57:29.449Z</atom:updated>
            <content:encoded><![CDATA[<p>Un débat épineux fait rage depuis la nuit des temps — ou presque — à propos des tests unitaires de <a href="https://fr.wikipedia.org/wiki/Test_driven_development">TDD</a>. Voyons plutôt à côté de quoi tellement de développeurs et de passionnés sont passés. Remontons aux origines de TDD pour découvrir ensemble la vérité ! Tout un travail d’enquête ne sera pas de trop pour résoudre enfin cette triste et sombre histoire… J’indiquerai à la fin de l’article mes sources pour prouver et soutenir son contenu.</p><p>Aux prémisses de TDD, il s’agissait simplement d’écrire les tests avant de coder, et cela s’appelait <em>Test First Design</em>. Puis la méthode évolua vers une granularité plus fine de développement : pour une ligne de test en échec, une ligne de code de production est écrite pour faire réussir le test. Afin d’entériner cette granularité de ligne à ligne entre code de test et de code de production, trois lois ont émergé.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/199/1*H-sXLCwYZvzgT5tPxFLzVw.png" /><figcaption>Parallèle avec les 3 lois de Képler</figcaption></figure><ol><li>Loi n°1 : “Vous ne pouvez pas écrire un code de production tant que vous n’avez pas écrit un test unitaire qui échoue.”</li><li>Loi n°2 : “Vous ne pouvez pas écrire plus d’un test unitaire que nécessaire pour échouer, et ne pas compiler revient à échouer.”</li><li>Loi n°3 : “Vous ne pouvez pas écrire plus de code de production que nécessaire pour que le test actuellement en échec réussisse.”</li></ol><p>Ces lois sont ici énoncées selon les termes utilisés en 1999. Or l’emploi de l’expression “<a href="https://fr.wikipedia.org/wiki/Test_unitaire">test unitaire</a>” dans les deux premières lois prête ici largement à confusion. Par test unitaire, ces lois ne désignent pas un cas de test complet, mais en fait une <strong>unique assertion </strong>de test. Comment pourrait-on parler d’une granularité de ligne à ligne sinon ? Le cas de test complet devrait être obtenu après avoir itéré plusieurs fois l’ensemble de ces 3 lois, sachant que la résolution d’une erreur de compilation constitue déjà une itération à part entière. En 2014, Robert C. Martin reformule d’ailleurs les trois lois de TDD et le terme “unitaire” disparaît.</p><p>Une formulation exacte et exempte de toute ambiguïté serait plutôt comme suit.</p><ol><li>Loi n°1 : Vous devez écrire un test qui échoue avant de pouvoir écrire le code de production correspondant.</li><li>Loi n°2 : Vous devez écrire une seule assertion à la fois, qui fait échouer le test ou qui échoue à la compilation.</li><li>Loi n°3 : Vous devez écrire le minimum de code de production pour que l’assertion du test actuellement en échec soit satisfaite.</li></ol><p>On fait ainsi la distinction entre l’assertion à l’origine de l’échec du test et le test qui échoue lors de son exécution. De plus, on ne présume pas de la forme de test la plus adéquate, ni ne se restreint à une seule possible, ce qui est d’autant plus pragmatique. Le fait de mettre bout à bout les 3 lois de TDD en une seule itération constitue ce qui est appelé un <strong>nano-cycle</strong> de TDD. À noter que ces 3 lois ne couvrent que les conditions à respecter en TDD pour arriver à un test qui réussit, en exprimant le minimalisme attendu du test en échec. Elles sont à la charnière des étapes de la phase amont de TDD, appelée Code-Driven Testing (à gauche dans le schéma ci-dessous).</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w_ejMzqlbeHEC-6VczKcEg.png" /><figcaption>Processus cyclique de TDD et micro-cycles itératifs de conception</figcaption></figure><p>À la lumière de ses origines, on comprend mieux que TDD n’est pas défini par le choix des tests unitaires, qu’inversement les tests unitaires ne sont pas non plus définis par la pratique de TDD. De fait, TDD n’émet pas de restriction sur les formes de test à mettre en œuvre, et le fait de recourir successivement à différentes formes de test ne signifie en aucune manière que nous cessons brutalement d’appliquer TDD. Tout en appliquant TDD, il est en vérité tout aussi intéressant de s’appuyer sur des tests unitaires, des tests d’acceptation métier, des tests d’intégration de composant, des tests d’intégration système, et finalement n’importe quel test susceptible d’influencer positivement la conception du logiciel. Car rappelons-le : TDD n’est pas une méthode de test, mais bien une méthode de conception, qui s’appuie sur des tests.</p><p>Par conséquent, il est vain et inapproprié de chercher à redéfinir la notion de test unitaire en considération d’une interprétation quelconque de TDD. S’il existe deux formes de test qui n’ont pas la même taille de sujet de test ou qui ne poursuivent pas les mêmes objectifs de vérification, il est simplement normal qu’elles portent des noms différents. Pour rappel, la notion d’unité dans les tests unitaires vient du fait qu’un test unitaire porte sur une unité de programmation, une et une seule. Une unité de programmation est définie en fonction du paradigme de programmation. Ainsi :</p><ul><li>En <a href="https://fr.wikipedia.org/wiki/Programmation_orient%C3%A9e_objet">programmation orientée objet</a>, une unité de programmation est un objet.</li><li>En <a href="https://fr.wikipedia.org/wiki/Programmation_proc%C3%A9durale">programmation procédurale</a>, une unité de programmation est une procédure.</li><li>En <a href="https://fr.wikipedia.org/wiki/Programmation_fonctionnelle">programmation fonctionnelle</a>, une unité de programmation est une fonction.</li></ul><p>En corollaire, si le sujet de test est plus gros qu’une unité de programmation, alors le test n’est pas unitaire. Un test qui vérifie le respect d’une règle métier en instanciant plusieurs objets pour constituer son sujet de test est un <strong>test d’acceptation métier</strong>.</p><p>Plus généralement, l’étude et l’analyse des formes spécifiques de test, autrement dit la <a href="https://gearsoftesting.org/test-typology.html">typologie des tests</a>, n’est pas dans le giron du Software Craftsmanship, pas davantage que les <a href="https://gearsoftesting.org/">stratégies de test</a> ne le sont. Le <a href="http://manifesto.softwarecraftsmanship.org/">Software Craftsmanship</a> est une mouvance de l’ingénierie logicielle qui fédère une communauté de professionnels autour de méthodes de conception et de méthodes collaboratives pour produire des logiciels utiles et de grande qualité, dans le cadre de partenariats. Ces méthodes de conception s’appuient généralement sur les tests automatisés, et plus précisément des pratiques de test, mais elles ne distinguent pas les différentes formes de test entre elles, et ce n’est pas leur préoccupation. Il est tout au plus question de doublures de test (simulacre, bouchon, espion de test, etc). Et cela vaut évidemment pour TDD.</p><p>Or les pratiques de test du Software Craftsmanship ne manquent pas et forment un terrain propice à l’exploration pour tous les aventuriers du code avides d’excellence, comme en témoigne l’infographie que je vous propose ci-après.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dWH3h044FsNVBobbOnIRGg.png" /><figcaption>Pratiques de TDD, avec ses 3 lois actualisées</figcaption></figure><p><strong>Références</strong></p><ul><li>Clean Code, A Handbook of Agile Software Craftsmanship, Robert C. Martin, p. 122</li><li><a href="http://blog.cleancoder.com/uncle-bob/2014/12/17/TheCyclesOfTDD.html">The Cycles of TDD</a>, Robert C. Martin</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a07b05fdff6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Quand les tests coûtent-ils ?]]></title>
            <link>https://medium.com/@xavier.pigeon/quand-les-tests-co%C3%BBtent-ils-243b7a41bdb6?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/243b7a41bdb6</guid>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[regression-testing]]></category>
            <category><![CDATA[agile-testing]]></category>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[test-pyramid]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Mon, 28 Jan 2019 14:17:12 GMT</pubDate>
            <atom:updated>2019-02-27T17:06:40.824Z</atom:updated>
            <content:encoded><![CDATA[<h3>Quand les tests coûtent-ils ?</h3><p>Si l’absence de test a un coût — celui des anomalies et de la non-qualité — , le coût des tests réalisés est plus difficile à appréhender, entre un retour sur investissement issu de gains espérés supérieurs aux coûts d’implémentation et des surcoûts cachés ou superflus. Alors comment réduire le coût des tests pour optimiser une stratégie de test et augmenter ses chances de succès ?</p><h3>Des Tests Utiles</h3><p>Qu’un test réussisse ou qu’il échoue, on veut tous qu’il le fasse, mais pour de bonnes raisons. Rien de plus frustrant qu’un test qui échouerait alors que le code testé n’a pas de défaut, ou pire encore, un test qui réussirait quand bien même le code testé comporte des défauts. On le voit bien : le statut d’un test après exécution ne se résume pas de façon binaire à un succès ou à un échec. Il y a même une façon précise de clarifier ces nuances en associant quatre mots seulement. Si un test réussit, on parle de résultat négatif : il n’a détecté aucun défaut. Si un test échoue, on parle de résultat positif : il a détecté un défaut, comme un réactif qui change de couleur en réagissant avec sa cible dans un tube à essai. Si le statut du test correspond à la réalité, on dit que le résultat est vrai, sinon qu’il est faux. On retrouve le même vocabulaire en Science, notamment en médecine, biologie et chimie, où le diagnostic peut être vrai ou faux.</p><p>Par conséquent, on souhaite rencontrer idéalement des vrais-négatifs ou des vrais-positifs, mais on redoute les <a href="https://fr.wikipedia.org/wiki/Faux_positif">faux-positifs</a> assimilables à du bruit et qui nous font perdre du temps en investigation inutile, et plus encore les <a href="https://fr.wikipedia.org/wiki/Faux_n%C3%A9gatif">faux-négatifs</a> assimilables à du silence et qui coûteront encore plus cher. En effet, les faux-négatifs coûtent une automatisation qui n’a pas porté tous ses fruits, le coût augmenté d’une correction tardive puisque relevée en production, une perte d’image et de confiance vis-à-vis des utilisateurs et clients qui se traduit généralement en pertes financières, et le coût du délai des fonctionnalités qui sortiront plus tard pendant qu’on corrige les anomalies manquées.</p><p>Les quatre quadrants ci-après résument bien, de manière visuelle, les quatre statuts possibles après exécution d’un test, en les associant à des situations vécues sur le terrain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CC0hnEqHNcZTLG1G1BW-IQ.png" /><figcaption>Quadrants du statut des tests, sur <a href="http://gearsoftesting.org/">gearsoftesting.org</a></figcaption></figure><p>Savoir distinguer <a href="https://fr.wikipedia.org/wiki/Faux_positif">faux-positifs</a> et <a href="https://fr.wikipedia.org/wiki/Faux_n%C3%A9gatif">faux-négatifs</a> est une condition pour améliorer les processus de développement et réduire les coûts liés aux tests.</p><ul><li>On chasse définitivement les faux-négatifs en mettant en place du <a href="https://gearsoftesting.org/tempo-of-testing.html">Defect-Based Testing</a> : pour chaque anomalie manquée, on crée un test qui vérifie sa correction.</li><li>On chasse les faux-positifs par de bonnes pratiques de test, en commençant par les <a href="https://gearsoftesting.org/legacy-tests.html">principes FIRST</a> pour augmenter la valeur des tests.</li></ul><p>Et quid des vrais-positifs ? Au fait, pourquoi ces tests ont-ils échoué ?</p><h3>Tests &amp; Régressions</h3><p>Quand un test donne un vrai-positif, c’est qu’il a détecté une régression, c’est-à-dire un altération indésirable du comportement du logiciel après que ce dernier a fonctionné au moins une fois.</p><p>Parmi les régressions, certaines sont <a href="https://en.wikipedia.org/wiki/Software_regression">locales</a>, c’est-à-dire qu’elles portent sur le code récemment modifié, voire en cours de modification. Si un code source est couvert par les tests A, B et C, eux-mêmes écrits dans cet ordre chronologique, alors il est possible qu’au moment où le test C passe, les tests A ou B précédemment en succès échouent désormais. Il convient donc de corriger le code modifié pour que tous les tests qui le couvrent passent ensemble. Peut-être est-il même plus commode d’annuler les modifications en cours, comme on le fait en <a href="https://medium.com/@kentbeck_7670/test-commit-revert-870bbd756864">TCR</a>, acronyme qui signifie “test &amp;&amp; commit || revert” : si les tests réussissent, on valide le changement par un commit, sinon on efface les modifications en cours.</p><p>Au contraire, d’autres régressions portent sur du code qui n’a pas été modifié. Or des tests portant sur ce code inchangé échouent, car le code modifié a eu un impact par effet de bord sur un code inchangé. Ce sont des régressions <a href="https://en.wikipedia.org/wiki/Software_regression">distantes</a>, en cascade ou par effet de bord. Faut-il conserver en l’état les tests en échec ou le code ? Il faudra donc choisir au cas par cas entre corriger le code pour que tous les tests passent de nouveau d’une part, et mettre à jour les tests qui couvrent le code inchangé d’autre part. Des régressions distantes surviennent quand on n’a pas anticipé tous les impacts fonctionnels d’un changement, que ce soit sur le code de production ou sur les tests. Soit le code a raison et les tests sont en retard, auquel cas on a découvert un impact souhaité sur le produit ; soit les tests ont raison et le code est dysfonctionnel, auquel cas on a découvert un impact indésirable sur le produit : dans les deux cas, on découvre un impact imprévu sur le produit. Cela prouve que le code applicatif et le code des tests relèvent tous les deux d’un impact sur le produit et sont indissociables de ce point de vue-là.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*so6iaSgN0LEZXf_KRS-U3g.png" /><figcaption>Réagir face aux {vrai, faux}x{positif, négatif}</figcaption></figure><p>Soit dit en passant, tout test capable de détecter une <a href="https://en.wikipedia.org/wiki/Software_regression">régression locale</a> est un test de régression : le code testé a été modifié et il est plus fortement susceptible d’avoir régressé. Et tout test capable de détecter une <a href="https://en.wikipedia.org/wiki/Software_regression">régression par effet de bord</a> est un test de non-régression : le code testé n’a pas été modifié et il est plus fortement susceptible de n’avoir pas régressé.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rhbVvFMS5-zCLv4-HaUtOg.png" /><figcaption>Test de régression vs test de non-régression : que chassent-ils ? Cf. la <a href="https://gearsoftesting.org/jungle-of-testing.html">jungle des tests</a>, sur <a href="http://gearsoftesting.org/">gearsoftesting.org</a>.</figcaption></figure><p>Toutefois, la valeur première des tests automatisés n’est pas de détecter les régressions, pas dans une démarche mature d’ingénierie logicielle et des tests en tout cas. Cette valeur première est de se focaliser sur l’heuristique du problème et l’émergence d’une solution qui répond avec pertinence et justesse à un besoin. Ici, je mets en opposition <a href="https://fr.wikipedia.org/wiki/Test_driven_development">Test-Driven Development</a> (TDD) et Test-Last Development. En effet, l’on perd au moins la moitié de la valeur des tests automatisés en Test-Last Development, et la détection des régressions, même si elle n’en est pas moins indispensable, devient un bénéfice additionnel en TDD.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w_ejMzqlbeHEC-6VczKcEg.png" /><figcaption>Processus cyclique des développements pilotés par les tests (TDD)</figcaption></figure><h3>Tests Complémentaires</h3><p>Si je fais uniquement des tests unitaires et que j’atteins une couverte à 100% du code, mon logiciel est-il bien testé ? Non : une anomalie peut passer à travers car les tests unitaires ne vérifient que la logique métier, et non la bonne collaboration entre composants, ni les cinématiques de l’IHM, ni les performances. Si je recours à des tests unitaires, d’intégration et systémiques, mon logiciel est-il bien testé ? Peut-être, mais si ces tests vérifient les mêmes choses et cassent pour les mêmes raisons, les coûts d’implémentation et de maintenance explosent. Si je remplace les tests unitaires et d’intégration par des tests fonctionnels pour vérifier tout à la fois la logique métier, la bonne collaboration entre composants et les cinématiques de l’IHM, mon logiciel est-il bien testé ? Non : cela revient à automatiser les tests certes, mais une automatisation sans aucune stratégie. On appelle même cette non-stratégie le cornet de glace. Or faire preuve de stratégie dans l’automatisation des tests veut que l’on tire à terme le meilleur profit de l’effort consenti à l’automatisation des tests sous leurs différentes formes, à la lumière de leurs complémentarités. Cela implique de tenir compte des forces et faiblesses des différentes catégories de test. Tour à tour, on souhaite que des formes de test se focalisent sur la logique métier, la collaboration, les exigences fonctionnelles et non-fonctionnelles, et les besoins, tout en gérant au mieux la combinatoire des entrées et des sorties, le contrôle des résultats, en fournissant des résultats fiables et rapidement, avec des coûts d’implémentation et de maintenance minimaux. Vouloir tout cela à la fois en employant un moyen unique, c’est un peu comme si nous voulions un pistolet de manche avec un chargeur illimité, capable d’un verrouillage de cibles multiples par connexion neuronale, qui produise des explosions avec effet de zone, … Même les <em>Men in Black</em> n’ont pas ça dans leur vaste arsenal. Il faut donc accepter de diversifier notre arsenal de tests et d’adapter l’arme au champ de bataille et à la menace.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*LLDr2PsttPicE2TZl3WqFQ.png" /><figcaption><a href="https://gearsoftesting.org/test-typology.html">Pyramide des tests</a> revue et disponible sur <a href="http://gearsoftesting.org/">gearsoftesting.org</a></figcaption></figure><p>En jouant avec la complémentarité des différentes catégories de tests, nous allons certes tester les mêmes lignes de code d’un logiciel, mais nous allons surtout tester plusieurs facettes distinctes de son fonctionnement. Cela rend-il les tests redondants ? Justement non : complémentaires oui, redondants non. Qu’est-ce qui rendrait les tests redondants ? C’est le fait de les avoir implémentés de telle sorte que des tests de catégories différentes cassent en même temps pour les mêmes anomalies. Au contraire, si un test unitaire échoue, on veut que ce soit seulement à cause de la logique métier ; si un test d’intégration échoue, on veut que ce soit seulement à cause de la collaboration entre composants ; si un test fonctionnel échoue, on veut que ce soit seulement à cause de la cinématique de l’IHM ; etc. Dans une stratégie de test, chaque catégorie de test a un rôle à jouer, mais il ne faut pas mélanger les objectifs de test entre catégories dans un même test. En conséquence, quand un test échoue, il doit permettre d’identifier la cause de l’échec au plus près de la source de l’anomalie.</p><p>Les tests redondants coûtent cher. D’ailleurs, la redondance est l’un des critères, le premier, des <a href="https://gearsoftesting.org/legacy-tests.html">tests <em>legacy</em></a>, que je réunis sous l’acronyme <a href="https://gearsoftesting.org/legacy-tests.html">RaFFISH</a>. En revanche, distribuer stratégiquement l’effort des tests conduit à des réductions de coût.</p><h3>Tests Durables</h3><p>Vos tests sont-il durables ? Autrement dit, quel est leur impact sur l’environnement — vital, et non d’exécution ?</p><p>Pour que les tests soient durables, il faut que le logiciel testé le soit également. Un logiciel durable à mon sens doit être un logiciel utile, c’est-à-dire qu’il répond à un besoin : inutile de consommer des ressources en versionnage, en compilation, en exécution des tests, en installation et déploiement, ainsi qu’à l’utilisation, si ce logiciel ne sert à rien ou pas grand chose. Il faut aussi que ce logiciel soit efficace, c’est-à-dire qu’il fasse un usage approprié et rentable de ses ressources, et qu’il consomme des ressources proportionnées à son objectif. Dans le cas contraire, les tests feront travailler fréquemment un logiciel inefficace et aggraveront son impact sur l’environnement.</p><p>Exécuter des tests capables d’intercepter des anomalies rend ces tests utiles. Des tests utiles sont durables s’ils sont efficaces, c’est-à-dire qu’ils font un usage approprié des ressources de test, et qu’il y a un rendement entre la consommation de ressources à leur exécution dans le temps et le nombre de fois qu’ils interceptent des anomalies. Pour cela, il faut savoir, dans un processus cyclique de développement, quand exécuter quels tests en anticipant les impacts d’un changement de code, ainsi qu’ordonner l’exécution des tests pour que les tests les plus susceptibles d’échouer soient exécutés plus souvent et les tests les plus susceptibles de réussir soient exécutés après les premiers. La distinction entre tests de régression et tests de non-régression devient indispensable pour des tests durables.</p><p>Le soin apporté à la complémentarité des tests dans une stratégie d’automatisation contribue à raréfier les formes de test les plus consommatrices de ressources et à multiplier en très grand nombre des formes de test dont la consommation est beaucoup plus restreinte, voire négligeable.</p><p>Les campagnes de tests manuels quant à elles ne sont pas durables, et à plus d’un titre, du point de vue environnemental comme humain, car leur coût d’exécution ne fait qu’augmenter à mesure qu’un produit logiciel grossit, et surtout ce n’est pas respecter la nature humaine que d’exiger d’un humain qu’il accomplisse ce qu’une machine peut faire aussi bien, voire mieux que lui.</p><p>En minimisant l’emprunte environnementale des tests, on diminue leurs coûts. Mais comment s’en assurer ? En associant à chaque catégorie de test des ressources autorisées et une quantité de ressources nécessaires à son exécution, qu’il s’agisse de CPU et de temps d’exécution, de RAM et d’objets, d’espace disque et de fichiers (bases de données incluses), de réseau et de trafic, etc.</p><ul><li>Plus un test est bas dans la pyramide, plus les ressources autorisées sont restreintes, ainsi que la quantité de ces ressources. Au contraire, plus un test est haut, plus les ressources autorisées sont nombreuses et la quantité de ces ressources importante.</li><li>Si le test utilise une ressource non-autorisée ou que le seuil maximal est dépassé, le test échoue automatiquement. Et le rapport de test doit indiquer qu’il s’agit d’une erreur d’exécution, et non d’un échec du test.</li><li>Un seuil global peut être appliqués à l’ensemble des instances de test d’une même catégorie. Par exemple, tous les tests fonctionnels doivent être terminés en un temps cumulé inférieur ou égal à 30 minutes.</li></ul><p>On peut ainsi lier tests durables, empruntes de test (ressources et quantités) et industrialisation.</p><h3>Conclusion</h3><p>Finalement, les tests coûtent quand ils donnent des faux-positifs ou des faux-négatifs, quand ils sont utilisés après codage, voire après livraison lors de recettes usine, quand ils sont redondants, quand ils sont utilisés à des fins d’automatisation sans stratégie, ou encore quand ils sont mis en œuvre sans considération de leur impact environnemental et humain. Parmi ces coûts, certains sont des gaspillages ou des occasions manquées.</p><p>Afin de maîtriser et réduire le coût global des tests, qui inclue toutes les formes de coût, il faut que les tests soient utiles en détectant les anomalies quand elles surviennent, que leur valeur soit optimisée par le recours aux tests avant les développements, que les tests soient implémentés dans le cadre d’une stratégie cohérente d’automatisation, et que les tests soient durables dans le respect de l’environnement et de la nature humaine.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=243b7a41bdb6" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Test-Driven Writing : TDD appliqué à l’écriture]]></title>
            <link>https://medium.com/@xavier.pigeon/test-driven-writing-tdd-appliqu%C3%A9-%C3%A0-l%C3%A9criture-ef587f6d56eb?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef587f6d56eb</guid>
            <category><![CDATA[wikipedia]]></category>
            <category><![CDATA[ecriture]]></category>
            <category><![CDATA[craftsmanship]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[tdd]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Thu, 03 Jan 2019 10:42:35 GMT</pubDate>
            <atom:updated>2019-01-03T10:53:12.899Z</atom:updated>
            <content:encoded><![CDATA[<h3>Test-Driven Writing : TDD appliqué à l’écriture</h3><p>Que pourrait donner l’application des principes de Test-Driven Development (TDD) à la réécriture d’une page de <a href="https://www.wikipedia.org/">Wikipédia</a> ? Et quitte à le faire, et si cette page était précisément celle de TDD ! Je m’étais donné comme objectif en 2018 de réécrire entièrement la page de <a href="https://fr.wikipedia.org/wiki/Test_driven_development">TDD</a> sur Wikipédia, à l’état d’ébauche. C’est maintenant chose faite, après une première étape en 2015 où j’avais déjà remplacé le schéma du cycle de développement de TDD.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*w_ejMzqlbeHEC-6VczKcEg.png" /><figcaption>Schéma du cycle de TDD</figcaption></figure><p>Ma démarche de réécriture a été semblable au cycle micro-itératif de TDD. Je cible un paragraphe, puis une idée tirée de ce paragraphe. Quelle est précisément l’idée élémentaire identifiée ? Quels mots utiliser pour l’exprimer avec concision ? En quoi puis-je l’exprimer avec plus de clarté, une tournure fluide, avec pédagogie ? Quels sont les concepts associés, même implicitement ? Lesquels peuvent manquer ? Ce seront là mes critères minimaux : tant qu’ils ne sont pas satisfaits, l’idée ciblée est insuffisamment développée pour passer le test. Je commence par un paragraphe vide au-dessus de celui visé. Puis j’écris un premier jet qui apporte le minimum de sens acceptable en mettant bout à bout les concepts-clés. Ce premier jet fait même émerger un fil directeur, mais à ce stade, il est à peine perceptible. Pour qu’il le devienne vraiment, je dois procéder à des <a href="https://fr.wikipedia.org/wiki/R%C3%A9usinage_de_code">remaniements</a> successifs. Quel est ce fil directeur manquant pour relier les concepts afférents à l’idée de départ de façon évidente ? Éventuellement, le début d’une deuxième idée relative à TDD a-t-il émergé du développement de la première ? Le cas échéant, il faut l’en extraire pour les <a href="https://fr.wikipedia.org/wiki/S%C3%A9paration_des_pr%C3%A9occupations">séparer</a> : tant que les deux idées sont fusionnées dans le même paragraphe, elles se chevauchent, s’entremêlent, et restent inaudibles, comme si une classe occupait plusieurs responsabilités.</p><p>Ensuite j’itère de paragraphe en paragraphe, voire de phrase en phrase — tout dépend de la densité des paragraphes — , de façon à ne négliger aucune des idées existantes, qu’elles soient exprimées ou sous-tendues. Je m’astreins à ne développer qu’une idée par paragraphe, en suivant l’ordre logique des étapes dans le processus de développement de TDD. Chaque cycle d’écriture est donc susceptible de me faire avancer d’une étape dans le processus de TDD, afin d’en restituer les rouages, en couvrant progressivement le schéma de synthèse. Ces étapes successives font parfois fortuitement émerger de nouvelles idées à développer. Par exemple, j’en suis arrivé à expliquer de quelles manières TDD permet à tout un chacun de gagner en productivité, un point très délicat à défendre et à argumenter, alors que d’aucuns invoquent encore des a priori de coûts liés aux tests.</p><p>Enfin, pour chaque nouveau paragraphe écrit, je relis l’existant pour m’assurer que je n’omets rien. Alors seulement je m’autorise à supprimer une ou plusieurs phrases. Autrement dit, je confronte les deux versions alternatives, j’en fais l’examen, et si ce dernier est concluant, je substitue la nouvelle version à l’ancienne. Cela devrait vous rappeler le <em>Golden Master</em>, qui donne tout son intérêt au kata <a href="https://github.com/emilybache/GildedRose-Refactoring-Kata"><em>Gilded Rose</em></a>, ainsi que les tests dos-à-dos.</p><p>Du <a href="https://fr.wikipedia.org/w/index.php?title=Test_driven_development&amp;oldid=155356847">résultat</a> j’espère que vous tirerez une meilleure lecture et compréhension de cette méthode de conception logicielle à la fois si particulière et si puissante, et néanmoins mal comprise, voire décriée faute de maîtrise. L’idée de transposer TDD à autre chose que le développement logiciel n’est pas inédite, cela s’appelle même le <em>Test-Driven Work</em>.</p><p>En réécrivant la page de <a href="https://fr.wikipedia.org/wiki/Test_driven_development">TDD</a> par petits pas, je souhaitais faire un don personnel en empruntant le chemin du compagnonnage. J’ai aussi pensé aux candidats, développeurs ou testeurs, en entretien de recrutement, qui peuvent être en difficulté lorsqu’il leur est demandé d’expliquer TDD. Entre le <a href="https://fr.wikipedia.org/wiki/Test_driven_development#/media/File:Cycle-global-tdd.png">schéma</a> qui représente le cycle de développement de TDD et les explications textuelles, vous avez dorénavant toutes les clés en main pour triompher de cette épreuve ! Restera quand même à relever l’exercice de codage en TDD si l’on vous en propose un en entretien, auquel cas rien ne vaut la pratique.</p><p>Les contenus de Wikipédia doivent être sous une <a href="https://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Licence_de_documentation_libre_GNU">licence</a> permettant n’importe quelle utilisation, même commerciale, et modification. Aussi mes schémas relatifs à TDD et sous une licence moins permissive sont disponibles sur <a href="http://gearsoftesting.org/">gearsoftesting.org</a>, et plus précisément sur la page du <a href="https://gearsoftesting.org/tempo-of-testing.html">tempo des tests</a>.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*C99rJtHj0NZC1UTreDpjMA.png" /><figcaption>TDD et ses variations décomposés en concepts et pratiques</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef587f6d56eb" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tests & Aléas, ou comment s’amuser des tests]]></title>
            <link>https://medium.com/@xavier.pigeon/tests-al%C3%A9as-ou-comment-samuser-des-tests-67701a256279?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/67701a256279</guid>
            <category><![CDATA[random]]></category>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Wed, 21 Nov 2018 18:56:35 GMT</pubDate>
            <atom:updated>2018-11-23T16:59:53.862Z</atom:updated>
            <content:encoded><![CDATA[<p>Qui a dit que les tests logiciels sont des personnages ennuyeux ? Trop lents, trop prévisibles, trop répétitifs ? Ce ne serait pas leur rendre justice. Voyons un peu et jouons beaucoup.</p><p>Parmi toutes les formes de test que l’on rencontre, certains s’éloignent du déterminisme habituel, pour soumettre le sujet de test à des aléas. Il pourrait même s’agir de deux catégories de test d’ailleurs : d’un côté les tests déterministes pour effectuer encore et toujours les mêmes contrôles un nombre infini de fois, de l’autre les tests aléatoires pour contrôler ce qui n’a pas été anticipé.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/300/1*Orh5WQhDcbiY6p7SCwOdBg.jpeg" /></figure><p>Au départ, je m’amusais à regrouper mentalement quelques tests sans lien apparent entre eux, sinon celui d’avoir une dimension aléatoire ou d’avoir des noms d’animaux vivant dans la jungle. Et je proposais de fait ce petit défi : quelle différence y a-t-il entre “fuzz testing”, “monkey testing” et “gorilla testing” ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TANAonwLTrUouVYNLsLm5A.png" /><figcaption>Qu’y a-t-il d’aléatoire pour chacun de ces tests ?</figcaption></figure><p>Les noms anglais étaient là pour ne pas faciliter la tâche. En effet, “<a href="https://en.wikipedia.org/wiki/Fuzzing">fuzz testing</a>” se traduit par test à données aléatoires — difficile de faire plus explicite ! Une traduction littérale donnerait “test du duvet”… À se demander si l’on parle encore de logiciel ! “<a href="https://en.wikipedia.org/wiki/Monkey_testing">Monkey testing</a>” peut être traduit par test simiesque — assez prosaïque — ou encore, test aléatoire, fidèle au synonyme anglais “random testing” — déjà moins précis que le tout premier. Et puis, comme un intrus : “gorilla testing” qui semble n’avoir d’autre traduction que littérale a quand même un synonyme anglais qui vient nous sauver, à savoir “frustrating testing”. En tout cas, il y a de quoi se demander si l’on ne dérive pas vers l’armée simiesque du chaos inventée par <a href="https://fr.wikipedia.org/wiki/Chaos_Monkey">Netflix</a>. Mais non, du tout : la livraison en production n’a pas encore eu lieu, et nous restons bien dans un environnement de test.</p><p>Alors, qu’y a-t-il d’aléatoire, si c’est l’aspect aléatoire qui doit regrouper ces trois formes de test ? Sans surprise, dans le “fuzz testing” ou “fuzzing”, ce sont les données d’entrée du test qui sont générées de façon aléatoire avant de participer du contexte d’exécution. C’est une manière de vérifier en sortie que les propriétés ou les invariants d’un logiciel sont respectés plutôt que ses résultats, afin de découvrir des cas de test non prévus et pourtant intéressants : c’est l’objet du Property-Based Testing. Dans le “monkey testing”, il faut imaginer un singe curieux qui commencerait à taper sur un clavier d’une manière pas toujours cohérente car il cherche à comprendre ce qu’il découvre devant lui, de sorte que les cas de test qui s’ensuivent sont plutôt imprévisibles. Dans le “gorilla testing”, quelqu’un, un développeur ou un testeur a priori, est mis à contribution, pas nécessairement consentie, pour répéter des séquences d’actions manuelles de test, déjà effectuées par d’autres avant lui, toujours les mêmes cas de test, en se figurant peut-être que les mêmes causes n’entraîneront pas les mêmes effets, ce qui est assez absurde. Le cas échéant, il y a fort à parier que les nerfs du gorille soient mis à l’épreuve, et sa patience n’étant pas infinie, cela va dégénérer. Or un gorille qui se fâche, ça fait forcément des dégâts ! En extrapolant donc un peu en matière d’aléas, il m’est apparu que ce sont les conflits avec les testeurs qui sont aléatoires dans un tel contexte managérial. Quels testeurs vont servir de cobaye ? Combien de temps vont-ils accumuler de frustration et supporter ce supplice psychologique ? Quand le conflit va-t-il finir par exploser ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*y2PL6bchtK8Am5E3P2kp3g.png" /><figcaption>Fuzz testing vs monkey testing vs gorilla testing</figcaption></figure><p>À la réflexion, nous pourrions même en ajouter un petit dernier à cette jungle des tests. Pourquoi pas ?</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WYa4Ffymq8h2vyTrzW1ZIA.png" /><figcaption>Fuzz testing vs monkey testing vs gorilla testing vs mutation testing</figcaption></figure><p>Dans les tests par mutation, des mutants sont créés à partir du code à tester : on remplace une instruction par une autre pour obtenir une variante du code source de départ. Si des tests sont positifs, les mutants sont tués et les tests sont pertinents. Si les mutants survivent, les tests ne les ont pas vu passés, de même qu’ils ne verront pas certaines régressions survenir. Les tests par mutation permettent de quantifier objectivement le niveau de confiance que nous pouvons accorder à notre harnais de tests en vue de livrer de nouvelles versions d’un logiciel.</p><p>Après cela, comment dire que le code n’a pas la vie dure dans cette jungle ? Si ce n’est pas le code, c’est sans doute l’humain, et ce n’est jamais bon signe !</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=67701a256279" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Fork partiel avec Git]]></title>
            <link>https://medium.com/@xavier.pigeon/fork-partiel-avec-git-ef10710d0e0?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef10710d0e0</guid>
            <category><![CDATA[git]]></category>
            <category><![CDATA[fork]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Tue, 30 Oct 2018 11:07:43 GMT</pubDate>
            <atom:updated>2018-11-02T11:59:57.364Z</atom:updated>
            <content:encoded><![CDATA[<p>Vous avez sans doute déjà été confronté à la situation où vous avez mené quelque expérimentation dans un dépôt Git existant. Pour autant, vous aimeriez par la suite séparer le fruit de cette expérimentation et l’existant dans des dépôts Git distincts. C’est tout à fait faisable, en toute simplicité, et c’est ce que nous allons voir ensemble ici. Si vous souhaitez zapper les explications, allez directement à la fin de cet article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/320/1*gagEQ3GZitJYcSDCbws5vQ.png" /></figure><h3>Préparation</h3><p>Commencez par créer un fork du dépôt de départ et clonez le fork.</p><p>S’il vous reste des branches distantes autres que master, c’est le moment de décider ce que vous souhaitez en faire par rapport au dépôt Git nouvellement créé. Soit vous les fusionnez, soit vous les supprimez. Après une éventuelle fusion des premières, supprimez les indésirables.</p><pre>$ git branch -a<br>$ git push origin :&lt;unwanted_to_be_deleted&gt;</pre><p>Et dans le cas où elles seraient nombreuses, voici comment les supprimer en masse.</p><pre>$ git branch -a | grep -vE &quot;(master|HEAD)&quot; | grep -Po &quot;(?&lt;=origin/).*$&quot; | xargs -I{} git push origin --delete {}<br>$ git pull --prune</pre><p>L’option -P ou --perl-regex de grep interprète les expressions régulières compatibles avec Perl (<a href="https://www.pcre.org/">PCRE</a>), ce qui inclut les expressions d’<a href="https://en.wikipedia.org/wiki/Oniguruma">Oniguruma,</a> afin de spécifier une regex en préfixe d’une autre (cf. “<a href="https://www.regular-expressions.info/lookaround.html">lookaround-lookahead-lookbehind</a>”). L’option -o ou --only-matching n’affiche que les correspondances, et sur des lignes séparées.</p><p>La commande git pull --prune élague le graphe : les branches distantes supprimées du dépôt distant sont ainsi supprimées du dépôt local.</p><h3>Nouveau graphe</h3><p>Nous allons créer un nouveau graphe en créant une branche orpheline, comme l’est la branche master à la création d’un dépôt vide.</p><pre>$ git checkout --orphan new_master master<br>$ git commit -m &quot;Squash all commits coming from the forked repository.&quot;</pre><p>Avec git checkout, l’option --orphan &lt;new_branch&gt; crée une nouvelle branche, orpheline, nommée new_master en l’occurrence : le dépôt est revenu à l’état initial, c’est-à-dire qu’il n’existe aucun commit parent. De plus, la copie de travail est placée dans le même état que si le HEAD pointait sur le commit &lt;start_point&gt;, à savoir master dans le cas qui nous concerne. L’index contient donc déjà toute la copie de travail de master au moment où la commande git commit crée ici un premier commit de graphe.</p><p>Au besoin, nous pouvons nous rassurer sur l’absence d’une perte de contenu entre les 2 branches master. Après tout, ce n’est pas comme si nous faisions cette manipulation tous les jours.</p><pre>$ git diff master new_master</pre><p>À ce stade, l’ancien graphe visible depuis master existe toujours. Il est temps de remplacer l’ancien graphe par le nouveau (qui contient un seul commit).</p><pre>$ git branch -M new_master master<br>$ git push origin +master</pre><p>La commande git branch -m &lt;old_branch&gt; &lt;new_branch&gt; renomme une branche, et l’option -M au lieu de -m ignore l’existence d’une branche portant déjà le nouveau nom. Juste avant publication (push), une comparaison par références est encore possible : git diff origin/master master. Lors du git push, le symbole + devant master force la mise à jour de la branche distante, sachant que master et origin/master ont divergé.</p><h3>Nettoyage</h3><p>Supprimez tous les fichiers que vous conserverez uniquement dans le dépôt de départ du fork, et peut-être aussi ceux de l’expérimentation, de manière à ne conserver que le fruit utile de cette expérimentation.</p><pre>$ git rm -r &lt;a_file_name&gt; &lt;path/to/directory&gt;<br>$ git commit --amend</pre><p>L’option --amend de git commit permet de verser les changements validés de l’index dans le commit précédent. N’utilisez pas l’option --amend si vous souhaitez pouvoir revenir sur le choix des fichiers à supprimer un peu plus tard. Si vous n’utilisez pas --amend, vous pourrez toujours invoquer git rebase -i --root, et choisir un squash du deuxième commit du graphe, afin que ce dernier fusionne avec le tout premier. Vous réduirez par là-même la taille de votre dépôt au prochain passage du ramasse-miettes, ce qui est plutôt une bonne chose.</p><h3>En résumé</h3><p>Nous avons réalisé un fork de dépôt sans conserver l’historique du dépôt de départ, afin de n’en conserver qu’une partie. En une unique commande, cela donne :</p><pre>$ git checkout --orphan new_master master &amp;&amp; git commit -m &quot;Squash all commits coming from the forked repository.&quot; &amp;&amp; git branch -M new_master master &amp;&amp; git push origin +master # après fork et clonage</pre><p>L’avantage de cette solution est de construire un nouveau graphe indépendamment du premier. Le changement de graphe vu de la branche master ne survient qu’à la dernière étape, de sorte qu’il est possible de comparer les états entre les 2 graphes pour se rassurer au besoin, voire de tout annuler.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef10710d0e0" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[De 2011 à 2013]]></title>
            <link>https://medium.com/@xavier.pigeon/de-2011-%C3%A0-2013-30a620b1e555?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/30a620b1e555</guid>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Fri, 28 Sep 2018 12:19:03 GMT</pubDate>
            <atom:updated>2018-09-28T12:19:03.500Z</atom:updated>
            <content:encoded><![CDATA[<p>Mes précédents articles sont disponibles <a href="http://xpn-engine.blogspot.com/">ici</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=30a620b1e555" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Qualité Intrinsèque vs Qualité Extrinsèque]]></title>
            <link>https://medium.com/@xavier.pigeon/qualit%C3%A9-intrins%C3%A8que-vs-qualit%C3%A9-extrins%C3%A8que-f4adfcf7bd5b?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f4adfcf7bd5b</guid>
            <category><![CDATA[qualité-logicielle]]></category>
            <category><![CDATA[tests-logiciels]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Sun, 23 Sep 2018 14:04:37 GMT</pubDate>
            <atom:updated>2018-09-29T12:30:05.273Z</atom:updated>
            <content:encoded><![CDATA[<p>En matière de <a href="https://fr.wikipedia.org/wiki/Qualit%C3%A9_logicielle">qualité logicielle</a>, il existe deux visions antagonistes et irréconciliables. La manière historique de gérer la qualité nous vient, dirons-nous, d’un pays fort fort lointain.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/0*jvUYpObROrrDaMfU.jpg" /></figure><p>Dans cette contrée reculée, les processus règnent en maître, ils sont aux commandes des humains qui doivent les appliquer docilement. Dans de tels processus, la qualité est envisagée comme un événement ponctuel, qui survient dans le flux immuable d’une séquence. Comme les humains sont au service du processus, ils réalisent eux-mêmes les tests, à la main, à la force de leurs poignets, afin que le processus accepte leurs offrandes binaires. Le processus a décidé que les responsabilités devaient être séparées entre humains et que leurs livrables devaient être spécialisés en fonction des étapes-clés du processus. Dans ce monde idéalisé, la politique du zéro bogue est érigée en dogme, et les humains se transmettent des patates chaudes, en priant que leurs livrables ne soient pas entachés d’imperfection. Dans le cas contraire, le dogme ferait d’eux des cibles faciles dans la chasse rituelle et sacrificielle des coupables. Aussi, pour éviter qu’un tel drame ne survienne, l’on voue un véritable culte aux 100% de couverture de tests fonctionnels.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/775/1*XEEbZYyGhEv94q0u3soC_w.png" /><figcaption>Qualité en tant qu’événement</figcaption></figure><p>La spécialisation des tâches fait écho au <a href="https://fr.wikipedia.org/wiki/Taylorisme">taylorisme</a>, et si d’aucuns emploient leurs mains, d’autres les commandent et contrôlent, dans un dispositif à la structure pyramidale. Bien évidemment, contrôler la qualité, une fois que la non-qualité est inscrite dans le code et sa conception, atteint rapidement ses limites, en plus de manquer d’efficacité.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*vsQ3-Ji6TYDsgsEJ.jpg" /></figure><p>Pourtant, ce statu quo n’est pas une fatalité. Et il nous appartient en tant que professionnels du développement logiciel d’en changer. Car quand un processus ne convient pas, il devient une question de survie de le remplacer par une meilleure solution. Survie économique certes, mais aussi survie cérébrale tant la répétition assèche l’esprit et l’envie. Or sans esprit créatif et d’initiative, pas d’innovation.</p><p>Alors quelle alternative s’offre à nous ? Revenons dans nos contrées, et voyons ce que nous pouvons attendre d’une gestion globalisée de la qualité logicielle — par opposition à une gestion localisée. Le fait d’élever la qualité d’un logiciel rend possible de saisir de nouvelles opportunités, en permettant la mise en place du déploiement continu : sitôt qu’un changement de code apporte de la valeur aux utilisateurs, ce changement leur est livré automatiquement. C’est une dynamique beaucoup plus compétitive. Seulement elle repose sur un prérequis : puisque la frontière temporelle entre développeur et utilisateur devient extrêmement ténue, le code livré doit être irréprochable.</p><blockquote>La qualité intrinsèque rend possible le déploiement continu, où un code irréprochable va de pair avec une expérience de l’utilisateur irréprochable.</blockquote><p>Pour y parvenir, il faut commencer par remettre l’humain aux commandes : les personnes et les équipes passent au premier plan, de façon à porter une attention continue à la qualité. Dans un écosystème propice au rayonnement de l’expertise et de l’habileté, la qualité va pouvoir prendre une toute autre ampleur.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*Hi_2tG4LOenRxii0TKq_rQ.png" /><figcaption>L’humain aux commandes pour une attention continue à la qualité</figcaption></figure><p>Comme le potentiel humain est libéré de ses entraves, il peut désormais tirer profit de ce qui se fait de mieux selon les préoccupations à gérer :</p><ul><li>L’humain excelle dans l’exploration, la créativité, l’heuristique.</li><li>Les automates et leurs technologies concomitantes excellent dans la répétition et la précision.</li></ul><p>Là où l’un excelle, l’autre est mauvais, et inversement.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*aOATl08vnlZp3E27.jpg" /><figcaption>À chacun son domaine d’excellence.</figcaption></figure><p>En renforçant la collaboration au lieu de saucissonner les tâches et les livrables, les personnes partagent les mêmes objectifs, et de cette appropriation collective résulte une approche des problèmes et difficultés orientée vers la recherche des solutions — plutôt que des coupables.</p><p>Enfin, s’agissant de test, l’on teste juste assez, juste ce qu’il faut, afin de minimiser les efforts et de maximiser les résultats. Par ailleurs, adapter l’effort consenti aux tests, qu’ils soient automatisés ou manuels, implique d’anticiper et d’ajuster les risques que nous sommes prêts à prendre. Cette prise de risque est elle-même pondérée par la réduction des impacts des défauts résiduels et une forte réactivité en cas d’incident.</p><p>En conclusion, produire de meilleurs logiciels repose notamment sur deux piliers :</p><ul><li>Qualité non-négociable, plutôt que variable d’ajustement.</li><li>Qualité intrinsèque, plutôt qu’extrinsèque.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f4adfcf7bd5b" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Recherche “grand bidouilleur, champion de la bricole logicielle”]]></title>
            <link>https://medium.com/@xavier.pigeon/recherche-grand-bidouilleur-champion-de-la-bricole-logicielle-f509c267310e?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/f509c267310e</guid>
            <category><![CDATA[recrutement]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[recruiting]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Mon, 09 Jul 2018 10:44:16 GMT</pubDate>
            <atom:updated>2018-07-09T11:06:22.554Z</atom:updated>
            <content:encoded><![CDATA[<p>Les recruteurs rivalisent d’imagination pour rebaptiser les fiches de poste, voire les requalifier de bout en bout, dans une quête d’originalité. Même si cela peut partir d’une bonne intention comme se démarquer, la démarche n’est pas toujours exempte de quelques dérapages. Par exemple, le bidouilleur ou le bricoleur rejoignent assez mal l’image professionnelle d’un développeur logiciel. En plus d’être teintés d’amateurisme, ils désignent aussi des travaux manuels et sans qualification. Je n’exclus certainement pas le cas de l’amateur qui pourrait se montrer plus habile que le professionnel, mais une fois encore : si l’amateur est meilleur que le professionnel, c’est surtout le professionnel qui devrait s’en inquiéter ; pour autant, cela ne fait pas de l’amateur un professionnel.</p><p>Au-delà du choix du vocabulaire, toutes les allégories ne sont pas bonnes à prendre. Quid du domaine du bâtiment pour représenter la conception logicielle ? À éviter ! Dans <a href="https://fr.wikipedia.org/wiki/Test_driven_development">Test-Driven Development</a> (TDD), il faudrait que le bâtiment s’écroule avant même d’être construit. En conception émergente, les décisions de conception surviennent par accident : vous décrivez le problème comme l’encombrement de votre espace de vie et vous aboutissez à quelque chose qui répond parfaitement au besoin, mais ce n’est peut-être pas un grenier ni une niche, et vous découvrez une solution fortuite par des cycles micro-itératifs de codage. Le choix d’une niche en amont est déjà une solution prédéfinie, qui est restrictive et limitative. Dans le <a href="https://fr.wikipedia.org/wiki/R%C3%A9usinage_de_code">remaniement</a>, le code est un matériau malléable et flexible. Or il paraît difficile d’imaginer déplacer la hauteur sous plafond ou des murs porteurs sur site autrement qu’en petites briques de plastique. C’est une différence fondamentale qui oppose les méthodes prédictives et les méthodes adaptatives, et qui marque une rupture entre bâtiment et logiciel.</p><p>À trop vouloir vulgariser on en vient à la caricature. Et la caricature devient problématique quand elle contrevient à tous les efforts consentis par les ambassadeurs d’un savoir-faire pour revaloriser un métier qui a trop longtemps été perçu à tort comme celui d’exécutants techniques des basses besognes (cf. « pisseur de code »), alors que c’est un métier créatif et abstrait.</p><p>Je vous propose donc une échelle pour fixer quelques idées en la matière, non sans y trouver un peu d’amusement.</p><p>- Touriste du code : il visite et s’il modifie, au mieux c’est comme avant en moins bien, au pire plus rien ne fonctionne.</p><p>- Scribouillard de code : avec un peu de chance et après maintes tentatives, ça compile, mais le code atteint les sommets de l’illisibilité et la prochaine fois que son code devra être modifié, on aura plus vite fait de tout réécrire.</p><p>- Bidouilleur du code : ça marchotte si les conditions d’exécution sont favorables, moyennant une abondance de verrues. Plus grosse est la bidouille, plus proche est sa fin de vie.</p><p>- Bricoleur de code : c’est l’amateur éclairé qui est capable d’entreprendre un code qui marche bien, il sait quand s’arrêter pour passer le relais à un professionnel, notamment quand l’édifice prend de l’ampleur.</p><p>Finalement, à chaque fois qu’il faut préciser que l’on parle de code, on reste dans l’amateurisme.</p><p>- Programmeur : un professionnel qui réalise des tâches de programmation pour mettre en œuvre une solution définie.</p><p>- Analyste-programmeur : un professionnel qui est capable d’analyser un problème complexe et de trouver une solution viable.</p><p>- Développeur : un professionnel qui conçoit des applications logicielles complexes.</p><p>- Développeur artisan : un professionnel qui sait gérer la qualité d’applications logicielles tout en réduisant leur complexité à l’essentiel, soucieux qu’il est d’imaginer des solutions élégantes et pérennes.</p><p>- Compagnon logiciel : un artisan qui cultive son art au paroxysme des exigences de qualité, qui a déjà réalisé un ou des chefs d’œuvre reconnus par ses pairs, et capable à son tour d’accompagner des artisans sur le chemin du compagnonnage.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f509c267310e" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Améliorer la qualité logicielle en partant des tests]]></title>
            <link>https://medium.com/@xavier.pigeon/am%C3%A9liorer-la-qualit%C3%A9-logicielle-en-partant-des-tests-bf420e6e435a?source=rss-3f1d2583bd2c------2</link>
            <guid isPermaLink="false">https://medium.com/p/bf420e6e435a</guid>
            <category><![CDATA[testing]]></category>
            <category><![CDATA[technical-debt]]></category>
            <category><![CDATA[software-testing]]></category>
            <category><![CDATA[code-smells]]></category>
            <dc:creator><![CDATA[Xavier Pigeon]]></dc:creator>
            <pubDate>Mon, 09 Jul 2018 09:27:01 GMT</pubDate>
            <atom:updated>2018-07-09T09:28:16.166Z</atom:updated>
            <content:encoded><![CDATA[<blockquote>« Pourquoi faire des tests ? N’ai-je pas déjà assez d’écrire le code ? 😇 »</blockquote><p>Ce qu’il y a de merveilleux dans les tests (automatisés), c’est qu’ils font la synthèse des maux du code. Non seulement ils fournissent une documentation vivante du comportement du logiciel, mais en plus ils facilitent les revues de code ou les audits en documentant la dette logicielle.</p><p>Exemples… Un test nécessite une préparation conséquente de dépendances : se pourrait-il que le sujet de test soit un objet divin ? Un test nécessite de préparer les arguments en de nombreuses étapes : la méthode testée pourrait-elle être en fait une procédure ? Un test nécessite de très nombreuses vérifications : est-il inenvisageable que la méthode testée tienne sur plus d’un écran ? De trop nombreux cas de test se rapportent tous à la même méthode testée : sa complexité cyclomatique n’aurait-elle pas crevé le plafond ? La sémantique d’un cas de test reste obscure : le code emploie-t-il un lexique approprié, comme le vocabulaire du métier ? Et s’il n’y a pas de test sur tout ou partie du code, que penser de ce code ? Alors le pire est à craindre !</p><blockquote>Si le code ne ment pas, les tests disent la vérité — même leur absence. 😉</blockquote><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=bf420e6e435a" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>