Démarrer l'essai gratuit
Tendances Nouveau Genres Auteurs
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Recherche en cours...
SoBrief
Architecture logicielle propre

Architecture logicielle propre

Titre original: Clean Architecture
Concevez des logiciels dont les changements restent abordables, sans payer le prix d’une complexité dont vous n’aurez peut-être jamais besoin.
par Robert C. Martin 2017 432 pages
4.21
7 000+ évaluations
Écouter
Immersif
V2.3
Amazon Kindle Audible
Essayez l'accès complet pendant 3 jours
Débloquez l'écoute et bien plus !
Continuer

Points clés

Évaluer l’architecture à l’aune du coût de la prochaine modification courante

La conception est un choix économique. Martin considère la conception et l’architecture comme un continuum de décisions, de la structure générale aux détails d’implémentation les plus modestes. Leur objectif est de réduire l’effort humain nécessaire pour créer et maintenir un système tout au long de sa durée de vie. Dans le cas d’une entreprise, les effectifs de développement et de paie ont fortement augmenté, tandis que la production de code stagnait presque. À la huitième version, chaque ligne de code coûtait environ 40 fois plus cher à produire que lors de la première. Le désordre accumulé avait transformé le développement de fonctionnalités en un travail de navigation dans du code ancien.

Un travail soigné peut faire gagner du temps. Lors d’un petit exercice de six jours consacré à la conversion de nombres en chiffres romains, les journées avec développement piloté par les tests ont pris environ 10 % moins de temps que celles sans cette discipline. C’est une illustration, pas une étude définitive, mais elle remet en question l’idée qu’un nettoyage est un luxe qu’on peut remettre à plus tard.

Analyse

Cette perspective économique rend l’architecture compréhensible aux personnes qui n’écrivent pas de code : la hausse du coût des modifications est un risque commercial, et non une préférence de développeur. Elle explique aussi pourquoi un système peut fonctionner correctement tout en étant en mauvais état. Il convient toutefois de nuancer les éléments de preuve. Le nombre de lignes de code est une mesure grossière de la valeur livrée, et un exercice de six jours ne saurait établir un avantage universel de productivité pour une pratique donnée. Le critère le plus durable consiste à déterminer si les équipes peuvent effectuer les modifications probables avec un effort prévisible, sans déstabiliser sans cesse des comportements sans rapport.

Préserver la capacité d’évolution aussi soigneusement que les fonctionnalités opérationnelles d’aujourd’hui

Le logiciel a deux valeurs. Son comportement crée ou économise de la valeur aujourd’hui; sa structure détermine la facilité avec laquelle ce comportement peut être modifié. Il est facile de négliger cette seconde valeur, car les demandes de fonctionnalités arrivent dans l’urgence, tandis que les dégâts architecturaux s’accumulent en silence. Martin reprend la distinction entre importance et urgence associée à Eisenhower: un travail urgent n’est pas automatiquement important. Les développeurs doivent aider les décideurs à prendre conscience du coût futur d’une architecture reléguée au second plan.

L’ampleur du changement ne détermine pas à elle seule son coût. Une demande modeste peut coûter cher si sa forme entre en conflit avec la structure du système. Si l’ajout d’un rapport exige des modifications dans des modules sans lien entre eux, l’architecture complique le changement au-delà de ce que la demande justifie. Préserver la capacité d’évolution ne signifie pas prévoir toutes les options imaginables. Il s’agit d’éviter que les changements courants et prévisibles ne deviennent une opération à l’échelle de tout le système.

Analyse

Cette distinction rappelle celle entre performance opérationnelle et résilience organisationnelle : un système peut atteindre ses objectifs du jour tout en perdant sa capacité à s’adapter demain. Le piège de l’urgence est particulièrement puissant dans les organisations produit, où les lancements visibles sont récompensés, contrairement aux coûts de maintenance évités. La flexibilité n’est toutefois pas gratuite. Chaque frontière et chaque abstraction mobilisent de l’attention ; l’architecture doit donc protéger les évolutions plausibles, et non hypothétiques. La vraie discussion ne consiste pas tant à choisir entre fonctionnalités et architecture qu’à rendre visible le coût du report des travaux structurels.

Limiter le flux de contrôle, l’indirection et la mutation pour faciliter les tests des programmes

La programmation progresse en s’imposant des contraintes. Martin présente la programmation structurée comme une discipline qui limite les sauts sans restriction, la programmation orientée objet comme un moyen d’encadrer plus sûrement les appels indirects, et la programmation fonctionnelle comme une discipline qui encadre la modification de l’état. Chacune rend plus difficile l’écriture de certains types de code, en contrepartie d’un code plus facile à raisonner. Les travaux de Dijkstra sur la programmation structurée ont montré comment la séquence, le choix et la répétition permettent de diviser les programmes en unités plus petites, que l’on peut examiner et tester.

L’état a un coût en matière de concurrence. L’immutabilité signifie que les valeurs ne sont pas écrasées à la légère; cela réduit les courses critiques et les mises à jour contradictoires, sans pour autant éliminer tous les problèmes de concurrence. L’approvisionnement par événements (event sourcing) en est un exemple: on stocke les transactions, comme les dépôts et les retraits, et on en déduit le solde d’un compte au lieu de remplacer sans cesse sa valeur. Des instantanés peuvent limiter la quantité d’historique à recalculer.

Analyse

L’idée fédératrice n’est pas que les programmeurs doivent adopter un paradigme à la mode, mais que des contraintes peuvent rendre le raisonnement compositionnel. Cela rejoint l’ingénierie de la sécurité, où limiter les opérations dangereuses compte souvent davantage que demander aux gens de rester vigilants. Il faut toutefois circonscrire l’affirmation sur la concurrence : les données immuables réduisent l’état mutable partagé, mais les systèmes restent confrontés à des problèmes d’ordre, de contention des ressources et de cohérence distribuée. Les historiques d’événements entraînent aussi des coûts de stockage, de rejeu et d’interprétation. La question de conception utile est de savoir où la mutation est nécessaire et dans quelle mesure on peut la circonscrire.

Orienter les dépendances du code source vers les règles métier, et non vers la technologie

Garder les règles au cœur du système. L’Architecture logicielle propre est l’organisation proposée par Martin pour que les règles métier restent indépendantes des mécanismes externes. Les Entités représentent les règles métier importantes qui peuvent s’appliquer à plusieurs applications. Les Cas d’utilisation coordonnent ces règles pour accomplir les tâches propres à une application donnée. Les adaptateurs périphériques assurent la traduction entre ces règles internes et des détails tels que les requêtes web ou les enregistrements d’une base de données.

Les dépendances sont orientées vers l’intérieur. La Règle de dépendance veut que le code source d’une couche de règles internes ne nomme pas les détails d’implémentation des couches externes et ne s’appuie pas sur eux. L’exécution peut néanmoins se dérouler vers l’extérieur: un cas d’utilisation interne appelle une interface dont il est propriétaire, et un présentateur externe ou un adaptateur de base de données implémente cette interface. Ainsi, les règles métier peuvent survivre à un changement de base de données ou de conception d’écran sans hériter des types ou formats de données propres à un framework.

Analyse

La distinction entre le flux d’exécution et les dépendances du code source est subtile, mais puissante. Elle sépare l’initiateur d’une action de celui qui est autorisé à définir le contrat, distinction familière dans la conception des protocoles et la gouvernance des institutions. La couche interne est propriétaire de l’interface parce qu’elle exprime le besoin ; l’adaptateur fournit un mécanisme remplaçable. Cette organisation n’impose pas de dessiner des cercles concentriques dans tous les projets. Elle permet de vérifier à qui appartient chaque responsabilité : si le changement d’une bibliothèque de base de données oblige à modifier les règles métier, la frontière ne remplit pas son rôle.

Tracer les frontières en fonction des raisons de changer, et non de catégories techniques arbitraires

Regrouper selon les responsabilités. Le principe de responsabilité unique veut qu’un module serve un seul acteur, c’est-à-dire un seul groupe à l’origine d’un type particulier de changement. Dans l’exemple de la paie de Martin, le calcul des salaires, le relevé des heures et le stockage en base de données sont réunis dans une même classe Employee. Une routine commune de calcul des heures permet alors à une modification liée à la paie de corrompre par inadvertance les rapports des ressources humaines. Séparer le code en fonction des personnes et des objectifs qui le font évoluer réduit ce type de conflit.

Concevoir pour permettre des variations sûres. Le principe ouvert-fermée préconise d’étendre le comportement sans modifier sans cesse le code protégé. Le principe de substitution de Liskov exige que les implémentations interchangeables respectent les garanties sur lesquelles s’appuient leurs utilisateurs. Le principe de ségrégation des interfaces évite d’obliger les clients à dépendre d’opérations qu’ils n’utilisent pas. Le principe d’inversion des dépendances place des abstractions stables entre les règles centrales et les détails sujets à fluctuer. Ensemble, ces idées aident à circonscrire les changements plutôt qu’à simplement orner les classes.

Analyse

Ces principes sont les plus utiles lorsqu’on les considère comme des questions de responsabilité du changement, et non comme une liste de formes à donner aux classes. L’exemple de la paie révèle un problème autant social que technique : une équipe peut modifier du code auquel une autre équipe fait confiance sans s’en rendre compte. Les interfaces peuvent rendre ces responsabilités explicites. Cependant, créer un module distinct pour chaque acteur peut entraîner des coordinations et des indirections inutiles. De bonnes frontières reflètent des différences récurrentes dans les changements ; il reste nécessaire de s’appuyer sur les revues de code et la connaissance du domaine pour déterminer quand deux responsabilités divergent réellement.

Briser les cycles entre composants avant qu’ils ne transforment les mises en production en urgences collectives

Les composants structurent la collaboration. Un composant est une unité déployable, comme une archive Java ou une bibliothèque partagée. Trois Principes de cohésion des composants aident à décider ce qui doit être regroupé: regrouper le code publié ensemble, regrouper le code qui évolue pour les mêmes raisons et éviter de réunir des classes dont les utilisateurs n’ont pas besoin simultanément. Ces objectifs entrent en conflit; la taille appropriée d’un composant peut donc évoluer à mesure qu’un projet passe du développement interne à la réutilisation.

Éviter les dépendances cycliques. Le principe des dépendances acycliques veut que les dépendances entre composants forment un graphe orienté sans boucle. Un cycle peut rendre plusieurs équipes dépendantes d’une même mise en production coordonnée, ce qui compromet l’autonomie des tests et l’intégration incrémentale. La stabilité fournit un autre repère: les composants dont dépendent beaucoup d’autres sont coûteux à modifier; les composants sujets à des changements fréquents ne devraient donc pas devenir des prérequis pour des règles stables. Des interfaces abstraites peuvent orienter les dépendances vers des composants stables.

Analyse

Un graphe de dépendances est aussi une carte des coûts de coordination. Les cycles créent l’équivalent logiciel de départements étroitement liés, incapables de modifier leurs procédures sans négocier entre eux. Un graphe acyclique ne garantit pas une bonne architecture, mais il facilite le raisonnement sur l’ordre de construction, le périmètre des tests et l’impact des mises en production. Les mesures de stabilité peuvent révéler des schémas de dépendance surprenants, mais elles ne permettent pas de décider si un composant est utile ou de taille appropriée. Ce sont des outils de diagnostic, pas des notes objectives de qualité.

Commencer par un monolithe; distribuer seulement si des contraintes réelles justifient le coût

Le déploiement n’est pas l’architecture. Un monolithe peut contenir des composants soigneusement séparés, tandis qu’un ensemble de services peut rester étroitement couplé. Les appels de fonction au sein d’un même processus sont peu coûteux et peuvent être fréquents. Les appels entre processus ou par réseau ajoutent de la latence, de la conversion de données et des modes de défaillance opérationnels; les frontières à ces niveaux devraient donc répondre à un véritable besoin de développement, de déploiement ou d’exploitation.

Les services ne garantissent pas l’indépendance. Dans l’exemple de réservation de taxis de Martin, l’ajout d’une fonctionnalité de livraison de chatons touche le choix des candidats, l’affectation des chauffeurs, les règles applicables aux fournisseurs et la vérification des allergies des clients. Répartir ces comportements entre plusieurs services n’a pas empêché la fonctionnalité de franchir toutes leurs frontières. Une conception par composants, dotée de points d’extension, aurait pu isoler cette nouvelle offre. Il est recommandé de préserver d’abord les séparations dans le code, puis de transformer certaines frontières en unités déployables ou en services lorsque les éléments disponibles le justifient.

Analyse

Cette analyse remet utilement en cause l’assimilation de la distribution sur le réseau à la modularité. Les systèmes distribués échangent une simplicité locale contre de la latence, des défaillances partielles, des besoins de coordination des déploiements et des exigences d’observabilité. L’exemple des chatons montre que des données partagées et des règles transversales peuvent lier des services aussi étroitement que des fonctions lient des classes. À l’inverse, un monolithe peut devenir un goulot d’étranglement lorsque les équipes ou les exigences opérationnelles imposent réellement des déploiements indépendants. La question architecturale n’est pas de savoir quelle topologie est moderne, mais quelle frontière réduit au total les coûts de coordination et de défaillance dans l’environnement réel.

Maintenir les bases de données, les interfaces web et les frameworks à l’extérieur des règles métier

Reporter les choix réversibles. Martin considère les bases de données, la diffusion web et les frameworks comme des détails, car les règles métier ne devraient pas dépendre de leurs implémentations particulières. Dans FitNesse, une interface simple de stockage des pages a permis à l’équipe de développer d’abord les fonctionnalités avec une implémentation en mémoire, puis avec des fichiers plats. Un client a ensuite ajouté une implémentation MySQL en une journée environ. Finalement, l’équipe n’a pas eu besoin de cette option.

Utiliser les outils sans leur céder le cœur du système. Les frameworks peuvent accélérer le travail, mais leurs auteurs les conçoivent pour leurs propres problèmes, et un engagement trop étroit peut rendre leur remplacement coûteux par la suite. Garder le code spécifique au framework dans un adaptateur périphérique ou un composant de configuration. Le modèle de données lui-même peut être central pour l’activité; le logiciel de base de données et son langage de requête n’ont pas à l’être. Des exigences externes, qu’elles viennent des clients ou de l’organisation, peuvent néanmoins rendre une technologie particulière nécessaire.

Analyse

L’histoire de FitNesse illustre la valeur des décisions réversibles : une petite interface a préservé la possibilité de choisir plus tard sans obliger l’équipe à prédire le système de stockage idéal. Cela rappelle le raisonnement des options réelles en économie, où de faibles coûts initiaux peuvent préserver des choix précieux dans un contexte d’incertitude. Reporter une décision n’est toutefois pas toujours judicieux. Un choix technologique peut influer sur les performances, les compétences disponibles, la conformité ou les achats, et ces contraintes peuvent être substantielles plutôt que motivées par la mode. Il ne s’agit pas de faire comme si les contraintes n’existaient pas, mais d’éviter qu’elles ne contaminent inutilement les règles métier.

Intégrer les tests et les interfaces matérielles à l’architecture, plutôt que de les contourner

Tester à la frontière des règles métier. Le patron de l’objet humble (Humble Object) déplace les comportements difficiles à tester dans un composant minimal et conserve la logique dans un composant testable. Un présentateur peut formater les dates et les montants dans un modèle de vue, laissant à la vue d’écran le soin de les afficher. Une API de test dédiée peut permettre aux tests d’accéder aux règles métier sans parcourir une interface graphique instable ni devoir faire correspondre chaque classe de production à une classe de test. Cela réduit la fragilité des tests et les réticences à effectuer des refactorisations sans risque.

Séparer le logiciel du matériel. Les systèmes embarqués ont besoin d’une couche d’abstraction matérielle (HAL), une interface qui offre des services utiles tout en masquant les implémentations propres à chaque périphérique. Une abstraction du système d’exploitation peut jouer le même rôle pour les dépendances liées à celui-ci. Sans de telles interfaces de séparation, un changement matériel peut imposer des modifications étendues, et le code risque de ne pouvoir être testé que sur l’appareil cible.

Analyse

La testabilité est ici une propriété structurelle, et non une réflexion après coup de l’équipe chargée des tests. Une API stable permet aux tests d’accéder au comportement tout en les protégeant des détails accessoires de la disposition de l’écran et de l’organisation des classes. Dans les systèmes embarqués, la même logique permet de tester avant que le matériel soit prêt ou après qu’un appareil est devenu obsolète. Les interfaces de test puissantes exigent de la prudence : contourner la sécurité ou remplacer des ressources coûteuses peut créer des risques si des capacités réservées aux tests se retrouvent en production. L’isolation doit porter sur le déploiement et le contrôle des accès, pas seulement sur la propreté du code source.

Faire apparaître le produit dans l’architecture, puis faire respecter ses frontières par le code

Rendre le domaine visible. Un dépôt devrait rendre son objectif manifeste, qu’il serve à vendre des vidéos, aux soins de santé ou à la comptabilité, au lieu de ne révéler que son framework web. Dans l’exemple de la vente de vidéos, les différents acteurs sont les acheteurs particuliers, les acheteurs professionnels, les auteurs et les administrateurs. Regrouper leurs cas d’utilisation aide à empêcher que les demandes d’un acteur ne se propagent sans discernement dans tout le système.

L’implémentation peut défaire la conception. Dans son chapitre, Simon Brown compare plusieurs façons d’organiser le code: par couche technique, par fonctionnalité, par frontière de domaine ou par composant. En Java, rendre chaque classe publique affaiblit l’encapsulation au niveau des packages; le compilateur ne peut donc pas empêcher les appelants de contourner les interfaces prévues. Un package organisé par composants peut exposer un seul point d’entrée tout en masquant son implémentation interne. Il convient de renforcer les frontières lorsque les frictions montrent que leur bénéfice dépasse leur coût de maintenance, et non de les imposer partout d’emblée.

Analyse

L’architecture s’adresse aussi bien aux machines qu’aux personnes. Une structure centrée sur le domaine peut faciliter l’intégration des nouveaux venus, qui peuvent comprendre ce que fait le système avant d’apprendre les choix de framework. Les restrictions d’accès imposées par le compilateur donnent à cette structure une réalité qui dépasse le diagramme ou la promesse faite lors d’une revue de code. L’organisation par fonctionnalité ou par composant n’est cependant pas toujours supérieure : les règles de visibilité du langage, la taille de l’équipe et les besoins de déploiement influencent le meilleur agencement. Le critère essentiel est de savoir si la structure choisie rend les dépendances voulues faciles à suivre et les dépendances accidentelles difficiles à créer.

Analyse

Le geste le plus important du livre est de redéfinir l’architecture: non plus comme une représentation de boîtes, mais comme une stratégie de maîtrise du coût des changements. Cela donne leur cohérence à ses recommandations: l’inversion des dépendances protège les règles métier, les graphes de composants organisent la collaboration, les frontières testables limitent les risques de régression et le report des choix technologiques préserve des options. L’argument est le plus convaincant lorsqu’il relie la structure logicielle à l’effort humain. Un graphe de dépendances enchevêtré n’est pas seulement inélégant; il ralentit l’intégration, élargit le périmètre des tests et exige davantage de personnes pour effectuer des changements courants.

Son cadre se veut délibérément transposable d’un langage et d’une époque à l’autre. Les éléments récurrents sont la séquence, le choix, l’itération, les données et l’indirection, tandis que le matériel et les outils évoluent. Cette perspective historique aide à résister à l’idée qu’un nouveau framework ou un nouveau mode de déploiement résout les anciens problèmes de conception. Il faut toutefois comprendre l’affirmation selon laquelle les règles architecturales sont essentiellement immuables comme une affirmation portant sur la durabilité des principes, et non sur l’identité des implémentations. Les plateformes distribuées modernes, l’exploitation dans le nuage et les exigences réglementaires modifient le coût des frontières, même lorsque les règles métier doivent rester à l’abri des détails.

Le livre présente aussi une tension féconde plutôt qu’une recette. La réutilisation, les changements locaux et l’évitement des dépendances superflues tirent la conception des composants dans des directions différentes. De même, anticiper une frontière peut éviter une refonte coûteuse, mais une abstraction spéculative peut alourdir un petit produit. La tâche architecturale est donc empirique: observer où les changements entrent en collision, où les tests deviennent fragiles et où le déploiement ou l’exploitation impose de véritables contraintes, puis investir dans la frontière dont les économies attendues justifient l’entretien.

Certains éléments de preuve sont illustratifs plutôt que concluants. L’exemple de productivité s’appuie sur le nombre de lignes de code, et l’expérience sur le développement piloté par les tests est de petite ampleur. Aucun des deux n’établit un rendement numérique universel de la conception logicielle propre. Leur rôle est de rendre visible un mécanisme plausible: une structure désordonnée consomme des efforts qui pourraient autrement produire des comportements utiles. La leçon durable n’est pas de maximiser l’abstraction. Elle consiste à rendre les règles essentielles du système compréhensibles, testables et relativement insensibles aux détails les plus susceptibles de changer.

Résumé en 30 secondes
L’architecture détermine l’effort qu’exigent les changements ordinaires au cours de la vie d’un système. Gardez les règles métier indépendantes des bases de données, des interfaces et des frameworks, et orientez les dépendances du code vers ces règles. Séparez les modules selon leurs responsabilités, évitez les dépendances circulaires et établissez des frontières là où les changements se télescopent ou les tests deviennent fragiles. Commencez par un monolithe bien séparé ; passez à des services distribués seulement lorsque les contraintes opérationnelles ou de développement justifient leur coût. Dans une entreprise, la production de code a à peine augmenté malgré la croissance des effectifs, et les versions ultérieures coûtaient environ 40 fois plus cher par ligne.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.21 sur 5
Moyenne de 7 000+ évaluations de Goodreads et Amazon.

Architecture logicielle propre : guide du praticien sur la structure et la conception logicielles reçoit des avis partagés. Beaucoup saluent son intérêt pour les principes SOLID et le découplage, tandis que d’autres le trouvent répétitif et pauvre en exemples pratiques. Certains lecteurs apprécient le contexte historique et les anecdotes ; d’autres estiment qu’ils détournent l’attention du contenu essentiel. L’ouvrage est généralement considéré comme utile pour comprendre les grands principes de l’architecture logicielle, mais les avis divergent quant à son utilité pour les débutants et les développeurs expérimentés. Plusieurs critiques remarquent que son contenu aurait pu être présenté plus succinctement.

Votre note :
4.6
633 évaluations
Envie de lire le livre complet ?

Glossaire

Architecture propre

Des règles métier protégées des détails

Une approche architecturale qui place les règles métier importantes au cœur du système, et les mécanismes techniques tels que les bases de données, les frameworks web et les appareils à l’extérieur. Les dépendances du code source pointent vers les règles internes. Le système peut toujours utiliser des outils externes, mais ses règles fondamentales ne devraient pas dépendre de leurs noms, de leurs formats ni de leurs choix d’implémentation.

Règle de dépendance

Les dépendances pointent vers les règles métier

La règle selon laquelle, dans une architecture en couches, les dépendances du code source doivent pointer vers l’intérieur, des détails vers les règles de plus haut niveau. Le code interne ne doit pas faire référence aux noms ni aux formats de données déclarés par les couches externes. Les interfaces appartenant au code interne permettent aux appels à l’exécution d’atteindre des implémentations externes sans inverser la dépendance du code source.

Entité

Règles métier et données essentielles

Un objet ou un module logiciel qui regroupe des données métier essentielles et les règles qui s’y appliquent. Une Entité représente un concept métier qui conserve son sens au-delà de l’interface ou de la base de données d’une application particulière. Elle ne devrait pas dépendre de ces mécanismes techniques.

Cas d’utilisation

Procédure métier propre à une application

La description et la mise en œuvre de la façon dont un système automatisé est utilisé pour atteindre un objectif. Un cas d’utilisation définit les entrées, les sorties et le traitement pertinents, et coordonne les Entités qui contiennent des règles métier plus générales. Il ne devrait pas dépendre du fait que les utilisateurs interagissent au moyen d’une page web, d’une console ou d’une autre interface.

Principes SOLID

Repères pour une conception qui facilite les changements

Cinq principes de conception connexes portant sur la responsabilité, l’extension, la substituabilité, la taille des interfaces et le sens des dépendances. Ils guident le regroupement des fonctions et des données ainsi que les dépendances entre les modules. Leur objectif commun est de rendre les logiciels plus faciles à modifier, à comprendre et à réutiliser, sans coupler des responsabilités sans rapport entre elles.

Principes de cohésion des composants

Règles de regroupement du code déployable

Les principes d’équivalence réutilisation/version, de fermeture commune et de réutilisation commune guident le choix des classes à réunir dans un composant. Ils permettent de concilier les versions coordonnées, le regroupement du code qui évolue pour les mêmes raisons et l’évitement des dépendances à des classes inutilisées. Comme ces objectifs peuvent entrer en conflit, la structure des composants devrait refléter les besoins actuels du projet en matière de développement et de réutilisation.

Approvisionnement par événements (event sourcing)

Stocker les événements et en déduire l’état actuel

Une stratégie de données qui stocke la séquence des transactions ou des événements plutôt que de remplacer continuellement l’état actuel. L’état est reconstruit en appliquant ces événements, parfois à partir d’un instantané sauvegardé afin de réduire le travail de rejeu. Cette stratégie peut réduire les mises à jour mutables, mais nécessite le stockage et le traitement de l’historique enregistré.

Patron de l’objet humble (Humble Object)

Isoler le comportement difficile à tester

Un patron de conception qui répartit le comportement entre un composant minimal chargé des aspects difficiles à tester et un composant distinct contenant la logique testable. Par exemple, une vue peut afficher des valeurs préparées tandis qu’un présentateur les met en forme. Cette séparation crée souvent une frontière architecturale utile.

API de test

Accès stable pour les tests automatisés

Une interface destinée à permettre aux tests d’exercer le comportement métier sans dépendre de l’interface utilisateur ni reproduire chaque classe de production. Elle peut proposer des moyens contrôlés de définir l’état du système, de contourner des ressources coûteuses ou d’accéder à des opérations indisponibles aux utilisateurs ordinaires. Les fonctionnalités de test sensibles devraient être exclues des chemins d’accès en production.

Couche d’abstraction matérielle (HAL)

Le matériel est masqué derrière des services

Une interface logicielle qui fournit les services dont une application a besoin tout en masquant les particularités du matériel. Au lieu d’exposer les registres de l’appareil ou l’affectation des broches, elle peut proposer des opérations formulées selon les termes du produit. Les implémentations peuvent ainsi évoluer avec le matériel, tandis que le logiciel de plus haut niveau reste protégé de ces changements.

Séquence principale (Main Sequence)

Équilibrer stabilité et abstraction

Une ligne sur un graphique de conception des composants qui met en relation stabilité et abstraction. Les composants proches d’une extrémité sont stables et abstraits ; ceux proches de l’autre sont instables et concrets. Les composants éloignés de la ligne peuvent être rigides tout en étant concrets, ou abstraits sans dépendants utiles. Cette mesure sert de piste de diagnostic, pas de preuve de qualité.

FAQ

De quoi parle Architecture logicielle propre ?

  • L’accent sur la structure logicielle : Architecture logicielle propre, de Robert C. Martin, préconise de créer des systèmes faciles à développer, à maintenir et à déployer grâce à une architecture logicielle efficace.
  • Des principes intemporels : l’ouvrage présente des principes comme SOLID, applicables à différents paradigmes de programmation, pour guider les développeurs dans l’écriture d’un code propre et facile à maintenir.
  • La séparation des préoccupations : le livre recommande de séparer les règles métier des détails techniques afin d’accroître la flexibilité et la capacité d’adaptation de la conception logicielle.

Pourquoi lire Architecture logicielle propre ?

  • Améliorer ses compétences en conception logicielle : le livre approfondit la compréhension de l’architecture logicielle et fournit des conseils pratiques pour les projets réels.
  • Des connaissances intemporelles : ses principes ne sont pas liés à des technologies particulières et restent donc pertinents tout au long d’une carrière.
  • Des exemples du monde réel : Martin partage les enseignements de sa vaste expérience au moyen d’exemples parlants et d’études de cas qui simplifient des concepts complexes.

Quels sont les principaux enseignements d’Architecture logicielle propre ?

  • L’architecture est une forme : l’architecture logicielle se définit par la division des composants et leur communication, ce qui facilite le développement et la maintenance.
  • Découpler les règles métier : le livre insiste sur la séparation des règles métier et des détails techniques pour faciliter les modifications et les adaptations.
  • Préserver les options : une bonne architecture reporte les décisions techniques afin de permettre l’adaptation à l’évolution des besoins.

Quels sont les principes SOLID mentionnés dans Architecture logicielle propre ?

  • Principe de responsabilité unique (SRP) : une classe ne devrait avoir qu’une seule raison de changer, ce qui réduit la complexité et facilite la maintenance.
  • Principe ouvert-fermé (OCP) : les entités logicielles devraient être ouvertes à l’extension, mais fermées à la modification, afin de réduire les risques de bogues.
  • Principe de substitution de Liskov (LSP) : les sous-types doivent pouvoir remplacer leurs types de base sans compromettre la correction du programme.

Qu’est-ce que le principe d’inversion des dépendances (DIP) dans Architecture logicielle propre ?

  • Modules de haut niveau : le DIP stipule que les modules de haut niveau ne devraient pas dépendre des modules de bas niveau ; les uns et les autres devraient dépendre d’abstractions.
  • Les abstractions plutôt que les détails : dépendre d’abstractions plutôt que d’implémentations concrètes facilite la modification et l’extension des systèmes.
  • Utilisation d’interfaces : le principe encourage l’utilisation d’interfaces pour définir des contrats entre les composants, ce qui améliore les tests et la maintenance.

Comment Architecture logicielle propre définit-elle une bonne architecture logicielle ?

  • Prise en charge des cas d’utilisation : une bonne architecture doit prendre en charge les cas d’utilisation visés et les rendre clairs et visibles dans sa structure.
  • Réduire les ressources humaines nécessaires : une conception réfléchie devrait réduire les ressources nécessaires au développement, au déploiement et à la maintenance.
  • Préserver les options : une architecture bien conçue laisse ouvertes des possibilités de changement futur, ce qui est essentiel à la réussite à long terme.

Quelle est l’importance des frontières dans Architecture logicielle propre ?

  • Séparation des préoccupations : les frontières séparent les composants du système et veillent à ce que les changements dans une partie ne nuisent pas aux autres.
  • Maîtrise des dépendances : gérer les dépendances de part et d’autre des frontières prévient les perturbations et contribue à la stabilité du système.
  • Faciliter le développement indépendant : les frontières permettent aux équipes de travailler indépendamment, ce qui améliore la productivité et réduit les conflits.

Qu’est-ce que le concept d’« architecture éloquente » dans Architecture logicielle propre ?

  • L’architecture exprime l’intention : l’« architecture éloquente » signifie que l’architecture du système doit communiquer clairement son objectif et ses fonctionnalités.
  • Orientée par les cas d’utilisation : une bonne architecture est guidée par les cas d’utilisation, ce qui préserve clarté et intention tout au long du développement.
  • Éviter la dépendance aux frameworks : l’architecture devrait être centrée sur les besoins métier, plutôt que dictée par des frameworks ou des outils.

Comment Architecture logicielle propre aborde-t-elle les tests ?

  • Des architectures testables : le livre met l’accent sur les architectures qui permettent de tester unitairement les règles métier sans faire fonctionner de systèmes externes.
  • Patron de l’objet humble (Humble Object) : ce patron sépare le code difficile à tester du code testable, afin de se concentrer sur la logique sans les complexités de l’interface utilisateur ou des frameworks.
  • API de test : il recommande de créer une API de test permettant de contourner les contraintes de sécurité et d’élargir les possibilités de tester différents scénarios.

Comment Architecture logicielle propre distingue-t-elle le web de l’architecture d’un système ?

  • Le web comme mécanisme de présentation : le web est considéré comme un mécanisme de présentation, et non comme un élément définissant l’architecture du système.
  • Découpler la présentation de la logique : traiter le web comme un détail permet de concevoir des systèmes indépendants des modes de présentation.
  • Mettre l’accent sur la logique métier : le livre donne la priorité à la logique métier et aux cas d’utilisation plutôt qu’aux particularités de la présentation web, afin de préserver les fonctionnalités essentielles.

Quels sont les risques liés à l’utilisation de frameworks selon Architecture logicielle propre ?

  • Couplage étroit : les frameworks peuvent entraîner un couplage étroit qui complique les changements de technologie.
  • Surcharge et complexité : une dépendance excessive aux frameworks peut introduire une complexité inutile et nuire aux performances.
  • Perte de contrôle : une dépendance excessive aux frameworks peut rendre le système rigide et compliquer les changements et les adaptations.

Quelles sont les meilleures citations d’Architecture logicielle propre et que signifient-elles ?

  • « Votre architecture devrait renseigner le lecteur sur le système, pas sur les frameworks que vous avez utilisés. » : cette citation souligne que l’architecture doit refléter le domaine métier et les cas d’utilisation, et non les technologies.
  • « Les frameworks sont des outils, pas un mode de vie. » : elle rappelle aux développeurs de garder la maîtrise de l’architecture et de ne pas trop dépendre des frameworks.
  • « Une bonne architecture rend inutile le choix de Rails, Spring, Hibernate, Tomcat ou MySQL avant une étape avancée du projet. » : cette citation met en avant le report des décisions technologiques jusqu’à ce que l’architecture soit établie, afin de préserver la flexibilité.

À propos de l'auteur

Robert Cecil Martin, connu sous le nom d’Uncle Bob, est un ingénieur logiciel réputé et un défenseur des méthodes de développement Agile. En tant que président d’Object Mentor Inc., il dirige une équipe de consultants spécialisés dans la conception orientée objet, les patrons, UML et les méthodes Agile. Martin possède une vaste expérience de l’industrie logicielle et a été rédacteur en chef du C++ Report de 1996 à 1999. Conférencier très demandé lors de conférences et de salons internationaux, il y partage son expertise des bonnes pratiques de développement logiciel. Son influence dépasse le cadre du conseil : il a écrit plusieurs ouvrages marquants sur le savoir-faire logiciel et les pratiques de codage propre.

Télécharger le PDF

Pour garder le résumé de Architecture logicielle propre pour plus tard, téléchargez gratuitement le PDF. Vous pouvez l’imprimer ou le lire hors ligne quand vous le souhaitez.
Download PDF

Télécharger l'EPUB

Pour lire le résumé de Architecture logicielle propre sur votre liseuse ou dans une application de lecture, téléchargez gratuitement l’EPUB. Le format numérique .epub est idéal pour lire des livres numériques sur téléphone, tablette ou liseuse.
Download EPUB
Envie de lire le livre complet ?
Suivre
Écouter
Accueil
Swipe
Biblio
Appli
Essayez l'accès complet pendant 3 jours
Écoutez, enregistrez, et plus encore
Comparer les fonctionnalités Gratuit Pro
📖 Lire les résumés
Lisez des résumés illimités. Les utilisateurs gratuits en reçoivent 3 par mois
🎧 Écouter les résumés
Écoutez des résumés illimités dans 40 langues
—
❤️ Favoris illimités
Limité à 4 pour les utilisateurs gratuits
—
📜 Historique illimité
Limité à 4 pour les utilisateurs gratuits
—
📥 Téléchargements illimités
Limité à 1 pour les utilisateurs gratuits
—
Calendrier sans engagement
Aujourd'hui : Accès immédiat
Écoutez les résumés complets de plus de 26 000 livres. Soit plus de 12 000 heures d'audio !
Jour 2 : Rappel d'essai
Nous vous enverrons une notification pour vous informer que votre essai se termine bientôt.
Jour 3 : Votre abonnement commence
Vous serez débité le 24 nov.,
annulez à tout moment avant.
Consume 2.8× More Books
2.8× livres de plus Écoute Lecture
Nos utilisateurs nous adorent
1M+ lecteurs
Trustpilot Rating
TrustPilot
4.6 Excellent
Ce site change tout. Je n'ai jamais lu autant de résumés aussi rapidement. Je recommande vivement.
— Dave G
Ça vaut vraiment le coup en temps et en argent, et c'est très bien fait. Je n'ai jamais vu cette qualité de résumés ailleurs. Très utile !
— Em
Hautement recommandé !! Service fantastique. Parfait pour ceux qui veulent plus qu'un aperçu sans tous les détails d'un livre audio complet.
— Greg M
Économisez 62 %
Annuel
$119.88 $44.99/an/an
$3.75/mois
Mensuel
$9.99/mois
Démarrer un essai gratuit de 3 jours
3 jours gratuits, puis $44.99/an. Annulez à tout moment.
Unlock a world of fiction & nonfiction books
Plus de 26 000 livres pour le prix de 2 livres
Lisez n'importe quel livre en 10 minutes
Découvrez de nouveaux livres comme sur Tinder
Demandez n'importe quel livre s'il n'est pas encore résumé
Lisez plus de livres que quiconque
L'appli n°1 pour les amateurs de livres
Lifelike & immersive summaries
Garantie satisfait ou remboursé 30 jours
Téléchargez les résumés en EPUB ou PDF
Annulez à tout moment en quelques clics

Pourquoi un seul résumé ?

Scanner
Trouvez un code-barres à scanner

⭐
⭐
⭐
Nous avons un cadeau spécial pour vous
Ouvrir
38 % de réduction
RÉDUCTION POUR VOUS
⭐
⭐
⭐
$79.99
$49.99/an
Seulement $4.16 par mois
Continuer
2 touches pour commencer, résiliation ultra simple
Paramètres
Général
Widget
Chargement...