Dans ce module, nous allons nous plonger dans les principes essentiels de conception de logiciels, en nous concentrant sur les principes SOLID. Vous explorerez comment ces principes peuvent être appliqués pour créer une architecture logicielle plus propre, plus facile à maintenir et plus évolutive. Nous aborderons également les techniques permettant de structurer efficacement les modules afin d'améliorer la qualité du code.

Dans ce module, nous vous guiderons sur la manière de lire et de comprendre efficacement de grandes bases de code. Vous apprendrez des techniques pour naviguer efficacement dans le code et identifier les zones où les odeurs de code peuvent être améliorées ou remaniées pour plus de clarté et de maintenabilité.

Dans ce module, nous présenterons l'odeur de code des commutateurs répétés et discuterons de son impact négatif sur la lisibilité et la maintenabilité du code. Vous apprendrez à reconnaître et à remanier les instructions switch répétées pour obtenir un code plus propre et plus facile à maintenir.

Dans ce module, nous explorerons l'obsession primitive code smell, en nous concentrant sur la façon dont la surutilisation des types de données primitifs peut compliquer votre code. Vous apprendrez à les remplacer par des objets spécifiques au domaine, ce qui améliorera l'abstraction et la lisibilité.

Dans ce module, nous aborderons les structures de boucle inefficaces, l'un des problèmes de code les plus courants, et nous discuterons de leur impact à la fois sur les performances et sur la lisibilité. Nous présenterons les meilleures pratiques pour remanier les boucles afin de les rendre plus efficaces et plus faciles à comprendre.

Dans ce module, nous aborderons l'odeur de code des longues listes de paramètres et la manière dont les paramètres excessifs peuvent compliquer les signatures de fonctions. Vous apprendrez des stratégies pour simplifier ces listes, telles que l'utilisation d'objets ou de valeurs par défaut pour améliorer la lisibilité et la maintenabilité.

Dans ce module, nous aborderons l'odeur de code de la duplication des connaissances, en expliquant comment la logique répétée dans la base de code peut conduire à des incohérences et à des coûts de maintenance plus élevés. Vous apprendrez des techniques de refactorisation et de suppression des redondances afin d'améliorer la maintenabilité de votre logiciel.

Dans ce module, nous étudierons comment les commentaires non informatifs peuvent encombrer votre code et en réduire la clarté. Vous apprendrez à rédiger des commentaires utiles et concis et à améliorer la lisibilité du code en éliminant les redondances.

Dans ce module, nous allons plonger dans le code smell de la chirurgie shotgun, où les changements dans une partie du système nécessitent des modifications à travers plusieurs classes. Vous apprendrez des stratégies de refactorisation pour réduire la complexité de ces changements dispersés et améliorer la maintenabilité.

Dans ce module, nous aborderons le problème des classes alternatives avec des interfaces incohérentes, ce qui peut entraîner des confusions et des problèmes d'utilisation. Vous apprendrez à remanier les classes pour unifier les interfaces et améliorer la cohérence du code.

Dans ce module, nous allons explorer l'odeur de code du legs refusé, qui se produit lorsqu'une sous-classe hérite d'une fonctionnalité qu'elle n'utilise pas. Vous apprendrez comment remanier votre code pour réduire l'utilisation abusive de l'héritage et préférer la composition pour améliorer la flexibilité et la maintenabilité.

Dans ce module, nous aborderons l'odeur de code des amas de données, où des données connexes sont regroupées de manière inappropriée. Vous apprendrez à remanier ces structures de données afin d'améliorer l'organisation et l'encapsulation pour une meilleure maintenabilité.

Dans ce module, nous examinerons l'odeur de code de l'homme du milieu, où les classes inutiles ajoutent de la complexité en déléguant simplement des fonctionnalités. Vous apprendrez à remanier votre code en supprimant les couches d'abstraction inutiles afin de simplifier votre base de code.

Dans ce module, nous explorerons les données mutables et la façon dont les changements d'état incontrôlés peuvent entraîner des bogues et des incohérences. Vous apprendrez à remanier votre code pour gérer efficacement l'immutabilité des données afin d'améliorer la fiabilité et la prévisibilité.

Dans ce module, nous aborderons l'odeur de code de l'envie de fonctionnalité, où les méthodes ont tendance à se concentrer trop fortement sur les données d'une autre classe. Vous apprendrez à remanier votre code pour améliorer les frontières entre les objets et déplacer le comportement vers la classe à laquelle il appartient logiquement.

Dans ce module, nous allons explorer l'odeur de code de changement divergent, où un module nécessite des modifications fréquentes pour des raisons sans rapport. Vous apprendrez comment remanier votre code afin de minimiser le risque que des modifications fréquentes entraînent une instabilité ou des régressions.

Dans ce module, nous explorerons la question des grandes interfaces et la façon dont elles peuvent rendre le code difficile à maintenir et à étendre. Vous apprendrez à remanier les grandes interfaces pour en faire des interfaces plus petites et plus faciles à gérer, plus faciles à maintenir et à faire évoluer.

Dans ce module, nous aborderons l'odeur de code multitâche, où les classes ou les méthodes assument trop de responsabilités. Vous apprendrez à appliquer le principe de la responsabilité unique pour remanier votre code et améliorer sa clarté et sa maintenabilité.

Dans ce module, nous nous concentrerons sur l'importance de conventions de nommage claires et intuitives. Vous apprendrez comment des noms peu clairs peuvent prêter à confusion et comment adopter les meilleures pratiques pour nommer les variables, les fonctions et les classes afin d'améliorer la lisibilité.

Dans ce module, nous discuterons de la généralité spéculative et de la manière dont une ingénierie excessive peut rendre le code inutilement complexe. Vous apprendrez comment simplifier le code en supprimant les abstractions prématurées et en vous concentrant sur les besoins actuels.

Dans ce module, nous allons explorer l'odeur de code des exceptions inutiles, où l'utilisation excessive des exceptions rend la gestion des erreurs plus compliquée que nécessaire. Vous apprendrez à simplifier la Gestion des exceptions pour obtenir un code plus clair et plus robuste.

Dans ce module, nous discuterons de l'odeur de code des modules peu profonds, où les modules contiennent peu de fonctionnalités par rapport à leur complexité. Vous apprendrez comment remanier ces modules afin de fournir des fonctionnalités plus significatives et d'améliorer leur réutilisation.

Dans ce dernier module, nous résumerons les principaux enseignements du cours, renforcerons l'importance des pratiques de code propre et offrirons des conseils sur la façon de continuer à améliorer vos compétences en matière de conception de logiciels pour améliorer la maintenabilité et l'évolutivité.