Chapitre 1 : Tout est gestion de la complexité

1.1 Conception orientée objet et épreuves du temps
1.2 Conception de systèmes orientés objet simples
__1.2.1 Code simple
__1.2.2 Objets cohérents
1.2.3 Gestion appropriée des dépendances
__1.2.4 Bonne abstraction
1.2.5 Gestion appropriée des dépendances externes et de l'infrastructure
__1.2.6 Bonne modularisation
1.3 Un design simple comme activité quotidienne
1.3.1 Réduire la complexité est similaire à l'hygiène personnelle
__1.3.2 La complexité peut être nécessaire, mais elle ne doit pas être permanente.
__1.3.3 Il est rentable de s'attaquer en permanence à la complexité.
1.3.4 Un code de haute qualité favorise les bonnes pratiques
1.3.5 Maîtriser la complexité n'est pas aussi difficile qu'on le croit
__1.3.6 Il est de la responsabilité du développeur de maintenir la simplicité de la conception.
__1.3.7 C'est une conception suffisamment bonne
1.4 Passez brièvement en revue l'architecture des systèmes d'information.
1.5 Exemple : Les gens grandissent !
1.6 Exercices pratiques
1.7 Résumé

Chapitre 2 : Maintenir un code concis

2.1 Réduisez la taille de vos unités de code.
__2.1.1 Diviser les méthodes complexes en méthodes privées
__2.1.2 Déplacer les unités de code complexes vers d'autres classes
__2.1.3 Quand ne pas découper le code en unités plus petites
__2.1.4 Examinez l'ensemble du code avant de le refactoriser
__2.1.5 Exemple : Importation des données des employés
2.2 Rendez votre code lisible et documenté.
__2.2.1 Continuez à chercher un bon nom
2.2.2 Documentez vos décisions
__2.2.3 Ajoutez des commentaires à votre code
__2.2.4 Exemple : Déterminer le moment opportun pour envoyer un courriel informant d’une modification du contenu de l’offre
2.3 Séparer la nouvelle complexité des classes existantes.
__2.3.1 Séparer la logique métier complexe dans sa propre classe.
2.3.2 Décomposer les principaux flux d'activité
2.3.3 Exemple : Liste d’attente pour une offre
2.4 Exercices pratiques
2.5 Résumé

Chapitre 3 Maintien de la cohérence des objets

3.1 Soyez toujours cohérent
__3.1.1 Laissez les classes responsables de leur propre cohérence.
__3.1.2 Encapsuler la tâche entière et les contrôles de cohérence complexes.
__3.1.3 Exemple : Entité Employé
3.2 Concevoir un mécanisme de validation des données efficace.
3.2.1 Définir explicitement les préconditions
3.2.2 Créer un composant de validation
__3.2.3 Utilisez les valeurs nulles avec précaution et évitez-les si possible.
3.2.4 Exemple : Ajouter du personnel à un cours
3.3 Encapsuler la vérification d'état
3.3.1 Ordre, pas de questions
3.3.2 Exemple : Vérification des postes vacants dans une offre
3.4 Ne fournissez que les accesseurs et les mutateurs nécessaires.
3.4.1 Accesseurs qui ne modifient pas l'état et n'exposent pas trop d'informations aux clients
__3.4.2 Les setters ne sont utilisés que pour les propriétés qui décrivent un objet.
3.4.3 Exemple : Getters et Setters de la classe Offering
3.5 Modéliser l'agrégat pour garantir les invariants de l'ensemble d'objets.
3.5.1 Ne violez pas les règles des itinéraires agrégés
3.5.2 Exemple : Agrégat d'offres
3.6 Exercices pratiques
3.7 Résumé

Chapitre 4 : Gérer les dépendances

4.1 Séparer le code de haut niveau et le code de bas niveau
4.1.1 Concevoir un code stable
__4.1.2 Découverte de l'interface 098
4.1.3 Lorsqu'il n'est pas nécessaire de séparer le code de haut niveau et le code de bas niveau
__4.1.4 Exemple : Tâches de traitement des messages
4.2 Évitez de vous fier à des détails ou des éléments inutiles.
4.2.1 Ne demandez ou ne renvoyez que les classes dont vous êtes propriétaire.
4.2.2 Exemple : Remplacement d’un bot HTTP par le SDK de chat
4.2.3 Ne donnez pas à vos clients plus que ce dont ils ont besoin.
4.2.4 Exemple : Liste des offres
4.3 Classes distinctes qui dépendent de trop d'autres classes
4.3.1 Exemple : Séparation du service MessageSender
4.4 Injecter les dépendances (utiliser l'injection de dépendances)
__4.4.1 N’utilisez pas de méthodes statiques pour les opérations qui modifient l’état.
__4.4.2 Toujours injecter les collaborateurs : sinon, faites comme vous le souhaitez
4.4.3 Stratégies pour la création conjointe de classes et de dépendances
__4.4.4 Exemple : Injection de dépendances de MessageSender et de ses collaborateurs
4.5 Exercices pratiques
4.6 Résumé

Chapitre 5 : Bien concevoir l’abstraction

5.1 Abstractions de conception et points d'extension
5.1.1 Identifier le besoin d'abstraction
5.1.2 Conception des points d'extension
__5.1.3 Propriétés d'une bonne abstraction
5.1.4 Apprendre de l'abstraction
5.1.5 Découvrir l'abstraction
5.1.6 Abstraction et combinaison
__5.1.7 Exemple : Attribution de badges aux employés
5.2 Généraliser les règles métier importantes
__5.2.1 Séparer les règles commerciales générales des données spécifiques.
5.2.2 Exemple : Généralisation des règles des badges
5.3 Privilégier les abstractions simples
5.3.1 Règles empiriques
5.3.2 La simplicité est toujours préférable
__5.3.3 À ce stade, nous devons considérer l’abstraction.
5.3.4 N’ayez pas peur de modéliser des abstractions dès le début
__5.3.5 Exemple : Retour sur l’exemple du badge
5.4 Exercices pratiques
5.5 Résumé

Chapitre 6 : Gestion des dépendances externes et de l'infrastructure

6.1 Code de domaine et infrastructure séparés
__6.1.1 Une interface est-elle nécessaire ?
__6.1.2 Masquez les détails dans votre code, mais ne les cachez pas aux développeurs.
__6.1.3 Évolution des infrastructures : est-ce inutile ou cela se produira-t-il réellement ?
6.1.4 Exemple : Accès à la base de données et bot de messagerie
6.2 Tirez le meilleur parti de votre infrastructure
__6.2.1 Faites de votre mieux pour ne pas casser le design.
6.2.2 Exemple : Annulation de l’inscription
6.3 Ne vous fiez qu'à ce qui vous appartient.
6.3.1 Ne luttez pas contre le cadre établi
6.3.2 Attention aux fuites indirectes
__6.3.3 Exemple : Bot de messagerie
6.4 Encapsuler les erreurs d'infrastructure de bas niveau dans des erreurs de domaine de haut niveau.
6.4.1 Exemple : Gestion des exceptions dans SDKBot
6.5 Exercices pratiques
6.6 Résumé

Chapitre 7 : Atteindre la modularité

7.1 Créer un module profond
7.1.1 Trouver des moyens de réduire l'impact des changements
7.1.2 Affiner continuellement les limites du domaine
7.1.3 Gardez les éléments connexes à proximité
__7.1.4 Évitez tout couplage accidentel, mais s'il est inévitable, documentez-le.
7.2 Concevoir une interface claire
7.2.1 Simplifier les interfaces des modules
7.2.2 Modules avec rétrocompatibilité
7.2.3 Fournir des points d'extension propres
7.2.4 Coder comme si des personnes ayant des besoins différents utilisaient le module
__7.2.5 Les modules doivent avoir des règles claires en matière de propriété et de participation.
7.3 Évitez toute proximité entre les modules
7.3.1 Rendre les modules et les clients responsables de la rupture de l'intimité
7.3.2 Ne dépendez pas des classes internes
7.3.3 Surveiller le réseau de dépendances
__7.3.4 Monolithe ou microservice ?
7.3.5 Considérer les événements comme un moyen de séparer les modules
7.3.6 Exemple : Système de notification
7.4 Exercices pratiques
7.5 Résumé

Chapitre 8 : Une approche pratique

8.1 Soyez pratique, mais seulement dans la mesure nécessaire.
8.2 Refactorisez avec audace, mais décomposez en unités plus petites.
8.3 Acceptez que votre code ne soit pas parfait.
8.4 Envisager une refonte
8.5 Vous êtes responsable de vos développeurs juniors.
8.6 Références
8.7 Exercices pratiques
8.8 Résumé

Recherche

Systèmes orientés objet, concevez-les correctement !
Apprenez les 6 principes et l'approche pratique !

Conception orientée objet, faites simple !

L'essentiel du travail d'un développeur consiste à maintenir et à faire évoluer les systèmes existants.
La construction de systèmes logiciels maintenables nécessite une bonne conception orientée objet, et un élément clé de cette bonne conception est la simplicité.
Même si un système est bien conçu initialement, sa complexité augmente à chaque modification.
À mesure que de nouvelles classes, méthodes et fonctionnalités sont ajoutées, la quantité d'état et d'abstraction à gérer augmente.
Maintenir des conceptions simples face à la croissance naturelle de la complexité est un défi, mais la gestion de la complexité est essentielle pour maintenir et faire évoluer efficacement les systèmes logiciels.
Découvrez six principes de conception qui vous aideront à maîtriser la complexité et à simplifier votre conception orientée objet.

Approfondissons six principes clairs et pratiques !

Un recueil de principes de conception pratiques qui vous aideront à maintenir la simplicité de votre code orienté objet à mesure qu'il évolue, ainsi que des techniques pratiques applicables à n'importe quel langage orienté objet.
Nous allons diviser ce principe en six aspects et les explorer en détail, un par un.
Pour vous aider à mieux comprendre chaque principe, nous avons préparé des illustrations faciles à comprendre, des exemples de systèmes concrets et des exercices pratiques qui suscitent la réflexion.

Comment garder son code concis
• Comment maintenir la cohérence des objets
Comment gérer correctement les dépendances
Comment bien comprendre l'abstraction et la conception
Comment gérer et manipuler correctement l'infrastructure
Comment parvenir à une conception bien modulaire

Prenons l'exemple d'un système backend d'un point de vue pratique !

Nous expliquons d'abord le concept de chaque principe, puis nous expliquons comment l'appliquer d'un point de vue pratique à travers des exemples de code.
Pour illustrer les modèles de conception, nous utiliserons tout au long de ce livre un exemple de système backend fictif appelé PeopleGrow!
L'équipe en charge du développement de PeopleGrow! rencontre actuellement des problèmes de maintenance.
Des bugs surviennent, de simples modifications affectent des zones inattendues du système et les changements prennent des jours à être effectués.
Nous allons analyser en détail les choix de conception de PeopleGrow! et les affiner, en explorant le contexte, les avantages et les inconvénients de chaque principe, et en déterminant quand les appliquer et quand ne pas les appliquer.

[Préface de l'auteur]

Ce livre s'adresse aux développeurs de logiciels qui souhaitent améliorer leurs compétences en conception orientée objet.
Nous explorons en profondeur la complexité du code, sa cohérence, son encapsulation, la gestion des dépendances, la conception de l'abstraction, la gestion de l'infrastructure et la modularisation.
Même les développeurs expérimentés déjà familiarisés avec des approches similaires, telles que l'architecture propre, tireront profit de la perspective unique offerte par ce livre.
Les lecteurs doivent posséder des connaissances de base des concepts orientés objet tels que les classes, le polymorphisme et les interfaces.
Bien que les exemples de code soient principalement écrits en pseudo-code Java, ils devraient être faciles à comprendre pour les développeurs familiers avec les langages de programmation orientés objet tels que C#, Python et Ruby.

[Avis du bêta-testeur]

Au lieu d'expliquer pourquoi la conception orientée objet est une bonne chose, ce livre traite de la manière d'écrire du code et de la manière d'implémenter des modules tout au long du développement logiciel.
Ce livre résume de manière concise les informations importantes.
- Yoon Byeong-jo, Développeur logiciel, Développeur serveur

À mesure que la structure des services se complexifie, nous aborderons les aspects sur lesquels il convient de se concentrer lors de leur modélisation.
De plus, vous pouvez facilement comprendre chaque théorie des principes abordés dans la programmation orientée objet grâce au développement de services expliqué par des exemples de code.

- Choi In-ju, SSG.com, Développeur backend

D'après l'expérience de l'auteur, le principal atout de cet ouvrage réside dans son approche orientée objet de la résolution de problèmes pour les cas courants du quotidien.
Le contenu du livre a été traduit très facilement et explique bien comment améliorer un code orienté objet de qualité.
Examinez attentivement si un code existant ou de bonne qualité nécessite une maintenance continue.
Ce livre explique la marche à suivre et établit des principes pour maintenir une bonne conception, tels que les critères de séparation du code et les raisons pour lesquelles la maintenance continue est difficile.
- Chan-Woong Park, équipe de développement locatif de Lotte

Ce livre explique l'essence de la conception orientée objet de manière simple et approfondie.
J'ai été impressionné par la façon dont cela a offert une perspective nouvelle à tous, des néophytes en matière de concepts orientés objet aux développeurs possédant une expérience pratique.
- Lee Ki-ha, ingénieur cloud chez OPDC (Open Platform Developer Community).

Il constitue une première étape pratique vers une gestion et une maîtrise efficaces de la complexité grâce aux principes de la conception orientée objet.
Une introduction claire et pertinente à la programmation orientée objet que tout développeur se doit de lire.
- Seo Young-won, ingénieur logiciel chez Curly

Ce livre vous amène à repenser l'essence même de la conception orientée objet.
J'ai été particulièrement impressionné par la partie qui allait au-delà de la simple énumération des principes, mais qui m'a plutôt amené à réfléchir aux relations entre ces principes et aux points d'équilibre dans les situations de compromis.
Ce livre est utile à tous, des débutants en conception orientée objet aux développeurs expérimentés et aux responsables qui réfléchissent à l'architecture système.
- Choi Seong-wook, ingénieur en sécurité cloud, laboratoire de sécurité de la division commerciale VD de Samsung Electronics

Si vous êtes un développeur possédant déjà une solide expérience des méthodologies de développement, ce livre sera un outil encore plus précieux.
Cet excellent guide fait le lien entre la théorie et la pratique et vous aidera à établir votre propre philosophie de développement.
- Park Myeong-cheol, Autoplus, développeur Java depuis 20 ans