Idées & Perspectives · Page 5

Explorer le développement AI-first, les garde-fous de code et l'architecture de la jetabilité.

16 juil. 2026

Corriger le bug est la partie facile. Comprendre pourquoi il existe est ce qui compte.

La plupart des équipes corrigent les défauts et passent à autre chose. Les mêmes défauts reviennent. Voici comment exécuter une analyse causale dans une inspection Fagan pour arrêter d'écrire deux fois le même bug.

15 juil. 2026

Les Revues de Pull Request Détectent 15 à 30 % des Défauts. Les Données le Disent Depuis 50 Ans.

De multiples études menées chez IBM, AT&T, HP et Microsoft confirment que la revue de code informelle détecte environ un quart des défauts. Voici ce que les données disent réellement, pourquoi ce nombre est si bas et comment y remédier.

fagan-inspections code-review data pr-reviews

14 juil. 2026

Une checklist générique ne capture rien. Une checklist structurée capture 60 % des défauts.

La plupart des checklists de revue sont des listes copiées-collées de bonnes intentions. Une checklist structurée de type Fagan inspection est construite à partir de données réelles de défauts, ciblée sur des types d'artefacts spécifiques et utilisée pendant la préparation individuelle. Voici comment en construire une qui fonctionne.

fagan-inspections code-review checklists structured-review

13 juil. 2026

Un LLM peut pré-inspecter votre code. Il ne peut pas animer la réunion.

Les inspections Fagan nécessitent quatre à six personnes et deux heures pour examiner 250 lignes. Un LLM peut réduire ce coût en gérant la préparation et le respect des checklists, mais il ne peut pas remplacer les rôles humains qui trouvent les défauts les plus coûteux.

fagan-inspections llm code-review ai-engineering

12 juil. 2026

Les Fagan Inspections détectaient 90 % des défauts avant les tests. Puis nous avons cessé de les pratiquer.

Le processus de revue structuré de Michael Fagan chez IBM capturait presque tous les défauts avant qu'ils n'atteignent le compilateur. Il consommait aussi 15 à 20 % de l'effort total du projet. Voici pourquoi la méthode de revue la plus efficace de l'histoire du logiciel a disparu, et ce que les équipes manquent réellement.

fagan-inspections code-review software-history process

11 juil. 2026

Votre meilleur relecteur manque la plupart des défauts. Fagan l'a mesuré chez IBM en 1976.

Même les ingénieurs seniors ne détectent qu'une fraction des défauts dans une relecture non structurée. Les recherches de Michael Fagan chez IBM ont montré pourquoi, et ont construit un processus d'inspection structuré pour y remédier.

fagan-inspections code-review human-factors defect-detection

10 juil. 2026

La plupart des code reviews détectent 20 % des défauts. Les Fagan inspections en détectent 90 %.

La revue de code informelle détecte 15 à 30 % des défauts. Les Fagan inspections, un processus structuré vieux de 50 ans, rapportent constamment des taux d'élimination de 60 à 90 %. Voici comment elles fonctionnent, pourquoi les équipes les évitent, et comment en exécuter une version allégée.

fagan-inspections code-review defect-prevention software-quality

9 juil. 2026

AutoVerus transforme 40 heures d'écriture de proof en 3 appels LLM. L'astuce consiste à savoir quand abandonner.

AutoVerus utilise un réseau d'agents LLM pour générer des proofs de correction Verus pour du code Rust, automatisant plus de 90% des proof obligations via une boucle générer-réparer-discharger pilotée par le feedback du solveur SMT.

model-checking autoverus rust verification

8 juil. 2026

Les LLMs peuvent générer du code Rust. Les preuves formelles sont un problème entièrement différent.

Les grands modèles de langage écrivent du Rust étonnamment bon, mais quand vous leur demandez une preuve formelle, ils hallucinent des invariants et inventent une syntaxe qu'aucun vérificateur n'accepte. Voici ce qu'ils font réellement bien, où ils échouent et comment les utiliser malgré tout.

model-checking llm rust formal-proofs

7 juil. 2026

Attendre les race conditions est une stratégie de test épouvantable

Pourquoi le model checking bat des jours d'exécution en production pour trouver les bugs de concurrence, et comment l'appliquer à votre propre code.

model-checking race-conditions concurrency testing