Clean Code

1. Écrire un code propre, lisible et maintenable

La seule mesure valable de la qualité du code : WTFs/minute

La lisibilité est primordiale. Un code propre doit être facilement compris par d'autres développeurs. Il doit être simple, élégant et sans encombrement. Efforcez-vous d'écrire un code qui exprime clairement son intention sans avoir besoin de commentaires extensifs. Utilisez des noms de variables et de fonctions significatifs, gardez les fonctions petites et ciblées, et organisez le code de manière logique.

La maintenabilité permet l'évolution. Un code difficile à modifier devient un handicap. Concevez votre code pour qu'il soit flexible et modulaire afin qu'il puisse s'adapter aux exigences changeantes. Suivez des principes comme DRY (Don't Repeat Yourself) et SOLID pour créer des systèmes faiblement couplés et hautement cohésifs. Refactorez sans pitié pour améliorer la structure du code sans en changer le comportement.

Le code propre est rentable. Bien que l'écriture d'un code propre demande plus d'efforts au départ, elle permet de gagner beaucoup de temps et d'éviter des maux de tête à long terme. Un code propre est plus facile à déboguer, à étendre et à maintenir. Il permet aux développeurs de travailler plus efficacement et réduit le risque d'introduire des bugs lors des modifications. Faites du code propre une partie essentielle de votre pratique de développement.

2. Suivre des conventions de nommage significatives

Le nom d'une variable, d'une fonction ou d'une classe doit répondre à toutes les grandes questions. Il doit indiquer pourquoi il existe, ce qu'il fait et comment il est utilisé.

Utilisez des noms révélateurs d'intention. Choisissez des noms qui transmettent clairement le but et le comportement des variables, fonctions et classes. Évitez les noms à une seule lettre ou les abréviations cryptiques. Utilisez des noms prononçables qui peuvent être facilement recherchés. Par exemple :

• Mauvais : d (temps écoulé en jours)
• Bon : elapsedTimeInDays

Soyez cohérent et précis. Utilisez des conventions de nommage cohérentes dans tout votre code. Soyez précis pour éviter toute ambiguïté - par exemple, utilisez des distinctions significatives comme getActiveAccounts() et getActiveAccountInfo(). Évitez les encodages ou les préfixes qui ajoutent du bruit sans valeur. Les noms de classes doivent être des noms, les noms de méthodes doivent être des verbes.

La longueur du nom doit correspondre à la portée. Utilisez des noms plus longs et plus descriptifs pour les variables et les fonctions avec des portées plus larges. Les noms courts sont acceptables pour les petites portées locales. La longueur d'un nom doit être proportionnelle à sa portée d'utilisation. Optimisez pour la lisibilité et la compréhension dans le contexte où le nom est utilisé.

3. Garder les fonctions petites et ciblées

Les fonctions doivent faire une seule chose. Elles doivent bien le faire. Elles doivent le faire uniquement.

Petit est beau. Les fonctions doivent être petites - généralement de 5 à 10 lignes. Elles doivent tenir sur un écran et être immédiatement compréhensibles. Extrayez le code en fonctions auxiliaires bien nommées plutôt que d'écrire des fonctions longues et complexes. Les petites fonctions sont plus faciles à comprendre, à tester et à maintenir.

Faire une seule chose bien. Chaque fonction doit avoir un but unique et clair. Si une fonction fait plusieurs choses, extrayez-les en fonctions séparées. Les signes qu'une fonction fait trop incluent :

• Plusieurs niveaux d'abstraction
• Plusieurs sections ou blocs de code
• De nombreux paramètres

Maintenir un seul niveau d'abstraction. Les instructions dans une fonction doivent toutes être au même niveau d'abstraction. Ne mélangez pas la logique de haut niveau avec les détails de bas niveau. Extrayez les opérations de bas niveau en fonctions séparées. Cela améliore la lisibilité en gardant les fonctions ciblées et conceptuellement simples.

4. Pratiquer un formatage et une organisation appropriés

Le formatage du code concerne la communication, et la communication est la première priorité du développeur professionnel.

Un formatage cohérent est important. Utilisez une indentation, des sauts de ligne et des espacements cohérents dans tout votre code. Cela améliore la lisibilité et réduit la charge cognitive. Mettez-vous d'accord sur des normes de formatage avec votre équipe et utilisez des outils automatisés pour les appliquer. Les principales directives de formatage incluent :

• Une indentation appropriée
• Un placement cohérent des accolades
• Des sauts de ligne logiques
• Un espacement approprié

Organiser le code de manière logique. Regroupez le code lié ensemble et séparez le code non lié. Utilisez des lignes vides pour créer des "paragraphes" entre les sections logiques. Placez les fonctions liées les unes près des autres. Gardez les fichiers centrés sur un seul concept ou composant. Divisez les fichiers volumineux en fichiers plus petits et plus ciblés lorsque cela est approprié.

Suivre les conventions standard. Adhérez aux conventions standard pour votre langage et votre communauté. Cela rend votre code plus familier et accessible aux autres développeurs. Par exemple, en Java :

• Les noms de classes utilisent PascalCase
• Les noms de méthodes utilisent camelCase
• Les constantes utilisent ALL_CAPS

5. Gérer les dépendances et éviter la duplication

La duplication peut être la racine de tous les maux en logiciel.

Éliminer la duplication. Le code dupliqué est une occasion manquée d'abstraction. Lorsque vous voyez de la duplication, extrayez le code commun dans une fonction ou une classe réutilisable. Cela améliore la maintenabilité en centralisant la logique et en réduisant le risque de modifications incohérentes. Types de duplication à surveiller :

• Blocs de code identiques
• Algorithmes similaires avec de légères variations
• Chaînes switch/case ou if/else répétées

Gérer les dépendances avec soin. Minimisez les dépendances entre les modules pour réduire le couplage. Utilisez l'injection de dépendances et l'inversion de contrôle pour rendre le code plus modulaire et testable. Suivez le principe d'inversion de dépendance - dépendez des abstractions, pas des concrétions. Cela rend votre code plus flexible et plus facile à modifier.

Utiliser le principe de moindre connaissance. Un module ne doit pas connaître les détails internes des objets qu'il manipule. Cela réduit le couplage entre les modules. Par exemple, utilisez la loi de Demeter - une méthode ne doit appeler que des méthodes sur :

• Son propre objet
• Les objets passés en paramètres
• Les objets qu'elle crée
• Ses objets composants directs

6. Gérer les erreurs avec élégance

La gestion des erreurs est importante, mais si elle obscurcit la logique, elle est incorrecte.

Utiliser des exceptions plutôt que des codes d'erreur. Les exceptions sont plus propres et ne surchargent pas la logique principale de votre code. Elles permettent de séparer la gestion des erreurs du chemin heureux. Lors de l'utilisation des exceptions :

• Créez des messages d'erreur informatifs
• Fournissez du contexte avec les exceptions
• Définissez des classes d'exception en fonction des besoins de l'appelant

Ne retournez pas null. Retourner null conduit à des exceptions de pointeur null et surcharge le code avec des vérifications null. À la place :

• Retournez des collections vides au lieu de null pour les listes
• Utilisez le pattern Null Object
• Utilisez Optional en Java ou Maybe dans les langages fonctionnels

Écrivez d'abord les instructions try-catch-finally. Commencez par le try-catch-finally lorsque vous écrivez du code qui pourrait lancer des exceptions. Cela aide à définir la portée et les attentes pour le code appelant. Cela garantit que les ressources sont correctement gérées et libérées, même en cas d'erreur.

7. Écrire des tests unitaires complets

Le code de test est tout aussi important que le code de production.

Suivre les trois lois du TDD. Le développement piloté par les tests (TDD) améliore la qualité et la conception du code :

1. Écrivez un test qui échoue avant d'écrire du code de production
2. Écrivez juste assez de test pour démontrer un échec
3. Écrivez juste assez de code de production pour passer le test

Gardez les tests propres et maintenables. Appliquez les mêmes normes de qualité de code à vos tests qu'à votre code de production. Refactorez et améliorez régulièrement le code de test. Des tests bien structurés servent de documentation et permettent une refactorisation sans crainte du code de production.

Visez une couverture de test complète. Écrivez des tests qui couvrent les cas limites, les conditions de bord et les scénarios d'erreur - pas seulement le chemin heureux. Utilisez des outils de couverture de code pour identifier les lacunes dans la couverture des tests. Rappelez-vous que 100% de couverture ne garantit pas un code sans bug, mais cela donne confiance dans la refactorisation et les modifications.

8. Refactoriser le code en continu

Laissez le terrain de camping plus propre que vous ne l'avez trouvé.

Refactoriser de manière opportuniste. Améliorez la structure du code chaque fois que vous travaillez sur un morceau de code. Suivez la règle du scout : laissez le code meilleur que vous ne l'avez trouvé. Les petites améliorations incrémentales s'additionnent au fil du temps et empêchent la dégradation du code. Les techniques de refactorisation courantes incluent :

• Extraction de méthodes ou de classes
• Renommage pour plus de clarté
• Simplification des conditionnels complexes
• Suppression de la duplication

Refactoriser en toute sécurité avec des tests. Ayez toujours une suite de tests solide avant de refactoriser. Faites de petits changements incrémentaux et exécutez les tests fréquemment. Cela vous donne confiance que vos modifications ne cassent pas les fonctionnalités existantes. Utilisez des outils de refactorisation automatisés lorsque disponibles pour réduire le risque d'introduire des erreurs.

Équilibrer la refactorisation avec la livraison de valeur. Bien que la refactorisation continue soit importante, ne laissez pas cela paralyser les progrès. Visez le "suffisamment bon" plutôt que la perfection. Concentrez les efforts de refactorisation sur les zones de code les plus problématiques ou les plus fréquemment modifiées. Communiquez la valeur de la refactorisation aux parties prenantes pour garantir le soutien à l'amélioration continue du code.

9. Appliquer les principes de programmation orientée objet et fonctionnelle

Les objets cachent leurs données derrière des abstractions et exposent des fonctions qui opèrent sur ces données. Les structures de données exposent leurs données et n'ont pas de fonctions significatives.

Utiliser les principes orientés objet avec sagesse. Appliquez des principes comme l'encapsulation, l'héritage et le polymorphisme pour créer des conceptions flexibles et modulaires. Suivez les principes SOLID :

• Principe de responsabilité unique
• Principe ouvert/fermé
• Principe de substitution de Liskov
• Principe de ségrégation des interfaces
• Principe d'inversion de dépendance

Exploiter les concepts de programmation fonctionnelle. Même dans les langages orientés objet, les techniques de programmation fonctionnelle peuvent conduire à un code plus propre :

• Fonctions pures sans effets de bord
• Données immuables
• Fonctions d'ordre supérieur
• Composition de fonctions

Choisir la bonne approche pour le problème. Les paradigmes orientés objet et fonctionnel ont chacun leurs forces et leurs faiblesses. Utilisez la conception orientée objet lorsque vous devez modéliser des domaines complexes avec des comportements. Utilisez des approches fonctionnelles pour la transformation et le traitement des données. De nombreux langages modernes supportent une approche hybride, vous permettant d'utiliser le meilleur outil pour chaque partie de votre système.

10. Considérer la concurrence avec soin

La concurrence est une stratégie de découplage. Elle nous aide à découpler ce qui est fait de quand c'est fait.

Comprendre les défis de la concurrence. La programmation concurrente introduit de la complexité et le potentiel de bugs subtils. Les problèmes courants incluent :

• Conditions de course
• Deadlocks
• Signaux manqués
• Problèmes de visibilité de la mémoire

Séparer les préoccupations de concurrence. Gardez votre code lié à la concurrence séparé du reste du code. Cela le rend plus facile à raisonner et à tester. Utilisez des abstractions comme Executors, Futures et Actors pour gérer la concurrence plutôt que de travailler avec des threads bruts.

Préférer l'immuabilité et les fonctions pures. Les objets immuables et les fonctions pures sont intrinsèquement thread-safe. Ils éliminent de nombreux problèmes de concurrence en évitant l'état mutable partagé. Lorsque l'état mutable est nécessaire, utilisez des techniques de synchronisation appropriées et envisagez d'utiliser des variables atomiques ou des collections concurrentes.

Last updated: July 25, 2024