Chapitre 1 : Comment écrire du code lisible
1.1 Amélioration de la productivité
1.1.1 Relation entre l'échelle de développement et la productivité
1.1.2 Environnement et système d'évaluation pour améliorer la lisibilité
1.2 Exigences pour écrire du code lisible
__1.2.1 Métriques liées à la lisibilité
1.2.2 Éléments à prendre en compte pour améliorer la lisibilité
1.3 Principes de programmation représentatifs
__1.3.1 Principes des scouts
__1.3.2 YAGNI
__1.3.3 KISS
1.3.4 Principe de responsabilité unique
1.3.5 L'optimisation prématurée est à l'origine de tous les maux
1.4 Résumé

Chapitre 2 La dénomination
2.1 Grammaire anglaise utilisée dans la dénomination
__2.1.1 Nom ou groupe nominal
__2.1.2 Commande
__2.1.3 Autres points de grammaire anglaise
__2.1.4 Pourquoi ignorons-nous la grammaire et nommons-nous les choses ?
2.2 Que signifie le nom ?
__2.2.1 Exemple : Noms des arguments
__2.2.2 Exemple : Nom de la fonction
__2.2.3 Exception : Méthodes abstraites
2.3 Sélection des mots
__2.3.1 Exemple : Choisir des mots non ambigus
__2.3.2 Éviter les abréviations sources de confusion
__2.3.3 Ajout de mots représentant des unités ou des entités
__2.3.4 Utiliser des mots positifs
2.4 Conventions relatives au langage, à la plateforme et au codage
2.5 Résumé

Notes du chapitre 3
3.1 Types et finalités des commentaires
3.2 Notes de documentation
__3.2.1 Anti-modèle
3.2.2 Structure des commentaires de documentation
3.2.3 Résumé des commentaires de documentation
3.2.4 Détails des commentaires de documentation
3.3 Annotations informelles
3.3.1 Division du code volumineux
3.3.2 Explication du code non intuitif
3.4 Résumé

Chapitre 4 Statut
4.1 Quand les valeurs variables sont plus appropriées
4.2 Relations entre les variables, orthogonales
4.2.1 Définition de l'orthogonalité
4.2.2 Méthode : Remplacement par une fonction
4.2.3 Méthode : Remplacer par un type somme
4.3 Conception des transitions d'état
4.3.1 Immuabilité
4.3.2 Idempotence
4.3.3 Acyclique
4.4 Résumé

Chapitre 5 Fonctions
5.1 Responsabilités liées à la fonction
5.1.1 Principes de base du partitionnement fonctionnel
5.1.2 Séparation des commandes et des requêtes
5.2 Flux fonctionnel
5.2.1 Programmation basée sur les définitions
5.2.2 Retour anticipé
5.2.3 Division par cible de manipulation
5.3 Résumé

Chapitre 6 Relations de dépendance
6.1 Exemples de relations de dépendance
6.2 Force de la dépendance : Couplage
__6.2.1 Combinaison des contenus
6.2.2 Jointures communes et jointures externes
6.2.3 Combinaison de commandes
6.2.4 Combinaison de timbres et combinaison de données
__6.2.5 Combinaison de messages
6.3 Direction de la dépendance
6.3.1 Appelant → Appelé
6.3.2 Concret → Abstrait
6.3.3 Complexe/Variable → Simple/Immuable
6.4 Duplication des dépendances
__6.4.1 Dépendances liées
6.4.2 Duplication de l'ensemble des objets dépendants
6.5 Explicitation des dépendances
6.5.1 Antimodèle 1 : Abstraction excessive
__6.5.2 Antimodèle 2 : Plages de valeurs implicites
6.6 Résumé

Révision du code du chapitre 7
7.1 Note du réviseur 1 : Créer des demandes de fusion faciles à examiner
7.1.1 Spécifier l'objectif de la demande de fusion
7.1.2 Division des demandes de fusion
__7.1.3 Structuration de l'engagement
7.2 Note du réviseur 2 : Application des commentaires de la révision
7.2.1 Déterminer la cause des opinions ou questions erronées
7.2.2 Comprendre l’intention de la proposition
7.2.3 Application à d'autres parties
7.3 Note du réviseur 1 : Principes du réviseur
__7.3.1 Ne négligez pas les avis demandés.
7.3.2 Rejet des demandes de fusion problématiques
7.3.3 Ne soyez pas trop soucieux des délais
7.3.4 Présenter des « opinions », et non des « suggestions »
7.4 Note du réviseur 2 : Contenu des commentaires
7.4.1 Analyse de cas
7.5 Résumé

Annexe : Grammaire Kotlin requise pour la lecture de ce livre

Vous allez créer du code spaghetti ?
Allez-vous créer un code facile à lire et à modifier ?
Du choix des noms de code aux revues de code, comment écrire du code qui améliore la lisibilité.

« Je n’ai aucune idée de ce que fait ce code », « Je dois modifier les spécifications, mais par où commencer ? » Si vous êtes développeur, vous avez probablement déjà vécu ces situations.
Parfois, on tombe sur du code difficile à comprendre, truffé de pièges, et qui peut facilement se rompre au moindre changement, même s'il n'implémente manifestement pas de fonctions complexes. Ou bien, on peut penser que son code est parfait et élégant au moment de sa rédaction, mais en le relisant quelques mois plus tard, on se surprend à se reprocher son erreur : « Pourquoi ai-je écrit ce code ? »
Nous ne devons donc pas perdre de vue l’importance de la « lisibilité du code ».

Ce livre explique la lisibilité du code et la revue de code en se basant sur l'expérience de l'auteur en matière de revue et de refactorisation de code sur des projets de développement à grande échelle chez LINE.
Nous parlerons d'abord de l'importance d'un code lisible et des principes de programmation, puis nous expliquerons comment nommer le code, comment écrire des commentaires, la structure interne des classes (état et fonctions) et les dépendances entre les classes.
Il fournit également des conseils et des méthodes pour mener des revues de code au sein d'une équipe.
Grâce aux nombreux exemples de code Kotlin concrets présentés tout au long du livre, vous comprendrez clairement ce que vous avez appris en théorie.