deep-dives

23 articles

9 juin 2026

La moitié de vos scénarios Cucumber sont skipped. Voici pourquoi ce statut vous ment.

Le statut « skipped » de Cucumber cache trois problèmes complètement différents. Voici comment diagnostiquer lequel dévore votre suite de tests, et comment l'arrêter.

8 juin 2026

Vos specs Gherkin vous mentent

Les specs Gherkin dérivent dès que vous confiez leur mise à jour à des humains. Voici comment automatiser les vérifications qui maintiennent vos feature files honnêtes.

deep-dives gherkin bdd living-documentation

7 juin 2026

Votre compilateur vérifie la syntaxe. Vos tests devraient vérifier l'architecture.

La plupart des équipes documentent les règles d'architecture dans des wikis. Voici comment les écrire comme des tests exécutables qui font échouer la CI quand votre graphe de dépendances dérive.

deep-dives architecture-testing clean-architecture ci-cd

6 juin 2026

Votre couche domaine importe Postgres. Votre CI s'en fiche.

Les diagrammes de clean architecture sont très beaux sur un tableau blanc. Voici comment faire en sorte que votre pipeline de build applique la direction des dépendances, pour que le code domaine ne puisse pas atteindre l'infrastructure.

deep-dives clean-architecture ci-cd dependency-rules

5 juin 2026

Votre diagramme d'architecture est déjà un mensonge

La documentation d'architecture pourrit dès que vous la sauvegardez. Voici comment garder une documentation honnête en utilisant des diagrammes générés depuis le code, des ADR et des tests d'architecture automatisés.

deep-dives architecture documentation living-docs

4 juin 2026

Votre boucle de retry part du principe que la première requête a échoué. Ce n'est probablement pas le cas.

Un timeout ou un crash ne signifie pas que votre requête API a été perdue. Voici comment les clés d'idempotence rendent les retries sûrs, et le pattern de stockage qui empêche réellement les doublons.

deep-dives idempotency api-design resilience

3 juin 2026

Un verrou qui survit à votre processus : comment fonctionnent réellement les leases distribués

Les mutex en mémoire disparaissent lors du redémarrage de votre serveur. Voici comment les leases distribués avec des jetons de clôture (fencing tokens) et des TTLs empêchent le travail en double lors des crashs, et où ils échouent encore.

deep-dives distributed-locks leasing resilience

2 juin 2026

Un circuit breaker sans goroutines, sans timers et sans overhead d'arrière-plan

La plupart des bibliothèques de circuit breaker lancent des threads d'arrière-plan pour tester la récupération. Vous n'en avez pas besoin. Voici une conception pilotée par les requêtes qui élimine tout l'overhead d'arrière-plan sans sacrifier la correction.

deep-dives circuit-breaker performance resilience

1 juin 2026

Votre service web a un chemin d'arrêt gracieux. C'est le bug.

Les logiciels crash-only traitent chaque échec comme un crash et chaque démarrage comme une récupération. Pour les services web, cela signifie supprimer votre logique d'arrêt et concevoir un état qui survit à un kill -9.

deep-dives crash-only-software resilience distributed-systems

31 mai 2026

Comment tuer un mutant survivant quand vous ne comprenez pas ce qu'il a changé

Le mutation testing a trouvé un survivant et vous n'avez aucune idée de ce que fait la mutation. Voici une méthode pas à pas pour écrire le bon test sans comprendre le mutant au préalable.

deep-dives mutation-testing test-writing debugging

30 mai 2026

Le code d'authentification a besoin de 90% de couverture de mutation. Vos utilitaires de chaînes de caractères, non.

Pourquoi imposer un seul score de mutation à l'ensemble de votre codebase est une erreur, et comment définir des seuils par module qui correspondent au risque réel.

deep-dives mutation-testing auth test-quality

29 mai 2026

Vos tests passent. Votre mutation score est de 40 %. Voici ce que les mutants survivants vous disent vraiment.

La couverture de code dit que vous êtes en sécurité. Le mutation testing dit que vos tests sont surtout de la décoration. Voici comment les mutants survivants exposent le fossé, et comment le combler.

deep-dives mutation-testing surviving-mutants test-quality

28 mai 2026

Le mutation testing en Rust fonctionne, mais vos temps de compilation vont le détester

cargo-mutants trouve les tests qui font semblant de vérifier votre code. Voici comment fonctionne le mutation testing pour Rust, ce qu'il détecte, et si le coût en temps de compilation en vaut la peine.

deep-dives mutation-testing rust cargo-mutants test-quality

27 mai 2026

Le mutation testing prend 4 heures. Comment les équipes l'utilisent-elles vraiment en CI ?

La plupart des équipes n'exécutent pas de suites complètes de mutation testing à chaque commit. Voici comment les équipes d'ingénierie intègrent réellement le mutation testing en CI sans faire échouer le pipeline de build.

deep-dives mutation-testing ci-cd test-quality

26 mai 2026

Vos tests unitaires passent, mais vos données disparaissent quand même

Les tests de base de données simulés vérifient votre syntaxe SQL, pas si les lignes survivent aux crashes, aux écritures concurrentes ou aux incompatibilités de schéma. Voici comment tester la persistance pour de vrai.

deep-dives database testing persistence

25 mai 2026

Tester Redux sans se noyer dans les mock actions

Mocker chaque action Redux transforme vos tests en validateur de changelog. Voici comment tester votre store avec de vraies transitions d'état à la place.

deep-dives redux testing state-management

24 mai 2026

100 exécutions de tests, c'est un mensonge : comment dimensionner vos tests par propriétés

Les 100 exemples par défaut dans les tests par propriétés sont un compromis social, pas une stratégie statistique. Voici comment choisir un nombre d'exécutions qui correspond à vos besoins de confiance et à votre budget CI.

deep-dives property-based-testing test-coverage shrinking

23 mai 2026

Les tests basés sur les propriétés en Rust trouvent les bugs que vos tests unitaires ne détectent pas

Le test par exemple ne couvre que les entrées auxquelles vous avez pensé. Le test basé sur les propriétés génère des données aléatoires, vérifie les invariants et réduit les échecs à des contre-exemples minimaux.

deep-dives rust property-based-testing quickcheck proptest

22 mai 2026

Vos tests unitaires passent. Votre code en production est toujours cassé.

Les métriques de code coverage créent un faux sentiment de sécurité. Voici pourquoi les tests unitaires laissent passer les bugs qui vous coûtent du sommeil, et quoi tester à la place.

deep-dives unit-testing test-quality bug-prevention

21 mai 2026

Les Runtime Contracts en Rust peuvent être sans coût en release, mais le compilateur ne le fera pas à votre place

Rust élimine automatiquement les debug assertions, mais un vrai design-by-contract nécessite plus que debug_assert!. Voici comment construire des runtime contracts sans coût qui disparaissent de votre binaire release.

deep-dives rust runtime-contracts performance

20 mai 2026

Zéro, une ou douze : combien d'assertions une fonction de production réclame-t-elle vraiment

Les développeurs dispersent les assertions comme des confettis ou les évitent totalement. Voici le cadre de décision qui distingue les invariants utiles des déclencheurs de crash en production.

deep-dives assertions production-code defensive-programming

19 mai 2026

Votre couche de validation est plus volumineuse que votre logique métier

La validation manuelle alourdit votre codebase et laisse encore passer des cas limites. Voici comment appliquer des runtime contracts avec des schémas déclaratifs qui restent discrets.

deep-dives runtime-contracts validation design-by-contract

18 mai 2026

strictNullChecks dans TypeScript est un garde-fou à la compilation, pas un bouclier à l'exécution

Le mode strict attrape les null que vous écrivez, pas les null qui arrivent à l'exécution depuis les API, les requêtes DOM et JSON.parse. Voici où le système de types s'arrête et où vos défenses commencent.

deep-dives typescript null-safety strict-mode