<?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 Antoine Lefrancois on Medium]]></title>
        <description><![CDATA[Stories by Antoine Lefrancois on Medium]]></description>
        <link>https://medium.com/@antoine.lefrancois?source=rss-4ad3e2eece79------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*_PSPeWwdCDDofMKt</url>
            <title>Stories by Antoine Lefrancois on Medium</title>
            <link>https://medium.com/@antoine.lefrancois?source=rss-4ad3e2eece79------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sun, 22 Nov 2026 07:04:05 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@antoine.lefrancois/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[Résumé: Formation Clean Architecture — Robert c. Martin (partie 2)]]></title>
            <link>https://medium.com/elapse-technologies/r%C3%A9sum%C3%A9-formation-clean-architecture-robert-c-martin-partie-2-5454c96dc219?source=rss-4ad3e2eece79------2</link>
            <guid isPermaLink="false">https://medium.com/p/5454c96dc219</guid>
            <category><![CDATA[test-automation]]></category>
            <category><![CDATA[software-architecture]]></category>
            <category><![CDATA[solid-principles]]></category>
            <dc:creator><![CDATA[Antoine Lefrancois]]></dc:creator>
            <pubDate>Sun, 29 Dec 2019 17:19:56 GMT</pubDate>
            <atom:updated>2019-12-29T17:19:56.010Z</atom:updated>
            <content:encoded><![CDATA[<h3>Résumé: Formation Clean Architecture — Robert c. Martin (partie 2)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*63HzT5TCkXHpf8b6-Gz-tw.png" /></figure><p>Précédemment, lors de la première partie, nous avons discuté de l’importance d’écrire du code ayant la capacité de bien vieillir. Nous avons déterminé que, peu importe le paradigme, la clé pour permettre à notre code d’évoluer élégamment résidait dans les tests. Finalement, nous avons conclu qu’il existait un étroit lien entre les tests et l’architecture.</p><p>Lorsqu’on la compare à d’autres domaines d’ingénierie plus traditionnels qui suivent des principes parfois millénaires, nous réalisons à quel point l’ingénierie logicielle est une discipline jeune! Malgré cela, nous détenons tout de même notre lot de règles et d’outils, forgé à travers les années et les expériences, nous permettant de guider nos décisions architecturales vers des solutions fonctionnelles et évolutives.</p><p>Dans cette deuxième partie, nous aborderons plus précisément les principes de bases sur lesquels nous asseyons nos décisions architecturales. Ceux-ci servent de fondement à d’autres concepts propres à l’ingénierie logicielle, tels que la programmation orientée objet ou les plug-ins.</p><p><strong><em>La programmation orientée objet</em></strong></p><p>La programmation orientée objet nous est généralement présentée comme le paradigme de programmation ayant pour but de représenter les concepts du <em>monde réel</em> dans notre propre conceptualisation d’un système informatique. Toutefois, si nous nous dégageons de cette définition plutôt rudimentaire, nous découvrons que ce paradigme nous expose trois principes puissants: l’encapsulation, l’héritage et le polymorphisme.</p><p>Le principe d’encapsulation se trouve très bien représenté dans le langage C. En effet, tout programme en C se compose de deux fichiers distincts: le fichier <em>header</em> et le fichier <em>source</em>. Cette ségrégation obligatoire induit la création d’un contrat généralement fort: le client utilise le fichier <em>header</em> comme un contrat de capacité en provenance de l’objet qu’il souhaite utiliser, dont l’implémentation réelle avec ses détails se retrouvent, cachés, dans le fichier <em>source</em>. Malheureusement, certains langages plus modernes tels que Java ou C# ont tendance à violer délibérément ce principe en déclarant ce contrat au même endroit que l’implémentation, permettant facilement l’exposition des <em>entrailles</em> de notre code.</p><p>Heureusement, le principe d’héritage s’en tire beaucoup mieux au sein de langages comme Java. Effectivement, celui-ci permet facilement l’héritage d’objet.</p><p>Pour ce qui est du polymorphisme, il faut savoir que cela existait antérieurement à l’apparition des langages fortement publicisés comme étant orientés objet. Plusieurs programmeurs C de cette époque pourraient témoigner en avoir fait usage. Cela dit, le réel apport de l’OO en lien avec le polymorphisme, c’est qu’il l’a rendu sécuritaire et donc, plus facilement accessible. Cela semble anodin, or, ce concept a permis de rendre nos systèmes beaucoup plus indépendants. En effet, lors de la conception de systèmes, nous identifions rapidement quelles sont les portions qui mériteraient d’être isolées par le soucis d’être potentiellement interchangées. Bien qu’aujourd’hui, cela ne veut plus nécessairement signifier des entrées ou des sorties matérielles, nous continuons d’architecturer nos systèmes en ayant cette préoccupation: celle de rendre tout module le plus indépendant possible. En inversant les dépendances dans nos systèmes, il n’est plus nécessaire d’utiliser directement les objets et les concepts de niveaux inférieurs, caractérisés par des détails qui pourraient changer. Ceux-ci sont maintenant vus comme des <em>plug-ins.</em> Grâce à ceux-ci, les architectes logiciels gagnent alors un plein contrôle sur l’orientation de leurs dépendances, et donc, une meilleure garantie sur l’évolution de leurs systèmes.</p><p><strong><em>Testabilité</em></strong></p><p>Le principe de <em>plug-ins</em> permet de rendre indépendantes certaines responsabilités divergentes, le plus souvent d’origine techniques. Les <em>plug-ins</em> peuvent s’amarrer facilement au reste du système, sans altérer ce qui est au centre de celui-ci: la logique d’affaires. La frontière entre la logique d’affaires au coeur du système et les diverses possibilités d’adaptabilité autour de celle-ci devient ainsi plus évidente. Grâce à ce type d’architecture, toutes les composantes vers lesquelles nous avons de fortes dépendances, et qui font habituellement obstacles à la testabilité de nos systèmes, deviennent maintenant des <em>plug-ins</em>. Ainsi chacune des parties du système peuvent être testées plus facilement en isolation.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3PLI8ShH-UC_VVjz1gX2KQ.jpeg" /><figcaption>Représentation du concept de plug-ings — Bob Martin Novembre 2019</figcaption></figure><p>De plus, qui dit indépendance entre les composantes, dit indépendance du déploiement de celles-ci. Donc nos solutions logicielles deviennent à la fois testables, modulables et avec un cycle de vie qui est propre à chaque responsabilité.</p><p>#testability #plugin</p><p>Aucune de ces dernières affirmations n’est réellement nouvelle ou révolutionnaire. Et pourtant, pourquoi cela est-ce toujours difficile de créer des architectures évolutives? Qu’est-ce qui nous empêche, en 2020, de se donner pleinement contrôle de notre logiciel?</p><p><strong><em>Conception logicielle</em></strong></p><p>Qui n’a pas déjà passé une longue rencontre, à tenter de concevoir un système tant bien que mal, en esquissant de multiples boîtes et flèches sur un tableau? Naviguant à l’aveugle, nous dessinons nos choix architecturaux de façon instinctive plutôt que réfléchie, ayant comme objectif de quitter la pièce avec une architecture visuellement intéressante et compréhensible, sans nécessairement garantie de flexibilité.</p><p>Heureusement, plusieurs principes existent et nous aident afin de soulever les questions importantes que nous devons nous poser afin critiquer et valider les choix architecturaux que nous prenons. Bob Martin fut l’un des premiers de l’industrie à publier ces principes qui sont maintenant devenus une référence dans notre domaine: les principes SOLID. C’est dans sa manière de définir chacun des principes que l’on perçoit la puissance de ces concepts:</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yP6M2n7c0lkwiOwbJcwS6A.jpeg" /><figcaption>Image tiré des diapositives de Bob Martin — Novembre 2019</figcaption></figure><p><strong>SRP: </strong>Un module doit être répondant de un seul et unique acteur</p><p><strong>OCP: </strong>Séparer les concepts qui changent (bas niveau) des concepts qui ne changent pas (haut niveau), créant ainsi des points d’extension dans le système</p><p><strong>LSP:</strong> Le code n’est pas nécessairement la représentation de la vie réelle. Posez-vous la question: <em>Est-ce que cela se comporte comme un … ?</em></p><p><strong>ISP:</strong> Il ne faut pas dépendre de choses dont nous n’avons pas absolument besoin… et ça vaut aussi pour les frameworks!</p><p><strong>DIP: </strong>Il faut dépendre de plus stable que nous. Seriez-vous réticent à dépendre de <em>String</em> de Java? Si vous dépendez d’un concept volatile, il serait préférable d’inverser la dépendance en créant une abstraction entre vous et votre dépendance.</p><p>Lorsque vous y référez, ces principes devraient agir en tant que petites voix lors de toute phase du développement logiciel. Ils nous évite ainsi de faire plusieurs erreurs figeant notre architecture, et portant possiblement atteinte à l’évolution de ses composantes.</p><p><strong><em>Composantes</em></strong></p><p>Qu’est-ce qu’une composante? Bien qu’évoquée à plusieurs reprises, nous n’en n’avons pas préciser la signification jusqu’à maintenant. Selon Uncle Bob, la composante se définit comme étant une unité indépendamment déployable. Cette définition étant assez large, nous pouvons en énumérer quelques exemples: microservice, jar, dll, plug-in… D’autres éléments de nos systèmes peuvent aussi être indépendamment déployés, comme la BD, le UI, les librairies et les configurations. À l’échelle d’une architecture distribuée, ce sont les microservices, <em>ces services</em> <em>indépendamment déployables</em>, qui sont considérés comme des composantes.</p><p>Dans la prochaine partie, nous aborderons davantage l’univers des composantes. Quelles règles devons-nous appliquer afin de créer des composantes évolutives? Comment organiser les dépendances entre nos composantes? Nous y reviendrons tout en faisant des liens avec de nouveaux concepts!</p><p><strong>À bientôt!</strong></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5454c96dc219" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elapse-technologies/r%C3%A9sum%C3%A9-formation-clean-architecture-robert-c-martin-partie-2-5454c96dc219">Résumé: Formation Clean Architecture — Robert c. Martin (partie 2)</a> was originally published in <a href="https://medium.com/elapse-technologies">Elapse Technologies</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Résumé: Formation Clean Architecture — Robert c. Martin (partie 1)]]></title>
            <link>https://medium.com/elapse-technologies/r%C3%A9sum%C3%A9-formation-clean-architecture-robert-c-martin-partie-1-5372a7ae2e73?source=rss-4ad3e2eece79------2</link>
            <guid isPermaLink="false">https://medium.com/p/5372a7ae2e73</guid>
            <dc:creator><![CDATA[Antoine Lefrancois]]></dc:creator>
            <pubDate>Fri, 06 Dec 2019 14:18:32 GMT</pubDate>
            <atom:updated>2019-12-06T14:40:35.734Z</atom:updated>
            <content:encoded><![CDATA[<h3>Résumé: Formation Clean Architecture — Robert c. Martin (partie 1)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/915/1*50TExEhhXKMU6oRVJNFiTA.png" /></figure><p>Toujours plus rapide, toujours plus performant, toujours plus léger, le matériel (processeur, RAM, disque, etc.) sur lequel nos logiciels vivent n’a pas cessé d’évoluer depuis le début de l’informatique. Toutefois, le logiciel que nous écrivons lui n’est pas si différent que les tout premiers écrit. Il est loin de suivre la même courbe d’évolutivité du matériel! <strong>#moores_law</strong></p><p>Les fondations de la programmation, définies avant même l’écriture des premiers logiciels, sont décrites par les 3 opérations suivantes:</p><ul><li>des séquences</li><li>des conditions</li><li>des itérations</li></ul><p>Regardez le dernier bout de code que vous avez écrit il y a quelques instants. Voyez-vous autre chose que c’est 3 blocs d’opérations? Très peu de changement dans notre manière de faire et pourtant, les TI sont maintenant une des dépenses les plus importantes des compagnies modernes. <strong>#no_new_operation</strong></p><p>Malgré cela, il y a tout de même une certaine évolution de l’industrie logicielle, par application de contraintes. Ce sont les contraintes apportées par les 3 paradigmes du logiciel. Chacun des paradigmes rajoute une discipline supplémentaire que l’on doit respecter, et on choisit celle qui fait le moins mal.</p><ul><li>Programmation structuré e— discipline sur le transfert de contrôle direct</li><li>Programmation Orienté objet — discipline sur le transfert de contrôle indirecte</li><li>Programmation fonctionnelle — discipline sur l’assignation</li></ul><p>Et si vous pensez que ces manières de programmer sont nouvelles, elles ont toutes été fondées dans les premiers pas de l’ingénierie logicielle. <strong>#nothing_really_new</strong></p><p>Écrire du code fonctionnel, c’est la partie facile. Cependant, focaliser seulement sur cet aspect fait que nos logiciels ont tendance à mal vieillir. Et quand ça se produit, c’est notre productivité qui en prend un coup. Alors pour résoudre cette baisse, on recrute de plus en plus de développeurs. Chaque ligne de code produite se met alors à coûter de plus en plus cher, et ce de manière exponentielle. Il est donc important de prendre le temps d’aussi s’assurer de faire la bonne chose de la bonne manière. <strong>#make_the_right_thing_right #craftmanship</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UHKQMMjuL7kUUi9iHBqVMQ.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*siVBZEaCxoYyADME7Nr84Q.png" /></figure><p>Alors comment s’assure-t-on de maintenir une courbe de productivité proche de celle souhaitée. Simple, écrivons du bon code vous allez me dire… Ok, mais comment on y arrive à ce bon code ? Ah, mais … c’est tout aussi simple, il suffit d’écrire de bons tests, idéalement en suivant le TDD. Et détrompez-vous, écrire des tests ne prend pas plus de temps que d’écrire le code pour satisfaire un besoin. Jason Gorman s’est amusé à tester cette idée même sur de petits problèmes (<a href="https://kata-log.rocks/roman-numerals-kata">Roman Numeral kata </a>) et a obtenu des résultats (non statistique) intéressants: il est presque toujours 2x plus rapide d’écrire les tests en premier pour finir un problème. Nous constatons par notre présence dans une multitude de compagnies une conclusion similaire. Un test s’assure non seulement de répondre au besoin du client, il augmente notre confiance et notre capacité à changer notre logiciel au fil du temps. Notre logiciel sera maintenant plus évolutif face aux intempéries, c.-à-d. les besoins qui changent, les problèmes qui surviennent et tous ces autres problématiques.</p><p>Rien de nouveau jusqu’ici. Or nous entendons souvent dans nos interventions, “oui , mais je ne peux pas faire de tests pour ça”. Le problème n’est pas ici avec le test en question, mais bel et bien l’architecture du logiciel.</p><p>Presque toutes les industries ont des moyens de tester conçus à même leur produit/chaîne de production. L’architecture de leur solution prend dès le début conscience de l’importance de cela. Alors, pourquoi ne pas appliquer ce principe à la nôtre?</p><p>Ce besoin de points d’intégration dans nos logiciels découle plusieurs principes architecturaux que nous survolerons dans la deuxième partie.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5372a7ae2e73" width="1" height="1" alt=""><hr><p><a href="https://medium.com/elapse-technologies/r%C3%A9sum%C3%A9-formation-clean-architecture-robert-c-martin-partie-1-5372a7ae2e73">Résumé: Formation Clean Architecture — Robert c. Martin (partie 1)</a> was originally published in <a href="https://medium.com/elapse-technologies">Elapse Technologies</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>