Chapitre 1 : Reconnaître le problème d'une structure défectueuse

1.1 Noms de signification inconnue
1.2 Des branches conditionnelles imbriquées qui rendent la compréhension difficile
1.3 Une classe de données qui crée d'innombrables démons
1.4 Les bases de la chasse aux démons

Chapitre 2 : Premiers pas dans la conception

2.1 Concevoir un nom qui exprime clairement l'intention
2.2 Créer et utiliser des variables séparément pour chaque objectif
2.3 Au lieu de simplement les énumérer, rassemblez des informations significatives et créez une méthode.
2.4 Regroupement des données et de la logique associées dans des classes

Chapitre 3 : Conception de classe : une base de conception qui relie tout

3.1 Concevoir pour bien fonctionner en tant qu'unité de classe
3.2 Techniques de conception pour la transition vers des classes matures
3.3 Analyse de l'effet d'exorcisme démoniaque
3.4 Modèles de conception permettant de résoudre les problèmes de structure des programmes

Chapitre 4 : Exploiter les invariants : assurer la stabilité des systèmes

4.1 Réaffectation
4.2 Effets indésirables causés par les variables
4.3 Comment gérer l'immuabilité et la mutabilité

Chapitre 5 Cohésion : Éléments dispersés

5.1 Mauvaise utilisation des méthodes statiques
5.2 Logique d'initialisation distribuée
5.3 Classes de traitement à usage général (Communes/Utilitaires)
5.4 N’utilisez pas de paramètres pour renvoyer des résultats
5.5 S'il y a trop de paramètres
5.6 Chaînage de méthodes

Chapitre 6 Branchement conditionnel : Comment démêler le labyrinthe des embranchements

6.1 Lisibilité réduite par les branches conditionnelles imbriquées
6.2 Instructions conditionnelles switch dupliquées
6.3 Chevauchement et imbrication conditionnels des branches
6.4 Évitez d'utiliser des branchements conditionnels pour la vérification des types de données
6.5 La première étape vers une maîtrise intermédiaire de l'interface
6.6 Paramètres du drapeau

Chapitre 7 Collections : Techniques de structuration pour éliminer l’imbrication

7.1 Ne pas réimplémenter les fonctionnalités existantes.
7.2 Imbrication de branches conditionnelles dans les itérations
7.3 Gestion des collections à faible cohésion

Chapitre 8 : Liens forts : Des structures si intimement liées qu'elles ne peuvent être démêlées

8.1 Couplage et responsabilités
8.2 Différents cas de couplage fort et méthodes de gestion

Chapitre 9 : Les divers démons qui sapent la solidité de la conception

9.1 Code mort
9.2 Principe YAGNI
9.3 Nombre magique
9.4 Obsession pour les types de données de type chaîne
9.5 Variables globales
9.6 Problème nul
9.7 Code qui intercepte et ignore les exceptions
9.8 Métaprogrammation qui détruit l'ordre de conception
9.9 Emballage axé sur la technologie
9.10 Copier et coller un exemple de code
Le 11 septembre est une balle

Chapitre 10 : Conception des noms : des noms qui représentent la structure

10.1 Noms qui invoquent des démons
10.2 Conception de noms - Conception de noms axée sur un objectif
10.3 Éléments à prendre en compte lors de la conception d'un nom
10.4 Noms de signification inconnue
10.5 Noms qui nuisent à la structure
10.6 Classes dont l'emplacement est incohérent lorsqu'on les consulte par leur nom
10.7 Abréviation du nom

Chapitre 11 : Annotations : Comment rédiger des commentaires pour améliorer la précision de la maintenance et des modifications

11.1 Commentaires obsolètes
11.2 Un exemple de dénomination approximative des choses en raison des commentaires
11.3 Informer le lecteur de toute modification apportée à l’intention et aux spécifications.
11.4 Résumé des règles d'annotation
11.5 Annotations de documentation

Chapitre 12 : Méthodes (Fonctions) : Les bonnes classes ont de bonnes méthodes.

12.1 Utilisez toujours les variables d'instance de la classe actuelle.
12.2 Création de méthodes prévisibles à l'aide d'invariants
12.3 Ne demandez pas, ordonnez.
12.4 Séparation des commandes et des requêtes
12.5 Paramètres
12.6 Valeurs de retour

Chapitre 13 : Modélisation : Fondements de la conception de classes

13.1 Classe d'utilisateur qui invoque facilement des démons
13.2 Structures à aborder par la modélisation
13.3 Problèmes liés aux mauvais modèles et solutions
13.4 Modélisation ayant une incidence sur la fonctionnalité

Chapitre 14 : Refactorisation : Techniques pour faire évoluer le code existant

14.1 Flux de refactorisation
14.2 Éviter les erreurs lors de la refactorisation grâce aux tests unitaires
14.3 Méthodes d'analyse pour la compréhension des spécifications incertaines
14.4 Fonctionnalités de refactorisation de l'IDE
14.5 Éléments à prendre en compte lors de la refactorisation

Chapitre 15 : La signification du design et comment aborder le design

15.1 De quel sujet de design ce livre parle-t-il ?
15.2 Si vous ne concevez pas, votre productivité en matière de développement diminuera.
15.3 Potentiel de croissance pour les logiciels et les ingénieurs
15.4 Dépannage
15.5 Indicateurs permettant d'évaluer la qualité d'un code
15.6 Divers outils d'aide à l'analyse du code
15.7 Objectif de conception et rapport coût-efficacité
15.8 Devenir un maître du temps

Chapitre 16 : Combattre les processus de développement qui entravent la conception

16.1 Communication
16.2 Conception
16.3 Mise en œuvre
16,4 avis
16.5 Amélioration des capacités de conception de l'équipe

Pour poursuivre l'étude des techniques de conception, voir le chapitre 17.

17.1 Livres recommandés
17.2 Méthodes d'apprentissage pour améliorer les compétences en conception

« C'était le cas à l'époque, mais plus maintenant. »
Êtes-vous submergé par la dette technique croissante à laquelle vous êtes confronté ?
Plongeons dans le monde du design à travers des exemples de mauvais code !

« Existe-t-il du bon ou du mauvais code ? », « Ça ne devrait pas simplement fonctionner ? », c'est ce que pourraient penser les programmeurs d'aujourd'hui.
Mais même si le code fonctionne correctement actuellement, si les exigences ou les fonctionnalités changent, des problèmes surgiront bientôt ici et là.

Un code mal conçu laissé de cette manière est non seulement long à lire et à comprendre, mais il continue également à créer des bugs qui nuisent à votre entreprise.
De plus, cela reproduit des expériences de développement de faible qualité, ce qui affecte les projets futurs.
Pour écrire un code hautement productif sur le long terme, il faut le « concevoir ».
Un thème commun se dégage de nombreux ouvrages techniques : « la bonne conception ».
En découvrant le design idéal grâce à ce livre et en le comparant à votre design actuel, vous pourrez progressivement réduire l'écart.

Code propre, conception pilotée par le domaine, refactoring… Vous voulez en savoir plus mais vous trouvez ça trop difficile ?
Premier pas pour les débutants en design ! Posons les bases de la conception orientée objet !

Les personnes qui n'ont pas étudié le design peuvent penser que le « design » est un domaine de niveau intermédiaire ou supérieur.
Ou peut-être souhaitez-vous améliorer le code source que vous développez en appliquant des techniques de conception sans simplement coder, mais vous ne savez pas par où commencer.
Il existe de nombreux bons livres sur le marché qui peuvent vous aider à améliorer vos compétences en design.
Ces livres sont considérés comme des lectures incontournables chez les programmeurs et sont souvent recommandés par les programmeurs expérimentés aux plus jeunes.
Cependant, même si vous achetez un livre comme celui-ci et essayez d'apprendre grâce à lui, il serait difficile pour les débutants de l'aborder en raison de son niveau élevé.

Ce livre aide même les débutants en design à surmonter les obstacles à l'entrée, à acquérir des bases solides et à progresser vers des études de design de niveau supérieur.
Transmet les concepts et les directives importants en matière de conception logicielle dans un format facile à comprendre.
De la manière de repérer le code de mauvaise qualité qui diminue la productivité du développement, à la manière d'aborder le code de manière structurelle, en passant par la résolution des problèmes pouvant survenir au cours du processus de développement, nous abordons des techniques qui peuvent aider même les débutants en conception à se familiariser avec le design et à améliorer la qualité du code.