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
CODER PROPREMENT

CODER PROPREMENT

Titre original: Clean Code
Un code lisible permet aux équipes de rester rapides : des pratiques qui rendent les logiciels plus faciles à modifier en toute sécurité.
par Robert C. Martin 2007 464 pages
4.35
23 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

Gardez le code propre, car le raccourci livré aujourd’hui alourdit chaque changement

Le raccourci apparent finit par coûter cher. Martin soutient qu’un code écrit à la hâte et embrouillé ralentit chaque changement ultérieur. Il évoque un produit logiciel autrefois populaire, dont les versions se faisaient de plus en plus attendre, dont les bogues persistaient et qui plantait de plus en plus souvent. Un ancien employé a attribué ce déclin à une base de code devenue difficile à faire évoluer. À mesure que le désordre s’installe, les changements deviennent plus risqués, les équipes ralentissent, et embaucher du personnel peut aggraver le problème, car les nouvelles recrues doivent travailler dans une architecture qu’elles ne comprennent pas.

Une réécriture ne remet pas tout à zéro par magie. Dans le scénario de refonte présenté dans le livre, une nouvelle équipe construit un remplacement tandis que l’ancien système continue d’évoluer. La course peut durer des années, et le remplaçant peut hériter du même désordre. L’alternative pratique consiste à améliorer le code au fil de ses évolutions, plutôt que de traiter le nettoyage comme un projet à venir.

Analyse

Ce qui frappe, c’est l’argument économique qui sous-tend le discours sur le savoir-faire : chaque décision obscure impose du travail aux lecteurs futurs, et ce coût se répartit sur toute la durée de vie du produit. Cela rappelle la maintenance préventive en ingénierie, où de petites inspections réduisent le risque de défaillances coûteuses. L’argument est particulièrement convaincant lorsque le code sera maintenu par une équipe au fil du temps. Un prototype destiné à être abandonné présente une autre structure de coûts : la propreté doit donc servir l’usage prévu, plutôt que devenir un rituel pour elle-même.

Écrivez pour les lecteurs du code, pas seulement pour le compilateur, et rendez l’intention facile à retrouver

La lecture constitue l’essentiel du travail. Martin estime que les programmeurs passent plus de dix fois plus de temps à lire le code qu’à l’écrire. Le prochain changement dépend de la compréhension de ce qui existe déjà: la lisibilité n’est donc pas un ornement. Les noms doivent indiquer aux lecteurs ce que représente une valeur, ce que fait une fonction et comment un résultat est utilisé. Par exemple, une variable de temps devrait préciser à la fois l’intervalle et son unité, plutôt que de laisser un commentaire expliquer ces éléments.

Rendez le sens facile à trouver. Préférez des noms prononçables et distinctifs aux abréviations obscures, aux suites de nombres arbitraires ou aux noms qui ne font que satisfaire le compilateur. Un compteur de boucle peut être bref dans un tout petit périmètre; une valeur utilisée à de nombreux endroits a besoin d’un nom facile à retrouver. Une mise en forme cohérente et des conventions d’équipe aident les lecteurs à reconnaître la structure sans devoir réapprendre chaque fichier.

Analyse

Un code lisible réduit la quantité d’informations qu’une personne doit garder en mémoire de travail lorsqu’elle suit un changement. Le choix des noms relève donc de la conception d’interfaces : l’identifiant est souvent la première explication qu’un collaborateur rencontre. Le livre relie également le style local à la confiance au sein de l’équipe, puisqu’une mise en page cohérente permet aux lecteurs de prévoir où se trouvent les concepts. Il y a toutefois une limite. Des noms plus longs ne sont pas automatiquement plus clairs, et trop de détails dans un nom peuvent obscurcir une opération locale simple. La clarté dépend du concept et de son périmètre.

Gardez les fonctions assez petites pour exposer clairement une étape à la fois

Une fonction, un niveau. Une fonction devrait décrire une seule opération, dont les étapes internes sont exprimées au niveau de détail suivant. Martin le montre en transformant une routine d’affichage HTML embrouillée en une brève séquence qui repère les pages de test, inclut les éléments de préparation et de nettoyage, puis renvoie le résultat affiché. Les fonctions plus petites rendent le but visible sans obliger d’abord les lecteurs à déchiffrer le traitement de chaînes à bas niveau.

Réduisez la charge d’interprétation. Préférez un petit nombre d’arguments, évitez les indicateurs booléens qui font se comporter une fonction de deux façons différentes, et séparez les commandes qui modifient l’état des requêtes qui renvoient des informations. Les effets de bord cachés sont particulièrement coûteux: une fonction nommée comme une vérification de mot de passe ne devrait pas réinitialiser discrètement la session d’un utilisateur. Les exceptions peuvent également séparer la gestion des échecs de l’algorithme ordinaire.

Analyse

La structure narrative est plus qu’une préférence stylistique. Une séquence bien ordonnée permet au lecteur de passer de la politique au mécanisme, comme une bonne explication qui présente une affirmation avant ses preuves. Les petites fonctions facilitent aussi les tests et la réutilisation. Mais l’extraction peut aller trop loin : un programme découpé en innombrables petits wrappers insignifiants peut obliger les lecteurs à naviguer sans cesse d’une définition à l’autre. Le bon critère n’est pas une limite universelle de lignes, mais la capacité de chaque unité à poursuivre un objectif cohérent que l’on peut nommer sans se contenter de répéter son implémentation.

Donnez à chaque classe une seule raison de changer, puis choisissez sa forme délibérément

Comptez les responsabilités, pas les méthodes. Le principe de responsabilité unique stipule qu’une classe ne devrait avoir qu’une seule raison de changer. Un tableau de bord qui ne comporte que quelques méthodes peut malgré tout réunir des tâches sans rapport, comme gérer une fenêtre et indiquer les numéros de version du logiciel. Séparer le comportement lié aux versions crée une unité plus petite, dont l’objectif est plus clair. Une forte cohésion signifie que les données et les méthodes d’une classe vont ensemble; des ensembles sans rapport suggèrent qu’une autre classe s’y dissimule.

Choisissez les objets ou les structures de données selon les changements auxquels vous vous attendez. Les objets masquent les données et exposent des comportements, ce qui facilite l’ajout de nouveaux types. Les structures de données exposent leurs champs et permettent d’ajouter de nouvelles opérations sans modifier chaque type. Aucun de ces styles ne l’emporte dans tous les cas. Les mélanger produit des hybrides qui ne masquent ni les données ni les responsabilités, tout en compliquant les deux types de changement.

Analyse

C’est un correctif utile à l’idée que la conception orientée objet consiste à transformer chaque nom en objet. La véritable question est de savoir où les changements ont le plus de chances de survenir. Si de nouveaux types de comportements apparaissent souvent, des données exposées accompagnées d’opérations distinctes peuvent être plus simples ; si de nouveaux types de données apparaissent souvent, des objets polymorphes peuvent circonscrire les changements. Le critère de responsabilité est tout aussi pratique, mais il peut être subjectif. La frontière d’une classe est une hypothèse sur les changements à venir, et non une loi garantissant la bonne architecture.

Gardez les tests propres pour protéger les changements, sans en faire un autre système ancien

Les tests préservent la liberté d’améliorer. Le développement piloté par les tests, ou TDD, consiste à écrire un test qui échoue avant le comportement de production, à ajouter juste assez de code pour le faire réussir, puis à affiner le résultat tant que les tests restent au vert. Martin décrit un cycle rapide de test et d’implémentation. Les tests ne sont pas un échafaudage jetable. Une équipe a laissé son code de test devenir embrouillé; les développeurs ont fini par abandonner la suite, perdre confiance dans les changements et cesser d’améliorer le code de production.

Rendez les tests lisibles et fiables. Le livre recommande des tests rapides, indépendants, répétables et auto-vérifiants, écrits au plus près du code qu’ils spécifient. Une structure « préparer, exécuter, vérifier » aide les lecteurs à distinguer la mise en place, l’action et le résultat attendu. Testez un concept principal à la fois et concentrez suffisamment les assertions pour que l’échec désigne clairement un comportement.

Analyse

Les tests font office de mémoire exécutable. Ils préservent ce que l’équipe estime que le logiciel doit faire, même après le départ des développeurs d’origine. Leur valeur est à la fois technique et sociale : un test compréhensible fournit au réviseur des éléments pour accepter un changement. Attention toutefois : des tests qui passent ne suffisent pas à établir la correction totale du système. Une suite de tests reflète les cas que ses auteurs ont anticipés ; les vérifications aux limites, les scénarios d’échec et la revue humaine restent donc des compléments importants à l’automatisation.

Refactorisez par petites étapes vérifiées, et non par réécritures héroïques

Le code qui fonctionne n’est qu’une ébauche. Dans l’étude de cas consacrée à un analyseur en ligne de commande, la première version gérait proprement les options booléennes. L’ajout d’options textuelles et entières a multiplié les cas particuliers jusqu’à rendre l’implémentation ingérable. Plutôt que d’ajouter des fonctionnalités, Martin s’est arrêté pour extraire une abstraction commune de gestion des arguments. Les tests ont été exécutés après de petits changements, maintenant le comportement stable tandis que les responsabilités étaient redistribuées et que la logique dupliquée disparaissait.

Laissez les éléments observés guider le nettoyage. Lors de l’examen d’une classe de dates distincte, les tests d’origine ne couvraient qu’environ la moitié des instructions exécutables. Des tests supplémentaires ont révélé des erreurs aux limites, notamment un calcul du jour de la semaine qui renvoyait la date courante alors qu’il aurait dû trouver la prochaine occurrence. Les priorités d’une conception simple exposées dans le livre consistent à garder les tests au vert, supprimer les doublons, clarifier l’intention et éviter les classes ou méthodes inutiles. Les études de cas montrent que le perfectionnement passe souvent par l’essai d’un changement, sa vérification et sa révision.

Analyse

La refactorisation incrémentale ressemble à une expérimentation contrôlée : on modifie une variable, on observe le résultat et on préserve une base connue comme fonctionnelle. Le travail dépend ainsi moins de la mémoire et de l’assurance. Cela met aussi en évidence une distinction clé entre une réécriture et une transformation : le comportement est protégé tandis que la structure change. Toutefois, des tests au vert ne sont instructifs qu’à hauteur de leur couverture et de leurs assertions. L’exemple des dates est précieux précisément parce que des tests plus larges ont révélé des défauts que la suite initiale avait laissés invisibles.

Utilisez les commentaires pour expliquer les raisons, jamais pour camoufler un code confus

Le code devrait s’expliquer de lui-même. Un commentaire qui reformule une instruction évidente ne fait qu’ajouter du bruit, tandis qu’un commentaire devenu obsolète peut induire davantage en erreur que le silence. Si un commentaire explique qu’une condition vérifie l’admissibilité à une prestation, la condition sera peut-être plus claire sous la forme d’une fonction bien nommée. Des noms, de petites fonctions et des valeurs intermédiaires explicites expliquent souvent l’intention plus sûrement qu’un texte placé à côté d’un code dense.

Conservez les commentaires qui apportent le contexte manquant. Les mentions légales, la documentation des API publiques, les avertissements sur des conséquences non évidentes et les explications des raisons d’une décision surprenante peuvent être utiles. Supprimez les historiques de modifications obsolètes, le code commenté, les en-têtes verbeux et les notes TODO que personne ne relit. Le contrôle de version peut conserver le code supprimé; le fichier source n’a pas à servir d’archive de son propre historique.

Analyse

La distinction la plus importante est celle entre décrire ce que fait le code et expliquer pourquoi une décision a été prise. La première démarche fait souvent double emploi avec l’implémentation ; la seconde peut préserver un contexte que l’implémentation ne révèle pas. Cela rejoint les pratiques documentaires des domaines critiques pour la sécurité, où les raisons comptent parce que les mainteneurs futurs peuvent être confrontés à des contraintes qui ne sont plus visibles. Il est toutefois possible d’appliquer à l’excès le rejet des commentaires. Un code clair ne peut pas toujours communiquer une politique, des hypothèses métier ou un contournement délibéré ; une explication concise a donc sa place lorsqu’elle reste exacte.

Rendez les échecs explicites tout en gardant le chemin normal dégagé

Séparez la gestion des erreurs de l’algorithme. Les codes de retour obligent les appelants à vérifier chaque opération, ce qui conduit souvent à imbriquer des conditions de réussite autour du travail principal. Les exceptions peuvent réserver un chemin distinct à la gestion des échecs, tandis qu’un contexte d’erreur utile précise quelle opération a échoué et pourquoi. Un wrapper autour d’une API tierce peut convertir plusieurs exceptions propres au fournisseur en un type unique que l’application sait gérer de façon cohérente.

Ne rendez pas l’absence ambiguë. Renvoyer null impose une obligation cachée à chaque appelant et favorise les oublis de vérification. S’il n’y a aucun employé, par exemple, une liste vide permet à l’appelant d’itérer sans risque, sans avoir à bifurquer. Pour une situation particulière légitime, un objet dédié peut fournir le comportement normal; ainsi, un résultat de frais de repas peut fournir un montant d’indemnité journalière lorsqu’aucune demande de remboursement de repas n’existe. Évitez d’accepter des entrées null sauf si l’interface l’exige explicitement.

Analyse

Cette approche considère les erreurs comme une partie de l’interface, plutôt que comme des résidus d’implémentation gênants. Elle est particulièrement efficace lorsque les appelants peuvent réagir utilement à un échec et que les exceptions contiennent assez de contexte pour en établir la cause. Le recours à un cas particulier réduit également les embranchements en représentant une absence valide par une valeur utilisable. Les systèmes de types modernes peuvent rendre ces choix plus explicites, mais aucune représentation ne dispense de décider si un événement est exceptionnel, attendu ou récupérable.

Créez des points de séparation autour des bibliothèques et de l’initialisation pour circonscrire les changements

Confinez les hypothèses externes à la périphérie. Une collection à usage général, comme une map, peut autoriser des opérations ou des valeurs dont l’application ne veut pas. Un petit wrapper propre à l’application peut n’exposer que le comportement nécessaire et regrouper au même endroit les conversions de types, les règles de typage et les détails de la bibliothèque. Les tests d’apprentissage sont de petites expériences qui vérifient le comportement d’une API inconnue avant que le code de production n’en dépende. Des tests de log4j, par exemple, ont révélé des détails de configuration que la documentation seule ne rendait pas évidents.

Séparez la construction de l’utilisation. Construisez et reliez les objets principaux dans une zone d’initialisation, une fabrique ou un conteneur d’injection de dépendances. L’application peut alors utiliser de simples objets métier sans savoir comment chaque dépendance est assemblée. Pour une API qui n’existe pas encore, définissez l’interface dont l’application a besoin et faites le pont avec le fournisseur qui la proposera au moyen d’un adaptateur.

Analyse

Une frontière est à la fois un point de séparation technique et un lieu où gérer l’incertitude. Les wrappers réduisent le nombre d’endroits touchés par un changement de fournisseur, tandis que les tests d’apprentissage transforment un comportement non documenté en éléments probants reproductibles. Séparer l’initialisation de l’exécution facilite également les tests de la logique applicative sans avoir à construire tout l’environnement. Le compromis est le coût des abstractions : envelopper chaque type de bibliothèque ou adopter prématurément un grand framework peut créer plus de mécanismes que de protection. Encapsulez une frontière lorsqu’elle limite les usages incorrects ou réduit sensiblement le coût des changements.

Traitez la concurrence comme un problème de conception à part entière, et non comme un bouton d’accélération

L’état partagé crée des chemins d’exécution cachés. Deux threads qui incrémentent le même identifiant peuvent tous deux lire l’ancienne valeur avant que l’un ou l’autre n’écrive, créant un doublon et perdant une mise à jour. Le livre calcule 12 870 entrelacements possibles de bytecode pour un incrément simple effectué par deux threads, illustrant pourquoi une instruction qui semble indivisible ne l’est pas nécessairement. La concurrence est utile lorsque des tâches peuvent se chevaucher pendant les périodes d’attente, par exemple lors d’accès réseau; elle n’accélère pas automatiquement les tâches limitées par le processeur.

Réduisez les possibilités d’interférence. Gardez le code qui tient compte des threads séparé, limitez les données partagées, utilisez des copies ou des données propres à chaque tâche lorsque c’est possible, et réduisez la taille des régions synchronisées. Familiarisez-vous avec le modèle d’exécution et les outils de bibliothèque concernés. Testez avec différents nombres de threads, sur diverses plateformes et sous différentes charges; considérez les échecs rares comme des preuves réelles, au lieu de les balayer comme des cas isolés.

Analyse

L’idée centrale du chapitre est que la concurrence élargit l’ensemble des historiques d’exécution auxquels le programme doit pouvoir résister. L’isolation et les interfaces contrôlées deviennent ainsi plus précieuses que des verrous ingénieux dispersés dans le code applicatif. L’intérêt en matière de performances dépend du contexte : le travail en parallèle peut masquer les temps d’attente, mais les threads supplémentaires entraînent aussi davantage de coordination et de contention. Une conception responsable commence par identifier le goulot d’étranglement et l’état partagé, puis met à l’épreuve les hypothèses sur l’ordonnancement grâce aux tests, plutôt que de croire qu’une exécution réussie prouve l’innocuité du système.

Analyse

CODER PROPREMENT se comprend avant tout comme un livre consacré à la maîtrise du coût des changements. Ses techniques précises, du choix de noms évocateurs aux interfaces étroites, réduisent toutes la quantité de contexte implicite qu’un développeur futur doit reconstituer. Le récit renforce cette thèse à travers des produits dégradés, des fonctions tentaculaires, un analyseur de ligne de commande sauvé par la refactorisation et une logique de dates dont les défauts ne sont apparus qu’avec des tests plus étendus. Ces exemples comptent parce que les conseils sont présentés comme un savoir-faire acquis par la pratique, et non comme une liste de contrôle qui produirait miraculeusement de la qualité.

La synthèse la plus durable prend la forme d’une boucle de rétroaction: exprimer clairement l’intention, tester le comportement, apporter une petite amélioration structurelle et vérifier que le comportement reste intact. La lisibilité facilite l’examen des défauts et des responsabilités. Les tests rendent le nettoyage moins inquiétant. De petites frontières empêchent les changements externes de se propager. Ces pratiques se renforcent mutuellement; traiter les tests ou la mise en forme comme des finitions facultatives fragilise donc l’ensemble du système.

Le livre assume des positions tranchées, et certaines de ses règles valent mieux comme principes par défaut que comme absolus. Des fonctions très petites peuvent fragmenter le flux de contrôle. Les abstractions peuvent se multiplier sans apporter de souplesse utile. Les commentaires peuvent préserver une justification liée au domaine que les noms ne sauraient exprimer. Même la meilleure architecture dépend des types de changements auxquels le système est réellement confronté. Les études de cas du livre illustrent un critère plus sain que la conformité rigide: examiner le code, vérifier les hypothèses, apporter un changement local et en juger le résultat.

Son affirmation plus générale, d’ordre professionnel, est que rapidité et rigueur ne sont pas incompatibles lorsque le logiciel doit évoluer. La mesure pertinente n’est pas la vitesse à laquelle le code est saisi, mais la facilité avec laquelle une équipe peut le comprendre, le modifier sans risque et le vérifier. La propreté n’est donc pas une perfection visuelle. C’est un investissement continu pour que le prochain changement reste compréhensible et abordable.

Résumé en 30 secondes
Les programmeurs passent plus de dix fois plus de temps à lire le code qu’à l’écrire ; des noms précis, des fonctions courtes et des limites claires réduisent donc le travail futur. Les tests devraient être rapides, indépendants, répétables et auto-vérifiables. Refactorisez par petits changements vérifiés plutôt que par de grandes réécritures. Deux fils d’exécution peuvent créer 12 870 entrelacements autour d’une seule incrémentation, faisant de l’état partagé un problème de conception à part entière. Masquez les API externes derrière des interfaces étroites.
Contient des spoilers

Dernière mise à jour:

Signaler un problème

Résumé des avis

4.35 sur 5
Moyenne de 23 000+ évaluations de Goodreads et Amazon.

CODER PROPREMENT reçoit dans l’ensemble des critiques positives pour ses principes d’écriture d’un code lisible et facile à maintenir. Les lecteurs apprécient les conseils pratiques sur le nommage, les fonctions et les tests. L’accent mis sur Java et certaines recommandations jugées trop strictes font partie des critiques récurrentes. Beaucoup considèrent le livre comme une lecture essentielle pour les développeurs, même si certains le trouvent moins utile aux programmeurs expérimentés. Les études de cas et les exemples de refactorisation sont loués par certains, mais jugés excessifs par d’autres. Dans l’ensemble, les critiques s’accordent à reconnaître que le livre offre des éclairages précieux sur la qualité du code, même si toutes ses suggestions ne s’appliquent pas universellement.

Votre note :
4.78
3183 évaluations
Envie de lire le livre complet ?

Glossaire

sens du code

jugement en matière de refactorisation

Aptitude acquise à reconnaître un code peu clair ou embrouillé, à imaginer de meilleures solutions et à choisir une succession de changements qui préservent le comportement afin de l’améliorer. Le livre présente cette aptitude comme une compétence qui se développe par une pratique répétée, et non comme un instinct que l’on acquiert en mémorisant des règles.

règle du scout

laisser le code en meilleur état

Principe de maintenance qui invite les développeurs à apporter une petite amélioration chaque fois qu’ils travaillent sur une partie du code. Le changement n’a pas besoin d’être important : un nom plus clair, une fonction plus courte ou la suppression d’une duplication peuvent éviter une dégradation progressive si cette pratique est répétée.

règle de progression par étapes

ordonner par niveau d’abstraction

Façon d’organiser les fonctions pour que le lecteur puisse passer d’une opération de haut niveau aux étapes de plus bas niveau qui la mettent en œuvre. Chaque fonction appelle ou introduit le niveau de détail suivant, de sorte que le fichier source se lise comme une explication de plus en plus précise.

principe de responsabilité unique

une seule raison de changer

Principe de conception selon lequel une classe ou un module ne devrait avoir qu’une seule responsabilité, entendue comme une raison principale de devoir changer. Il guide la délimitation des classes : les comportements qui changent pour des raisons sans rapport les unes avec les autres peuvent être séparés en unités distinctes.

loi de Déméter

limiter la navigation entre objets

Heuristique de conception qui déconseille à une méthode de parcourir plusieurs objets pour accéder à un détail interne. Un module devrait principalement communiquer avec ses propres méthodes, les objets qu’il crée, les arguments qu’il reçoit et les objets qu’il détient directement, plutôt que de dépendre du graphe d’objets d’un collaborateur.

F.I.R.S.T.

cinq qualités des tests

Acronyme désignant les qualités de tests unitaires propres : rapides, indépendants, répétables, auto-validants et écrits en temps utile. Ensemble, ces qualités rendent les tests pratiques à exécuter fréquemment, faciles à diagnostiquer et étroitement liés au code dont ils spécifient le comportement.

tests d’apprentissage

sonder les API externes

Petits tests écrits pour explorer et confirmer le comportement d’une bibliothèque tierce utilisée comme l’application le prévoit. Ils rendent exécutables les hypothèses concernant une interface inconnue, aident à distinguer le comportement de la bibliothèque des erreurs de l’application et peuvent détecter des changements incompatibles après une mise à niveau de la bibliothèque.

injection de dépendances

fournir les dépendances de l’extérieur

Approche de gestion des dépendances dans laquelle un objet ne construit pas et ne recherche pas lui-même ses collaborateurs. Une routine de démarrage ou un conteneur crée les objets nécessaires et les fournit par l’intermédiaire de constructeurs ou de méthodes setter, séparant ainsi la construction des objets du comportement de l’application à l’exécution.

motif du cas particulier (Special Case Pattern)

encapsuler les exceptions attendues

Technique qui consiste à représenter une situation exceptionnelle mais légitime par un objet fournissant le comportement approprié, afin que les appelants n’aient pas besoin d’une branche distincte. Par exemple, une requête de frais peut renvoyer un objet de frais de repas qui fournit un montant d’indemnité journalière lorsqu’aucun frais de repas n’a été enregistré.

séparation commande-requête

séparer la modification de la consultation

Principe de conception qui attribue un seul rôle à une fonction : soit modifier l’état d’un objet, soit renvoyer des informations à son sujet. La combinaison des deux peut rendre un appel ambigu, en particulier lorsqu’une opération qui modifie l’état est utilisée comme condition. Séparer ces rôles rend le code et son intention plus faciles à comprendre.

FAQ

De quoi parle « CODER PROPREMENT » ?

  • L’accent sur un code propre : « CODER PROPREMENT » de Robert C. Martin insiste sur l’écriture d’un code facile à lire, à comprendre et à maintenir.
  • Le professionnalisme en programmation : Le livre soutient qu’un code propre est une marque de professionnalisme dans le développement logiciel.
  • Des conseils pratiques : Il propose des recommandations, des exemples et des études de cas pour aider les développeurs à écrire un code propre et efficace.

Pourquoi lire « CODER PROPREMENT » ?

  • Améliorer ses compétences en programmation : Le livre enseigne comment écrire un code propre, efficace et facile à maintenir.
  • Apprendre auprès d’experts : Il fait partie de la série de Robert C. Martin, connue pour son approche technique et pragmatique.
  • Des bénéfices à long terme : Écrire un code propre réduit les coûts de maintenance et fait de vous un développeur plus précieux.

Quels sont les principaux enseignements de « CODER PROPREMENT » ?

  • Lisibilité du code : Le livre souligne que le code doit être facile à lire et à comprendre.
  • Principe de responsabilité unique : Il préconise qu’une classe ou une fonction n’ait qu’une seule raison de changer.
  • Amélioration continue : Il encourage les développeurs à améliorer continuellement leur code en suivant la règle du scout.

Comment « CODER PROPREMENT » définit-il un code propre ?

  • Élégance et efficacité : Le code propre est décrit comme élégant et efficace, avec un minimum de dépendances.
  • Lisible et facile à maintenir : Il devrait se lire comme un texte bien écrit et rendre claire l’intention du concepteur.
  • Ciblé et cohérent : Chaque fonction, classe et module devrait avoir un objectif unique et clair.

Qu’est-ce que le principe de responsabilité unique dans « CODER PROPREMENT » ?

  • Une seule raison de changer : Une classe ou un module ne devrait avoir qu’une seule raison de changer.
  • Une meilleure cohésion : Il garantit la cohésion des classes, dont les méthodes et les variables sont étroitement liées.
  • Une maintenance facilitée : Il rend le code plus facile à maintenir et à étendre, et réduit l’impact des changements.

Qu’est-ce que la « règle du scout » mentionnée dans « CODER PROPREMENT » ?

  • Amélioration continue : Elle suggère de laisser le code dans un meilleur état qu’on ne l’a trouvé.
  • Petits changements progressifs : Elle encourage les petites améliorations, comme renommer des variables ou scinder des fonctions.
  • Responsabilité professionnelle : Elle est présentée comme une responsabilité professionnelle visant à garantir la maintenabilité.

Comment « CODER PROPREMENT » aborde-t-il le développement piloté par les tests (TDD) ?

  • Une discipline fondamentale : Le TDD est essentiel à l’écriture d’un code propre et fiable.
  • Les trois lois du TDD : Écrire d’abord un test qui échoue, écrire le code nécessaire pour le faire réussir, puis refactoriser.
  • Les avantages : Cette approche aide à détecter tôt les bogues et améliore la conception du code.

Que sont les « code smells » selon « CODER PROPREMENT » ?

  • Définition : Des indicateurs de problèmes potentiels qui nuisent à la lisibilité ou à la maintenabilité.
  • Exemples : Les méthodes longues, les classes volumineuses et le code dupliqué.
  • Comment y remédier : Le livre propose des heuristiques et des techniques de refactorisation pour améliorer la qualité du code.

Comment « CODER PROPREMENT » recommande-t-il de gérer les exceptions ?

  • Préférer les exceptions : Utiliser des exceptions plutôt que des codes d’erreur pour bénéficier d’un meilleur contexte et d’une meilleure gestion.
  • Fournir du contexte : Inclure des messages pertinents et du contexte lorsqu’on lance des exceptions.
  • Éviter les exceptions vérifiées : Le livre recommande les exceptions non vérifiées pour un code plus propre.

Quel rôle les tests unitaires jouent-ils dans « CODER PROPREMENT » ?

  • Garantir la qualité du code : Les tests unitaires vérifient que le code fonctionne comme prévu et reste facile à maintenir.
  • Développement piloté par les tests : Le livre préconise d’écrire les tests avant le code de production.
  • Des tests propres et lisibles : Les tests devraient être aussi propres et lisibles que le code de production.

Quel est le rôle de la refactorisation dans « CODER PROPREMENT » ?

  • Amélioration continue : La refactorisation améliore la structure et la lisibilité du code sans en modifier les fonctionnalités.
  • Techniques : Le livre présente des techniques comme l’extraction de méthode et le renommage de variable pour améliorer la qualité du code.
  • Refactoriser sans crainte : Grâce à des tests complets, les développeurs peuvent refactoriser en toute confiance.

Quelles sont les meilleures citations de « CODER PROPREMENT » et que signifient-elles ?

  • « Un code propre fait bien une seule chose. » Cette citation souligne l’importance de la concentration et de la clarté dans le code.
  • « Laissez le terrain de camping plus propre que vous ne l’avez trouvé. » Elle encourage l’amélioration continue du code.
  • « Vous savez que vous travaillez sur du code propre lorsque chaque routine que vous lisez se révèle être à peu près ce à quoi vous vous attendiez. » Cette citation met en évidence l’importance de la lisibilité et de la prévisibilité.

À propos de l'auteur

Robert Cecil Martin, connu sous le nom d’Uncle Bob, est un ingénieur logiciel et consultant de renom. Il défend les méthodes de développement Agile et préside Object Mentor Inc. Son expertise couvre la conception orientée objet, les patrons de conception, UML et l’eXtreme Programming. Il a travaillé avec des clients dans le monde entier, partageant ses connaissances par le biais de missions de conseil et de conférences. Martin a été rédacteur en chef du C++ Report de 1996 à 1999. Figure marquante de la communauté du développement logiciel, il intervient fréquemment lors de conférences et de salons internationaux. Son influence dépasse le cadre de ses activités de conseil grâce à ses livres et à ses articles sur l’artisanat logiciel et les bonnes pratiques.

Télécharger le PDF

Pour garder le résumé de CODER PROPREMENT 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 CODER PROPREMENT 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
600,000+ 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...