▣ Chapitre 1 : Introduction

1.1 Les conséquences de toutes les décisions et de tous les modèles
__1.1.1 Décisions relatives aux tests unitaires
1.1.2 Ratio des tests unitaires et des tests d'intégration
1.2 Modèles de conception de code et pourquoi ils ne fonctionnent pas toujours
1.2.1 Mesure du code
1.3 Pourquoi les modèles de conception architecturale ne fonctionnent pas toujours
__1.3.1 Évolutivité et résilience
1.3.2 Vitesse de développement
1.3.3 Complexité des microservices
addition

▣ Chapitre 2 : Duplication de code vs. Flexibilité – La duplication de code n’est pas toujours mauvaise

2.1 Code commun et duplication entre les bases de code
__2.1.1 Ajout d'une nouvelle exigence métier nécessitant une duplication de code
2.1.2 Mise en œuvre des nouvelles exigences commerciales
2.1.3 Évaluation des résultats
2.2 Partage de code entre bibliothèques et bases de code
__2.2.1 Évaluation des avantages et des inconvénients des bibliothèques partagées
__2.2.2 Création d'une bibliothèque partagée
2.3 Extraction du code en microservices indépendants
2.3.1 Examen des avantages et des inconvénients des services indépendants
2.3.2 Conclusions sur les services indépendants
2.4 Amélioration du couplage faible par duplication de code
2.5 Conception d'API utilisant l'héritage pour réduire la duplication
__2.5.1 Extraction du gestionnaire de requêtes de base
2.5.2 Examen de l'héritage et du couplage fort
2.5.3 Analyse des compromis entre héritage et composition
__2.5.4 Examen des duplications inhérentes et accidentelles
addition

▣ Chapitre 3 : Gestion des exceptions et des erreurs : modèles à prendre en compte dans votre code

3.1 Hiérarchie des exceptions
3.1.1 Gestion de toutes les exceptions vs. gestion des erreurs plus granulaire
3.2 Bonnes pratiques pour la gestion des exceptions dans votre propre code
3.2.1 Gestion des exceptions vérifiées dans les API publiques
3.2.2 Gestion des exceptions non vérifiées dans les API publiques
3.3 Modèles à éviter dans la gestion des exceptions
3.3.1 Fermeture des ressources en cas d'erreur
3.3.2 Anti-modèles d'utilisation des exceptions pour contrôler le flux d'exécution d'une application
3.4 Exceptions provenant de bibliothèques tierces
3.5 Exceptions à surveiller dans les environnements multithread
3.5.1 Gestion des exceptions dans les flux de travail asynchrones à l'aide de l'API Promise
3.6 Une approche fonctionnelle de la gestion des erreurs avec Try
3.6.1 Utilisation de Try dans le code de service de production réel
3.6.2 Utilisation conjointe de try et de code générant des exceptions
3.7 Comparaison des performances du code de gestion des exceptions
addition

▣ Chapitre 4 : Concilier flexibilité et complexité

4.1 API robuste mais non évolutive
4.1.1 Conception de nouveaux composants
4.1.2 Commencer par le code le plus intuitif
4.2 Permettre aux clients de fournir leurs propres cadres de mesure
4.3 Fournir une extensibilité de l'API via des hooks
4.3.1 Prévention de l'utilisation inattendue de l'API Hook
4.3.2 Impact de l'API Hook sur les performances
4.4 Fournir une extensibilité de l'API via des écouteurs
4.4.1 Utilisation des écouteurs vs. des hooks
__4.4.2 Invariance du plan d'expérience
4.5 Analyse flexible vs. coûts de maintenance des API
addition

▣ Chapitre 5 : Optimisation prématurée vs. Optimisation des chemins de code critiques – Décisions ayant un impact sur les performances du code

5.1 Quand l'optimisation prématurée est mauvaise
5.1.1 Création d'un pipeline de traitement des comptes
5.1.2 Optimisation du traitement basée sur des hypothèses incorrectes
__5.1.3 Benchmarks d'optimisation des performances
5.2 Chemins de code critiques
5.2.1 Comprendre le principe de Pareto dans le contexte des systèmes logiciels
5.2.2 Configuration du nombre d'utilisateurs simultanés (threads) pour un SLA donné
5.3 Services Word présentant des chemins d'exécution potentiellement critiques
5.3.1 Découvrez le mot du jour
5.3.2 Vérifier si un mot existe
5.3.3 Exposition de WordsService au public via un service HTTP
5.4 Détection des chemins de code critiques
5.4.1 Création de tests de performance d'API à l'aide de Gatling
__5.4.2 Mesure des chemins de code à l'aide de MetricRegistry
5.5 Améliorations des performances pour les chemins de code fréquemment utilisés
5.5.1 Génération de microbenchmarks JMH pour les solutions existantes
__5.5.2 Optimisation de word-exists à l'aide d'un cache
__5.5.3 Le test de performance a été modifié pour accepter davantage de mots en entrée.
addition

▣ Chapitre 6 : Coût et simplicité de la maintenance des API

6.1 Bibliothèques de base utilisées par d'autres outils
6.1.1 Création d'un client de service cloud
6.1.2 Exploration des stratégies d'authentification
6.1.3 Comprendre le mécanisme de configuration
6.2 Exposition directe des paramètres des bibliothèques dépendantes au monde extérieur
6.2.1 Configuration de l'outil de déploiement
6.3 Outils pour abstraire la configuration des bibliothèques de dépendances
6.3.1 Configuration des outils de streaming
6.4 Ajout de nouveaux paramètres pour la bibliothèque cliente cloud
6.4.1 Ajout d'un nouveau paramètre à l'outil de déploiement
6.4.2 Ajout de nouveaux paramètres à l'outil de streaming
6.4.3 Comparaison des deux solutions en termes d'ergonomie utilisateur et de facilité de maintenance
6.5 Décider de déprécier ou de supprimer un paramètre de la bibliothèque cliente Cloud
6.5.1 Suppression des paramètres de l'outil de déploiement
6.5.2 Suppression des paramètres des outils de streaming
6.5.3 Comparaison des deux solutions en termes d'ergonomie utilisateur et de facilité de maintenance
addition

▣ Chapitre 7 : Travailler efficacement avec les données de date et d’heure

7.1 Concepts d'information de date et d'heure
__7.1.1 Temps informatique : instants, époques et intervalles de temps
7.1.2 Heure commerciale : Système calendaire, Date, Heure, Intervalle de dates
7.1.3 Fuseaux horaires, UTC et décalage UTC
7.1.4 Concepts de date et d'heure déroutants
7.2 Préparation au traitement des informations de date et d'heure
7.2.1 Limitation du champ d'application
7.2.2 Clarifier les exigences relatives à la date et à l'heure
7.2.3 Utilisation de la bibliothèque ou du package approprié
7.3 Mise en œuvre des codes de date et d'heure
7.3.1 Appliquer le concept de manière cohérente
7.3.2 Améliorer la testabilité en évitant les valeurs par défaut
7.3.3 Représentation des valeurs de date et d'heure sous forme de texte
7.3.4 Explication du code par des commentaires
7.4 Cas particuliers qui doivent être spécifiés et testés
7.4.1 Opérations arithmétiques calendaires
7.4.2 Conversion de fuseau horaire à minuit
7.4.3 Gestion des heures ambiguës ou manquantes
7.4.4 Utilisation des données de chronologie évolutives
addition

▣ Chapitre 8 : Exploiter la localité des données et la mémoire sur les ordinateurs

8.1 Qu'est-ce que la localité des données ?
8.1.1 Transfert des calculs vers les données
8.1.2 Mise à l'échelle du traitement en fonction de la localité des données
8.2 Partitionnement et division des données
8.2.1 Partitionnement hors ligne des données massives
8.2.2 Partitionnement vs. Sharding
8.2.3 Algorithme de partitionnement
8.3 Fusion de grands ensembles de données provenant de plusieurs partitions
8.3.1 Fusion de données au sein du même ordinateur physique
8.3.2 Opérations de jointure nécessitant un déplacement de données
8.3.3 Optimisation de la jonction par diffusion
8.4 Traitement des données : mémoire vs disque
8.4.1 Traitement sur disque
8.4.2 Pourquoi MapReduce est nécessaire
8.4.3 Calcul du temps d'accès
8.4.4 Traitement basé sur la RAM
8.5 Implémentation des jointures avec Apache Spark
8.5.1 Implémentation des jointures sans diffusion
8.5.2 Implémentation des jointures avec diffusion
addition

▣ Chapitre 9 : Bibliothèques externes – Les bibliothèques que vous utilisez deviendront bientôt votre code.

9.1 Importation des bibliothèques et prise en charge complète de la configuration : attention aux valeurs par défaut
9.2 Modèle de concurrence et évolutivité
__9.2.1 Utilisation des API asynchrones et synchrones
__9.2.2 Évolutivité distribuée
9.3 Testabilité
__9.3.1 Bibliothèque de tests
9.3.2 Tests avec des objets factices (doubles de test) et des objets simulés
__9.3.3 Intégration de la boîte à outils de test
9.4 Dépendances vis-à-vis des bibliothèques tierces
Éviter les conflits de versions avec __9.4.1
__9.4.2 Trop de dépendances
9.5 Sélection et maintien des dépendances externes
__9.5.1 Première impression
9.5.2 Différentes approches de la réutilisation du code
__9.5.3 Dépendance vis-à-vis du fournisseur
Licence __9.5.4
__9.5.5 Bibliothèques vs. Frameworks
__9.5.6 Sécurité et mises à jour
__9.5.7 Liste de contrôle pour la prise de décision
addition

▣ Chapitre 10 : Cohérence et atomicité dans les systèmes distribués

10.1 Envoyer la source de données au moins une fois
__10.1.1 Trafic entre services à nœud unique
__10.1.2 Nouvelle tentative d'appel d'application
10.1.3 Création de données et idempotence
__10.1.4 Comprendre le CQRS (Ségrégation des responsabilités des commandes et des requêtes)
10.2 Implémentation simple de la bibliothèque de déduplication
10.3 Erreurs courantes lors de la mise en œuvre de la déduplication dans les systèmes distribués
__10.3.1 Contexte avec un seul nœud
__10.3.2 Contexte multi-nœuds
10.4 Rendre la logique atomique pour éviter les conditions de concurrence
addition

▣ Chapitre 11 : Sémantique de la livraison dans les systèmes distribués

11.1 Architecture des applications événementielles
11.2 Applications de production et de consommation basées sur Apache Kafka
11.2.1 Un regard sur le côté consommateur de Kafka
11.2.2 Comprendre les paramètres du broker Kafka
11.3 Logique du producteur
11.3.1 Choisir entre la cohérence et la disponibilité pour les producteurs
11.4 Codes consommateurs et sémantiques de livraison diverses
11.4.1 Consommateurs effectuant un engagement manuel
__11.4.2 Redémarrer à partir du décalage le plus ancien ou le plus récent
__11.4.3 (virtuellement) exactement une fois sémantique
11.5 Exploiter la sémantique d'expédition pour assurer la tolérance aux pannes
addition

▣ Chapitre 12 : Gestion des versions et de la compatibilité

12.1 Contrôle de version dans le résumé
__Propriétés de la version 12.1.1
__12.1.2 Compatibilité ascendante et descendante
__12.1.3 Versionnage sémantique
__12.1.4 Version marketing
12.2 Gestion des versions pour les bibliothèques
12.2.1 Code source, binaires et compatibilité sémantique
__12.2.2 Graphe de dépendance et dépendance en diamant
__12.2.3 Techniques de gestion des modifications incompatibles
__12.2.4 Gestion des bibliothèques internes
12.3 Gestion des versions des API réseau
__12.3.1 Contexte d'un appel d'API réseau
__12.3.2 Clarté conviviale pour le client
__12.3.3 Stratégie générale de versionnage
__12.3.4 Considérations supplémentaires relatives au versionnage
12.4 Gestion des versions pour les référentiels de données
__12.4.1 Brève introduction aux tampons de protocole
__12.4.2 Quels changements rompent la compatibilité ?
12.4.3 Migration de données au sein d'un dépôt
__12.4.4 Anticiper l'inattendu
__12.4.5 Séparation de la représentation de l'API et du référentiel
__12.4.6 Évaluation du format du dépôt
addition

▣ Chapitre 13 : Suivre les dernières tendances ou réduire les coûts de maintenance du code

13.1 Quand utiliser un framework d'injection de dépendances ?
13.1.1 Injection de dépendances DIY (à faire soi-même)
13.1.2 Utilisation d'un framework d'injection de dépendances
13.2 Lors de l'utilisation de la programmation réactive
__13.2.1 Création d'un processus bloquant à thread unique
__13.2.2 Utilisation de CompletableFuture
__13.2.3 Mise en œuvre d'une solution réactive
13.3 Lors de l'utilisation de la programmation fonctionnelle
__13.3.1 Génération de code fonctionnel à partir de langages non fonctionnels
__13.3.2 Optimisation par récursion terminale
__13.3.3 Exploiter l'immuabilité
13.4 Évaluation paresseuse vs. enthousiaste
addition

★ Ce que ce livre aborde ★

◎ Comprendre le système pour prendre des décisions de conception plus intuitives et plus efficaces
◎ Comprendre comment équilibrer les compromis et les tendances de ces compromis
◎ Choisir la bibliothèque adaptée au problème
◎ Analyser en détail l'ensemble des dépendances du service
◎ Comprendre la sémantique de transmission et son impact sur les architectures distribuées.
◎ Concevoir et réaliser des tests de performance pour détecter les chemins de code critiques et vérifier les SLA du système.
◎ Détecter et optimiser les chemins de code critiques afin de concentrer l'optimisation sur la cause première.
◎ Déterminer le modèle de données approprié pour le traitement des dates et heures afin d'éviter les erreurs courantes (mais subtiles).
◎ Déduire la compatibilité et le contrôle de version pour éviter les problèmes inattendus avec les clients API.
◎ Comprendre les concepts de couplage fort et de couplage faible et comment ces concepts affectent la coordination du travail entre les équipes.
◎ Établissez des exigences claires jusqu'à ce qu'elles soient précises, faciles à mettre en œuvre et faciles à tester.
◎ Optimisation des API pour une expérience utilisateur conviviale