Débogage

La question du débogage fait partie du quotidien des programmeuses et des programmeurs, et la pratique du débogage est un art qu'il faut maîtriser pour cheminer dans cet étrange métier qu'est celui d'informaticienne ou d'informaticien.

Personnellement, je débogue beaucoup les autres (cela fait partie de ma tâche d'enseignant, je suppose) mais très peu mon propre code. Je dois ceci à mes illustres enseignants (en particulier Maurice Joyal et Norman Brault), à l'époque où j'étais moi-même étudiant, qui m'ont permis de lire leur propre code, ce qui m'a donné un choc total : contrairement à mon propre code de l'époque, qui tendait à être long et « verbeux », le leur était court, concis, avec très, très peu de fonctions longues de plus d'une ou deux lignes. Leur code tendait à être réutilisable alors que le mien tendait à être fortement lié au domaine du problème que je tentais de résoudre.

Avec le temps, j'ai réussi à rapprocher mon code de cet idéal, et force est d'admettre que, quand les fonctions ont une vocation claire et sont rarement plus longues qu'une ou deux lignes, les bogues, s'il y en a, sautent souvent aux yeux. Sans compter que cette démarche, qui tend à mener à du code plus générique, résulte en de multiples petits composants logiciels faciles à tester et à assembler (et, pour un compilateur, faciles à optimiser!), ce qui accélère le développement et la qualité globale de notre production.

Généralités

Quelques liens généraux à ce sujet :

• Les six phases du débogage, une réflexion humoristique de Mike W. Cremer rapportée par Aristotle Pagaltzis en 2012 : http://plasmasturm.org/log/6debug/
• Qu'est-ce qu'un bogue? Réflexion de Michael Hicks en 2015 : http://www.pl-enthusiast.net/2015/09/08/what-is-a-bug/
• Une catégorisation des bogues étranges, par familles : http://en.wikipedia.org/wiki/Unusual_software_bug
• Plusieurs liens et articles sur le sujet du débogage : http://www.softpanorama.org/Lang/debug.shtml
• Quelques bogues célèbres : http://www5.in.tum.de/~huckle/bugse.html
• Quelques erreurs de programmation Web : http://coding.smashingmagazine.com/2011/07/07/my-favorite-programming-mistakes/
• À propos du débogage algorithmique et automatique : http://www2.cs.uidaho.edu/~jeffery/aadebug.html
• Le cycle de développement sécuritaire de Microsoft : http://blogs.msdn.com/b/shawnhernan/archive/2010/02/13/microsoft-s-many-eyeballs-and-the-security-development-lifecycle.aspx
• Est-ce un bogue de compilateur (car oui, ça existe)? http://blog.regehr.org/archives/26 (et si vous souhaitez trouver ces bogues, des pistes sont offertes par http://gcc.gnu.org/wiki/summit2010?action=AttachFile&do=get&target=regehr_gcc_summit_2010.pdf)
• Le débogueur de Charles Babbage (sans blagues!) : http://blog.jgc.org/2010/09/babbages-debugger.html
• Sur la complexité de régler un bogue, un texte d'Eric Lippert en 2003 : http://blogs.msdn.com/b/ericlippert/archive/2003/10/28/53298.aspx
• Comment Google prédit les bogues, par Chris Lewis et Rong Ou en 2011 : http://google-engtools.blogspot.com/2011/12/bug-prediction-at-google.html
• Un blogue intéressant sur le dépistage et la correction de bogues, principalement sous Microsoft Windows : http://bugslasher.net/
• Apprendre C à l'aide du débogueur gdb, texte d'Alan O'Donnell en 2012 : https://www.hackerschool.com/blog/5-learning-c-with-gdb
• Suggestion de Noah Lavine en 2012 pour chercher à dépister ce qui se produit dans ces moments où un logiciel « fige » sans que l'on ne sache pourquoi et réduise la qualité de notre expérience : http://noahlavine.wordpress.com/2012/09/16/what-just-happened/
• Réflexion intéressante sur la nuance entre « erreur » et « bogue », en 2012 : http://celandine13.livejournal.com/33599.html
• Le débogage avec Java, et comment les piles d'appels (Stack Traces) devraient être présentées pour faciliter le travail des programmeuses et des programmeurs. Texte de 2012 : http://www.redcode.nl/blog/2012/09/stacktraces-should-be-inverted/
• Les bogues auraient quelque chose à nous apprendre, selon Henrik Warne en 2012 : http://henrikwarne.com/2012/10/21/4-reasons-why-bugs-are-good-for-you/
• Selon Gilad Bracha, en 2012, le mode de débogage serait le seul véritable mode de développement : http://gbracha.blogspot.ca/2012/11/debug-mode-is-only-mode.html
• Le débogage est-il un art ou une science? L'opinion d'Andrew Koenig en 2012 :
  • http://www.drdobbs.com/cpp/debugging-art-or-science/240142870
  • http://www.drdobbs.com/cpp/debugging-as-science-a-concrete-example/240144054
• Déboguer pour gagner de l'expérience, texte de Linus Akesson en 2012 : http://www.linusakesson.net/programming/kernighans-lever/index.php
• Selon Henrik Warne en 2013, un bon programmeur est un programmeur qui prend soin de rédiger du code plus facile à déboguer : http://henrikwarne.com/2013/05/05/great-programmers-write-debuggable-code/
• À propos des liens à faire entre le débogage et la preuve mathématique, un texte de Stuart Wray en 2013 : http://onfoodandcoding.blogspot.co.uk/2013/04/completely-reliable-conclusions.html
• Comment les compilateurs JIT influencent nos pratiques de débogage, réflexion de Shu-yu Guo en 2014 : http://rfrn.org/~shu/2014/05/14/debugging-in-the-time-of-jits.html
• Le Lincoln Index, une mesure quantifiée des bogues restants dans un programme, expliqué par John D. Cook en 2010 : http://www.johndcook.com/blog/2010/07/13/lincoln-index/
• Dans ce texte de 2014, Stanislav Nedelchev prend position à l'effet que suivre des cours de débogage devrait être une obligation dans tout cursus de programmation : http://stannedelchev.net/debugging-courses-should-be-mandatory/
• Comment écrire un bon Bug Report, de l'avis de Justin Jackson en 2014 : https://sprint.ly/blog/bug-report/
• Le débogage est une tâche longue et lourde, même à plusieurs, comme le rappelle Daniel Stenberg dans ce texte de 2015 : http://daniel.haxx.se/blog/2015/02/23/bug-finding-is-slow-in-spite-of-many-eyeballs/
• Quelle est la probabilité qu'un programme soit correct? Texte d'Alex Beal en 2013 : http://www.usrsb.in/probability-of-a-correct-program.html
• Comme le rappelle à juste titre Yegor Bugayenko en 2015, il existe des raisons valides de refuser de procéder à un Bug Fix : http://www.yegor256.com/2015/06/22/valid-reasons-to-reject-bug-fix.html
• Déboguer implique comprendre, comme l'explique Andre Medeiros dans ce texte de 2015 : http://futurice.com/blog/why-debugging-is-all-about-understanding
• Déboguer une expression régulière, texte de 2016 par Ori Bernstein : https://eigenstate.org/notes/regex-debug
• Quand les programmes se comportent de manière un peu trop étrange, Andrey Karpov recommande, dans ce texte de 2015, de vérifier la mémoire : http://cpphints.com/hints/42
• Dans ce texte de 2009, Shawn Hargreaves relate l'histoire d'une intelligence artificielle dont un comportement jugé positif découlait d'une caractéristique à cheval entre le bogue et le feature : https://blogs.msdn.microsoft.com/shawnhar/2009/12/29/bug-or-feature/
• Apprendre de ses erreurs, texte de 2016 par l'équipe de Tor qui en profite pour soumettre plusieurs recommandations de saines pratiques de programmation : https://blog.torproject.org/blog/mid-2016-tor-bug-retrospective-lessons-future-coding
• En 2016, Henrik Warne propose une série de trucs appris suite à des années d'expérience et de correction de bogues divers : https://henrikwarne.com/2016/06/16/18-lessons-from-13-years-of-tricky-bugs/
• Estimer le nombre de bogues restant dans un programme, par Ben Deane en 2018 : http://www.elbeno.com/blog/?p=1051

L'outil qu'est le débogueur

Un débogueur (selon la documentation de Xcode)

Si vous souhaitez implémenter un débogueur ou mieux comprendre comment ces outils fonctionnent, quelques liens :

• Texte de 2011 qui explique comment insérer un point d'arrêt (Breakpoint) dans du code compilé pour Linux : http://mainisusuallyafunction.blogspot.ca/2011/01/implementing-breakpoints-on-x86-linux.html
• Série d'articles sur le fonctionnement des débogueurs, par Eli Bendersky en 2011 :
  • http://eli.thegreenplace.net/2011/01/23/how-debuggers-work-part-1/
  • http://eli.thegreenplace.net/2011/01/27/how-debuggers-work-part-2-breakpoints/
  • http://eli.thegreenplace.net/2011/02/07/how-debuggers-work-part-3-debugging-information/
• Écrire des extensions pour débogueurs pour Windows, par Andrew Richards en 2011 :
  • http://msdn.microsoft.com/en-us/magazine/gg650659.aspx
  • http://msdn.microsoft.com/en-us/magazine/hh148143.aspx
• Les symboles sous Linux, de la perspective de Bruce Dawson, programmeur très expérimenté du point de vue du débogage sous Windows. Une série d'articles fort intéressants en 2013 :
  • http://randomascii.wordpress.com/2013/01/08/symbols-on-linux-part-one-g-library-symbols/
  • http://randomascii.wordpress.com/2013/01/19/symbols-on-linux-part-two-symbols-for-other-versions/
  • http://randomascii.wordpress.com/2013/02/20/symbols-on-linux-part-three-linux-versus-windows/
• Comment fonctionne un débogueur, par Kevin Pouget en 2014 : http://blog.0x972.info/?d=2014/11/13/10/40/50-how-does-a-debugger-work
• Comment était-il possible d'offrir un débogueur pour la version 16 bits de Windows? Raymond Chen l'explique, dans ce texte de 2014 : http://blogs.msdn.com/b/oldnewthing/archive/2014/11/26/10576044.aspx
• Microsoft a livré les sources du moteur de son débogueur en format « code ouvert » en 2015 : http://blogs.msdn.com/b/vcblog/archive/2015/07/20/source-now-available-for-gdb-lldb-debug-engine.aspx
• Linus Torvalds n'aime pas les débogueurs, outre en tant que désassembleurs programmables : https://lwn.net/2000/0914/a/lt-debugger.php3
• En 2016, Daniel Lemire explique pourquoi il n'utilise pas (pourquoi il n'utilise plus, en fait) de débogueur, du moins pas pour faire le suivi à la trace des instructions d'un programme : http://lemire.me/blog/2016/06/21/i-do-not-use-a-debugger/

Outils

Outils de débogage à proprement dit :

• Le produit DTrace, par Adam Levent :
  • http://en.wikipedia.org/wiki/DTrace
  • http://dtrace.org/blogs/ahl/2005/12/13/dtrace-for-linux/
  • http://dtrace.org/blogs/ahl/2011/10/05/dtrace-for-linux-2/
• Divers outils pour déboguer du code .NET ou du code C++ : http://blogs.microsoft.co.il/blogs/sasha/archive/2010/08/10/net-debugging-and-c-debugging-resources.aspx
• Déboguer avec Visual Studio :
  • introduction à la pratique du débogage avec cet outil, par Andrew Hall en 2015 : http://blogs.msdn.com/b/visualstudio/archive/2015/08/11/introduction-to-debugging.aspx
  • trucs divers :
    • http://blogs.msdn.com/b/vcblog/archive/2014/01/07/code-debugging-topics-on-msdn.aspx
    • http://blogs.msdn.com/b/vcblog/archive/2014/01/09/code-debugging-content-in-community.aspx
    • thttp://www.codeproject.com/Articles/469416/More-Visual-Studio-Debugging-Tips-for-Native-De
  • truc pour vérifier la corruption de mémoire avec Visual Studio : http://thetweaker.wordpress.com/2010/11/16/checking-memory-corruption-with-_crtcheckmemory-from-the-debugger/
  • techniques avancées de débogage avec Visual Studio :
    • débogage de code optimisé : http://blogs.microsoft.co.il/blogs/sasha/archive/2011/10/12/debugging-optimized-code-in-visual-studio-11.aspx
    • débogage de jeux vidéos avec Visual Studio 2011 : http://blogs.msdn.com/b/vcblog/archive/2011/11/08/10235150.aspx
    • présentées par Julien Gilli : http://www.juliengilli.com/advanced-debugging-fr/#1
    • proposées par Damien Guard en 2014 : http://damieng.com/blog/2014/02/05/8-visual-studio-debugging-tips-debug-like-a-boss
  • profiter à fond de la fenêtre Sortie, un texte d'Angelos Petropoulos en 2015 : http://blogs.msdn.com/b/visualstudioalm/archive/2015/02/09/the-output-window-while-debugging-with-visual-studio.aspx
  • plusieurs manières de voir les valeurs des variables, un texte de 2016 par Kaycee Anderson : https://blogs.msdn.microsoft.com/visualstudioalm/2016/07/15/7-ways-to-look-at-the-values-of-variables-while-debugging-in-visual-studio/
• L'outil Expression Evaluator du débogueur de Visual Studio, texte d'Ofek Shilon en 2013 : http://blogs.msdn.com/b/vcblog/archive/2013/03/07/guest-post-the-expression-evaluator.aspx
• Les Tracepoints, semblables aux Breakpoints mais qui opèrent sans arrêter l'exécution du programme, par Brad Sullivan en 2013 : http://blogs.msdn.com/b/visualstudioalm/archive/2013/10/10/tracepoints.aspx
• Déboguer un programme .NET avec le .NET Reference Source, un texte de Rion Williams en 2014 : http://rionscode.wordpress.com/2014/04/11/debugging-deeper-through-reference-source/
• À propos de libthread_db, texte de Joe Damato en 2013 : http://timetobleed.com/notes-about-an-odd-esoteric-yet-incredibly-useful-library-libthread_db/
• Survol d'UndoDB, un débogueur qui permet de reculer dans le temps, par Jack Whitham en 2015 : http://blog.jwhitham.org/2015/05/review-undodb-reversible-debugger.html
• Le DrMemory, qui est livré avec licence LGPL : http://drmemory.org/
• Déboguer en reculant dans le temps avec rr, un texte de Huon Wilson en 2015 : http://huonw.github.io/blog/2015/10/rreverse-debugging/

Débogueurs pour Linux :

• Une liste critique colligée par Howard Rubin en 2013 : http://www.drdobbs.com/testing/13-linux-debuggers-for-c-reviewed/240156817?pgno=1
• Une liste colligée par Saurabh Singh en 2014 : http://www.efytimes.com/e1/fullnews.asp?edid=145264
• L'outil Lockdep, pour déboguer les cas d'interblocage dans le noyau de Linux (entre autres). Une explication de Jonathan Corbet en 2013 : http://lwn.net/SubscriberLink/536363/344c96a33669826f/
• Utiliser gdb :
  • tirer au maximum profit de gdb, texte de 2015 par Jonathan Wakely : http://accu.org/index.php/journals/2111
  • avec gdb, il est parfois possible de faire du Reverse Debugging, pour reculer dans le suivi de l'exécution : https://sourceware.org/gdb/wiki/ReverseDebug
  • exemple de séance de débogage avec gdb, proposé par Kevin Pouget en 2015 : http://blog.0x972.info/?d=2015/09/09/09/19/14-debugging-with-gdb-a-real-life-example
  • introduction à l'utilisation de gdb, proposée par Alex Danoff en 2016 : https://komunity.komand.com/learn/article/gdb-for-fun-and-profit/
  • exemple de débogage avec gdb, proposé par Brendan Gregg en 2016 : http://www.brendangregg.com/blog/2016-08-09/gdb-example-ncurses.html
  • déboguer avec gdb, selon Julia Evans en 2016 : http://jvns.ca/blog/2016/08/10/how-does-gdb-work/
• En 2016, Julia Evans propose ses outils préférés pour déboguer sous Linux : http://jvns.ca/blog/2016/07/03/debugging-tools-i-love/

Outils de gestion et de suivi des bogues (Bug-Tracking Systems) :

• http://www.bugzilla.org/
• http://www.jetbrains.com/youtrack/index.html
• Prise de position contre la décentralisation de ces outils, par Éric S. Raymond en 2011 : http://esr.ibiblio.org/?p=3940

À propos du débogueur de Go, texte de Filippo Valsorda en 2015 : https://blog.cloudflare.com/go-has-a-debugger-and-its-awesome/

Écrire un débogueur

Écrire votre propre débogueur :

• Écrire un débogueur simple pour Microsoft Windows, texte du Code Project par Ajay Vijayvargiya en 2011 : http://www.codeproject.com/Articles/43682/Writing-a-basic-Windows-debugger
• Écrire un débogueur pour Java ou Scala, texte de Tal Weiss en 2013 : http://www.takipiblog.com/2013/09/24/how-to-write-your-own-java-scala-debugger/
• Texte de 2014 expliquant comment écrire un débogueur primitif :
  • http://www.codereversing.com/blog/?p=168
  • http://www.codereversing.com/blog/?p=169
  • http://www.codereversing.com/blog/?p=170

Bases du débogage

On nomme débogage cette pratique par lequel une programmeuse ou un programmeur cherche à découvrir pourquoi le comportement d'un programme ne correspond pas aux attentes. À propos des bases de cette pratique, pour ne pas dire cet « Art » :

• Le « comment déboguer 101 », le B-A-BA de cette pratique : http://blog.nikhilmarathe.me/2011/03/code-reading-and-bug-fixing-101.html
• Texte amusant sur les difficultés inhérentes au débogage dans un contexte de programmation système, par James Mickens en 2013 : https://research.microsoft.com/en-us/people/mickens/thenightwatch.pdf
• Le problème X-Y, par lequel qui débogue risque de perdre son énergie en fouillant au mauvais endroit : http://mywiki.wooledge.org/XyProblem
• Éviter les problèmes en premier lieu, ou comment écrire du code à faible risque de bogues, un texte de David Elentok en 2012 : http://elentok.blogspot.com/2012/01/solving-coding-problems.html
• Déboguer efficacement, ou faire distinguer la résolution d'un bogue d'une simple rustine (un patch), par Gabriel Silk en 2012 : http://www.runswift.ly/solving-bugs.html
• À propos des fichiers de journalisation (des Logs) :
  • à propos de l'importance de conserver des fichiers de journalisation de qualité, texte de Garry Shutler en 2012 : http://www.robustsoftware.co.uk/post/39211594225/logging
  • comment réaliser une journalisation de qualité, par Brice Figureau en 2013 : http://www.masterzen.fr/2013/01/13/the-10-commandments-of-logging/
  • utilisation efficace des fichiers de journalisation, texte de Lianne Hutt en 2013 : http://codeweavers.net/using-logs-effectively/
• Une approche scientifique au débogage, par John Regehr en 2013 : http://blog.regehr.org/archives/199
• Faciliter le débogage de code JavaScript, un texte de Panu Viljamaa en 2013 : http://panuviljamaablog.blogspot.ca/2013/05/use-functions-luke-javascript-has-been.html
• Une technique de débogage nommée le Live Programming :
  • texte de Rohan Pearce en 2013 : http://www.computerworld.com.au/article/459054/taking_pain_debugging_live_programming/

• Comment ne pas déboguer :
  • mal déboguer avec CoffeeScript ou Node.js, par Selin Öber en 2013 : http://selimober.com/blog/2013/09/09/obscure-errors-in-node-and-coffeescript/
• Déboguer du code optimisé (compilé en mode Release) avec Visual Studio 2012, par Bruce Dawson en 2013 : http://randomascii.wordpress.com/2013/09/11/debugging-optimized-codenew-in-visual-studio-2012/
• Débogage efficace, un texte de Carlos Bueno en 2013 : http://carlos.bueno.org/2013/09/effective-debugging.html
• Série d'articles sur le Troubleshooting, par Fabio Videira :
  • http://www.technoideas.com/the-basics-of-troubleshooting-part-1/
  • http://www.technoideas.com/the-basics-of-troubleshooting-part-2/
  • http://www.technoideas.com/the-basics-of-troubleshooting-part-3/
• De l'avis d'Andrew Koenig en 2013, il est parfois possible de prédire les bogues de par la structure d'un programme, ce qui peut influencer les choix de pratiques de tests : http://www.drdobbs.com/cpp/not-all-bugs-are-random/240165035
• Texte d'Andrzej Krzemieński en 2014 qui propose une démarche analytique de débogage d'une petite fonction, en se basant sur les idiomes du langage dans lequel elle est écrite : http://akrzemi1.wordpress.com/2014/02/12/find-the-bug/ (avec un suivi sur http://akrzemi1.wordpress.com/2014/03/13/find-the-bug-comments/ en réaction aux commentaires reçus)
• Dans ce texte de 2014, Jason M. Hanley recommande de se concentrer sur les éléments que l'on contrôle : http://blog.jasonhanley.com/2014/03/software-bugs-focus-on-what-you-can.html
• Très bon texte d'Eric Lippert en 2014 sur le débogage de petits programmes, avec plusieurs conseils tout à fait raisonnables : http://ericlippert.com/2014/03/05/how-to-debug-small-programs/
• Détecter les fuites de mémoire en Java, par Jose Ferreira de Souza Filho en 2014 : http://www.toptal.com/java/hunting-memory-leaks-in-java
• Dans ce texte de 2014, Ari Autio met de l'avant que nous devrions, pour l'essentiel, considérer un avertissement du compilateur comme une erreur : http://dev.solita.fi/2014/03/26/warnings-are-errors.html
• Texte d'Eric Lippert en 2014, qui explique la décision de rapporter un avertissement ou une erreur en C# : http://blog.coverity.com/2014/04/23/warnings-vs-errors/
• Texte de 2014 par Anthony Vallone, proposant des techniques pour réduire le nombre de bogues impossibles à reproduire dans un programme : http://googletesting.blogspot.ca/2014/02/minimizing-unreproducible-bugs.html
• Programmer avec l'aide du débogueur, dans un contexte de développement de jeu vidéo. Article de Maciej Sinilo en 2012 : http://msinilo.pl/blog/?p=965
• Trucs pour mieux déboguer avec gdb, par Himanshu Arora en 2014 : http://www.openlogic.com/wazi/bid/336594/advanced-gdb-tips-and-tricks
• En 2014, texte qui préconise de déboguer suivant une méthode qui a fait ses preuves... la méthode scientifique! http://yellerapp.com/posts/2014-08-11-scientific-debugging.html
• Neuf techniques de débogage, répertoriées en 2014 : http://macroware.wordpress.com/2014/03/29/debugging-strategies-techniques/
• La technique Sherlock Holmes, décrite par Sean Cassidy en 2014 : http://blog.seancassidy.me/sherlock-holmes-debugging.html
• Dépistage de bogues de concurrence avec Java, par Heinz Kanbutz en 2014 : http://www.infoq.com/articles/Hunting-Concurrency-Bugs-1
• Déboguer par hypothèses, par Ayron Wohletz en 2015 : http://ayronwohletz.com/debugging-with-hypotheses/
• Réduire les bogues en tirant profit du système de types d'un langage, par Andrzej Krzemieński en 2015 : https://akrzemi1.wordpress.com/2015/03/25/bug-of-the-week/
• Débogage à partir d'affichages à la console, par Brian W. Kernighan et Rob Pike : http://taint.org/2007/01/08/155838a.html
• Déboguer une grammaire Perl 6 : http://perlgeek.de/en/article/debug-a-perl-6-grammar
• En 2015, Remy Sharp discute de l'art du débogage : https://remysharp.com/2015/10/14/the-art-of-debugging

• En 2016, Raymond Chen explique comment il s'est écrit un petit programme pour faire semblant de déboguer lorsqu'il fait des démonstrations publiques : https://blogs.msdn.microsoft.com/oldnewthing/20160113-00/?p=92841
• Des trucs d'anti-débogage, ou comment se compliquer la vie, par Inbar Raz (avec aide par Eden Shochat et Yossi Gottlieb) : http://textfiles.com/programming/antidbg.txt
• En 2015, Nolan Lawson explique comment corriger un bogue dans un projet à code ouvert : https://nolanlawson.com/2015/12/28/how-to-fix-a-bug-in-an-open-source-project/
• Déboguer du code natif, trucs proposés par Bartlomiej Filipek en 2016 : http://www.bfilipek.com/2016/06/11-debugging-tips-that-will-save-your.html
• Approche systématique au débogage, proposée par Doug Bradbury en 2016 :
  • http://blog.8thlight.com/doug-bradbury/2016/07/01/methodical-approach-find-and-fix-bugs.html
  • http://blog.8thlight.com/doug-bradbury/2016/06/29/how-to-find-bug-in-your-code.html
  • http://blog.8thlight.com/doug-bradbury/2016/07/06/three-a-s-of-responding-to-bugs.html
• Texte de 2016 par Dan Luu, portant sur une expérience de débogage en situation de moindre familiarité avec le langage et les outils : http://bitfunnel.org/debugging-nativejit/
• Comment positionner des points d'arrêt, texte de Satabdi Das en 2016 : http://majantali.net/2016/10/how-breakpoints-are-set/

Domaines particuliers

La pratique du débogage peut être influencée par le contexte.

Débogage de problèmes de gestion de mémoire :

• Texte de 2016 par une entreprise qui vise à vendre un produit, qui illustre divers types de bogues de gestion de mémoire en langage C : http://backtrace.io/blog/blog/2016/08/03/introduction-to-memory-management-errors/

Débogage en conditions hostiles :

• Texte de 2016 par Erich Styger, qui discute de techniques pour déboguer des binaires n'incluant pas les symboles : https://mchouza.wordpress.com/2016/06/04/debugging-stripped-binaries/

Débogage propre aux systèmes multiprogrammés :

• Débogage « psychique » de code asynchrone avec C#, par Stephen Toub en 2013 : http://blogs.msdn.com/b/pfxteam/archive/2013/01/28/psychic-debugging-of-async-methods.aspx
• Déboguer du code AMP, par Gaston Hillar en 2014 : http://www.drdobbs.com/cpp/debugging-gpu-code-in-microsoft-c-amp/240168040?_mc=sm_drd

Débogage propre à la programmation orientée objet :

• Texte de Robert M. Lefkowitz en 2016 qui met de l'avant pourquoi il est si ardu de déboguer des objets : https://codewords.recurse.com/issues/one/why-are-objects-so-hard-to-debug

Débogage des outils des systèmes d'exploitation :

• Dépister une corruption de mémoire, par Randy Gaul en 2015 : http://www.randygaul.net/2015/10/15/finding-heap-corruption-tip-on-windows/
• Analyser un Core Dump sous FreeBSD, texte de 2015 par Brendon Scheinman : http://backtrace.io/blog/blog/2015/10/03/whats-a-coredump/
• Plus spécifiquement, débogage propre aux noyaux de systèmes d'exploitation :
  • déboguer le noyau de FreeBSD à distance à l'aide de communication sérielle : http://www.ibm.com/developerworks/aix/library/au-debugfreebsd.html?ca=dgr-lnxw01DbugFreeBSD
  • l'interface dynamique de débogage de Linux : http://lwn.net/Articles/434833/
  • rien de simple dans la recherche de bogues à l'intérieur d'une entité de ce niveau de complexité (texte de Neil Brown en 2011) : http://lwn.net/Articles/453685/
  • déboguer le noyau de Microsoft Windows, série d'articles en 2016 par Matt Mason (du moins, je pense que c'est son nom) :
    • https://blogs.msdn.microsoft.com/meason/2016/06/17/intro-to-kernel-debugging-1/
    • https://blogs.msdn.microsoft.com/meason/2016/06/17/intro-to-kernel-debugging-2/
    • https://blogs.msdn.microsoft.com/meason/2016/07/07/intro-to-kernel-debugging-3/
• Spécifique à Microsoft Windows :
  • détecter les violations d'ODR à l'aide de #pragma, un truc de 2016 proposé par Raymond Chen (inspiré par Stephan T. Lavavej) : https://blogs.msdn.microsoft.com/oldnewthing/20160803-00/?p=94015

Débogage propre aux langages fonctionnels :

• Déboguer une erreur lors d'une Tail-Recursion : http://funcall.blogspot.com/2011/03/tail-recursion-and-debugging.html
• Tracer la compilation d'une factorielle récursive sous Haskell : http://blog.ezyang.com/2011/04/tracing-the-compilation-of-hello-factorial/
• Déboguer un pipeline d'opérations en F#, par Anton Kropp en 2012 : http://tech.blinemedical.com/debugging-piped-sequences-f/
• Déboguer avec Clojure, par Kyle Kingsbury en 2014 : http://aphyr.com/posts/319-clojure-from-the-ground-up-debugging
• Déboguer ClojureScript dans un fureteur, est-ce raisonnable? Texte d'Eric Normand en 2015 : http://www.lispcast.com/debugging-clojurescript

Débogage avec Java :

• Ensemble d'erreurs classiques, et les diagnostics correspondants : http://errorprone.info/
• Que faire pour dépister les causes de hausses subites de l'utilisation du processeur, selon Ram Lakshmanan en 2016 : https://dzone.com/articles/troubleshoot-sudden-cpu-spikes

Débogage avec Lisp :

• Série de textes par Michael Malis en 2015 :
  • http://malisper.me/2015/07/07/debugging-lisp-part-1-recompilation/
  • http://malisper.me/2015/07/14/debugging-lisp-part-2-inspecting/
  • http://malisper.me/2015/07/22/debugging-lisp-part-3-redefining-classes/

Débogage avec Ruby :

• En 2015, Blake Mesdag rappelle qu'on peut aller plus loin que le simple recours à puts() : http://www.shopify.com/technology/17370004-theres-more-to-ruby-debugging-than-puts

Diagnostic Post-Mortem

Techniques de diagnostic post-mortem des processus :

• L'anatomie d'un bogue difficile à résoudre : http://blogs.msdn.com/b/rick_schaut/archive/2004/05/19/135315.aspx
• Déboguer une bibliothèque partagée : http://blog.ksplice.com/2010/09/debugging-shared-library-problems-a-real-world-example/
• Débogage et mémoire :
  • identifier et cerner les problèmes de corruption de mémoire et de mémoire non-initialisée : http://altdevblogaday.com/2011/05/30/finding-unitiliazed-memory-and-corruption/
  • utiliser Pageheap.exe sous Windows : http://support.microsoft.com/kb/286470
  • surveiller la consommation de mémoire dans le développement d'un jeu sur ordinateur personnel : http://www.gamasutra.com/view/feature/1430/monitoring_your_pcs_memory_.php
  • détecter les fuites de mémoire dans un programme .NET (oui, ça arrive). Article du Code Project, alors lire avec discernement : http://www.codeproject.com/KB/dotnet/BestPractices5.aspx
  • détecter les fuites de mémoire dans du code natif avec Visual Studio, à l'aide de la bibliothèque CrtDbg : http://www.codeproject.com/KB/cpp/MemoryDetection.aspx
  • texte de 2016 par Kamal Marhubi, qui explique ce qu'on peut tirer d'un SEGFAULT : http://kamalmarhubi.com/blog/2016/04/25/segfaults-are-our-friends-and-teachers/
  • en 2016, Tautvydas Zilys explique comment découvrir qui est le vilain qui écrit une valeur sur notre propre pile d'exécution : http://blogs.unity3d.com/2016/04/25/debugging-memory-corruption-who-the-hell-writes-2-into-my-stack-2/
• Analyser les exceptions et la pile des appels d'un programme C++ pour système embarqué une fois ce programme planté : http://www.codeproject.com/KB/windows/CallStackTest.aspx
• Analyser la pile des appels d'un programme Java, texte de Tomasz Nurkiewicz en 2012 : http://java.dzone.com/articles/filtering-stack-trace-hell
• http://www.yosefk.com/blog/what-makes-cover-up-preferable-to-error-handling.html
• Comment placer l'information utile au débogage dans des fichiers distincts du code objet, pour fins d'utilisation avec gdb (texte de 2011) : http://slackito.com/2011/08/24/separate-debug-information-with-gdb
• L'histoire d'un bogue de TCP : http://blogmal.42.org/tidbits/tcp-bug.story
• Provoquer des bogues de concurrence (texte de 2011) : http://blog.corensic.com/2011/08/22/accelerating-concurrency-bugs/
• Déboguer par bisection, technique proposée par Andrea Spadaccini en 2011 : http://edumips64.blogspot.com/2011/09/finding-bugs-via-bisection.html
• Récupérer diverses informations post-mortem, par Alexandru Juncu en 2011 : http://techblog.rosedu.org/rescuing-executable-code-from-a-process.html
• Combattre le Supervisor Mode Execution Protection (SMEP) sous Linux, un texte de 2011 (pas sûr que ça qualifie comme du débogage à proprement dit, mais bon...) : http://falken.tuxfamily.org/?p=115
• Comment OpenBSD utilise malloc() pour ce type de débogage, un texte de Robert Seaton en 2011 : http://os-blog.com/how-openbsd-leverages-malloc-to-find-bugs/
• Lire la pile des appels, et l'importance de la publication des symboles, par Bruce Dawson en 2011 : http://randomascii.wordpress.com/2011/11/27/a-tale-of-two-call-stacks/
• En 2004, Larry Osterman explique comment il débogue le code des autres : http://blogs.msdn.com/b/larryosterman/archive/2004/06/17/158336.aspx
• Aux grands maux les grands remèdes, un texte de 2013 qui explique comment déboguer un débogueur : http://blogs.msdn.com/b/ntdebugging/archive/2013/02/27/debugging-a-debugger-to-debug-a-dump.aspx
• Retracer un cas de segfault dans un programme aussi utilisé (et aussi rodé!) que grep, par Jason McSweeney en 2015 : http://blog.loadzero.com/blog/tracking-down-a-segfault-in-grep/ puis http://blog.loadzero.com/blog/digging-deeper-into-the-grep-segfault/
• En 2015, Dan Ellis relate son investigation « sans l'aide de Google » d'un problème un peu malpropre : https://medium.com/@dan.ellis/solving-a-tricky-problem-d1a8766f5347
• En 2014, Raymond Chen nous amène avec lui dans le débogage d'un processus paralysé : http://blogs.msdn.com/b/oldnewthing/archive/2014/10/24/10567004.aspx
• Analyse d'une fuite de mémoire en JavaScript chez Walmart, par T. J. Fontaine en 2013 : http://www.joyent.com/blog/walmart-node-js-memory-leak
• Comme le rappelle Raymond Chen en 2015, il faut parfois réfléchir avant de faire un diagnostic trop hâtif et « blâmer » un coupable « évident » : http://blogs.msdn.com/b/oldnewthing/archive/2015/08/13/10634840.aspx
• Analyser l'état du tas, par Michael Yan en 2016 : http://backtrace.io/blog/blog/2016/08/29/memory-allocator-tcmalloc/
• Analyser les pointeurs « passés date », texte de 2016 par Michael Yan : http://backtrace.io/blog/blog/2016/09/27/memory-error-stale-pointer/

Cas d'espèces

Cas d'espèces et expériences vécues :

• Texte amusant de Vinton Cerf, en 1985, proposant sous la forme d'un poème la réalité de la vie à la veille d'activer un nouveau réseau : https://tools.ietf.org/html/rfc968
• Une banque d'erreurs répertoriées par un outil d'analyse statique de code, offerte par Andrey Karpov en 2012 : http://www.reddit.com/r/viva64/comments/11n88s/this_is_intended_for_those_who_write_articles_and/
• Le cas de la résolution d'un bogue vieux de vingt ans, dans du code utilisé un peu partout dans le monde (texte de 2011) : http://www.azulsystems.com/blog/cliff/2011-08-28-just-fixed-a-20-year-old-bug
• Le cas d'un bogue de chargement de greffon, par Evan Martin en 2011 : http://neugierig.org/software/chromium/notes/2011/01/plugin-conflict.html
• Évidemment, même quand rien ne semble sensé, le programme nous parle. Un cas vécu : http://ridiculousfish.com/blog/archives/2011/09/15/The-app-that-was-fixed-by-a-crash/index.html
• Déboguer Firefox, un texte de 2011 : http://cheater.posterous.com/hacking-firefox
• Comment l'oubli d'un petit mot (ici, le mot var en JavaScript) peut ruiner un lancement de produit, texte de 2011 : http://blog.meloncard.com/post/12175941935/how-one-missing-var-ruined-our-launch
• Grosse bourde, relatée par Taylor Fausak en 2011, qui nous rappelle l'importance des copies de sauvegarde : http://taylor.fausak.me/2011/11/18/i-accidentally-deleted-all-our-data/
• En 2009, John Graham-Cumming relate une ligne de code épique (ses propres termes, ici) contenant à elle seule quatre types d'erreurs, soit une faute de design, deux erreurs d'implémentation, un problème de sécurité et un commentaire obsolète : http://blog.jgc.org/2009/01/single-line-assignment-filled-with-epic.html
• En 2011, Patrick McKenzie relate un bogue qui, de son propre aveu, est extrêmement subtil : http://www.kalzumeus.com/2011/11/17/i-saw-an-extremely-subtle-bug-today-and-i-just-have-to-tell-someone/
• En 2011, Joost van Dongen raconte le bogue le plus « poche » que son équipe ait jamais rencontré : http://joostdevblog.blogspot.com/2011/12/lamest-bug-we-ever-encountered.html
• Déboguer une machine virtuelle avec un outil de démonstration automatique de théorèmes, un texte de Rolf Rolles en 2012 : http://www.openrce.org/blog/view/1963/Finding_Bugs_in_VMs_with_a_Theorem_Prover,_Round_1
• Déboguer un programme qui se trouve dans l'espace (sur la planète Mars, rien de moins), une entrevue avec Daniel Lakey en 2012 : http://webservices.esa.int/blog/post/7/1382
• En 2012, Neil Brown nous offre un exemple de ce que peuvent nous apprendre les bogues : http://lwn.net/Articles/482345/
• Texte de 2012 par Raymond Chen, nous rappelant qu'un Crash Dump est quelque chose d'objectif, pas un objet de négociation : http://blogs.msdn.com/b/oldnewthing/archive/2012/09/28/10353944.aspx
• L'enfer, semble-t-il, est pavé de bonnes intentions. À cet effet, ce texte de Craig Gidney en 2012 décrit une situation existant dans ActionScript 3.0, où il semble que les gens derrière le design de la classe Dictionary, en voulant faire une optimisation, aient ouvert la porte à plusieurs nouveaux bogues : http://twistedoakstudios.com/blog/?p=925
• Texte de Raymond Chen en 2012, relatant une rustine (« patch ») de très bas niveau pour un logiciel, et décrivant sa stratégie pour repérer le problème et le régler sans avoir accès aux sources : http://blogs.msdn.com/b/oldnewthing/archive/2012/11/13/10367904.aspx
• Quand un outil d'analyse statique de code a un bogue, c'est très vilain, comme nous en fait part Bruce Dawson en 2012 : http://randomascii.wordpress.com/2012/11/28/another-bug-in-your-bug-finder-__offsetof/
• En 2012, Walter Bright explique comment il a migré son compilateur D vers une version 64 bits de Microsoft Windows : http://www.drdobbs.com/cpp/porting-the-d-compiler-to-win64/240144208
• Quelques cas vécus, relatés par Patrick Wyatt en 2012 : http://www.codeofhonor.com/blog/whose-bug-is-this-anyway
• En 2013, Andrew Koenig décrit les circonstances particulières qui l'ont mené à dépister un Heisenbug : http://www.drdobbs.com/cpp/its-a-heisenbug/240146005
• Texte de 2014 par Ryan Luecke sur la détection et la résolution d'un Heisenbug : http://tech.blog.box.com/2014/01/solving-a-heisenbug/
• Dans ce texte de 2013, Matt Swanson relate ce qui a été, du moins dans sa vie, le pire bogue d'entre tous : http://swanson.github.com/blog/2013/01/20/worst-bug-ever.html
• Une forme de débogage extrême, ou comment déboguer à l'aide d'un four. Par Alan Winfield en 2013 : http://alanwinfield.blogspot.com.br/2013/03/extreme-debugging-tale-of-microcode-and.html
• Texte instructif de Bruce Dawson en 2013 sur le débogage d'un script bash et ce que cela lui a appris : http://randomascii.wordpress.com/2013/03/18/counting-to-ten-on-linux/
• Personne n'est à l'abri. Témoignage de John Graham-Cumming en 2013 : http://blog.jgc.org/2013/07/your-test-suite-is-trying-to-tell-you.html
• Les dates, c'est l'horreur... Et les dates multiplateformes, dans un chiffrier électronique, c'est pire encore. Texte de 2013 : http://blogs.perl.org/users/ovid/2013/10/fighting-20-year-old-software-bugs.html
• Parlant d'horreur, imaginez déboguer un problème causé par ... le matériel! Dave Baggett raconte, en 2013, une aventure dans son passé : http://www.gamasutra.com/blogs/DaveBaggett/20131031/203788/My_Hardest_Bug_Ever.php
• L'expérience de Joe Damato, relatée en 2013, quant à la recherche de la cause d'une génération de thread de plus en plus lente passé un certain seuil avec Linux (un vieux bogue bien caché) : http://timetobleed.com/digging-out-the-craziest-bug-you-never-heard-about-from-2008-a-linux-threading-regression/ (merci à Jasmin Auger pour m'avoir envoyé ce lien!)
• Texte de 2014 colligeant quelques correctifs « sur une seule ligne » de bogues célèbres : http://www.tedunangst.com/flak/post/a-brief-history-of-one-line-fixes
• L'histoire d'héroïsme en débogage de Peter Lundgren, en 2013 : http://www.peterlundgren.com/blog/my-hardest-bug/
• En 2014, pendant qi'il cherchait à démontrer les bienfaits de la compilation en parallèle avec Visual Studio, Bruce Dawson a constaté que dans certaines circonstances, cela entraînait le démarrage... d'Internet Explorer! http://randomascii.wordpress.com/2014/03/31/you-got-your-web-browser-in-my-compiler/
• Le bogue qui disparaît lors de l'insertion d'un point d'arrêt, relaté par Drew Devault en 2014 : http://drewdevault.com/2014/02/02/The-worst-bugs.html
• En 2010, Henning Koch relate le pire bogue « qu'il n'a jamais corrigé » : http://blog.makandra.com/2010/04/the-greatest-bug-i-never-fixed/
• Texte de 2014 par Casey Muratori, relatant sa recherche et sa correction d'un gel de cinq secondes dans un programme (entre autres, ce texte met de l'avant qu'il est parfois intéressant de continuer de fouiller une fois un bogue identifié) : http://mollyrocket.com/casey/stream_0007.html
• En 2014, Raymond Chen montre comment il est possible de diagnostiquer un problème de DLL manquante même si la DLL semble être en mémoire : http://blogs.msdn.com/b/oldnewthing/archive/2014/05/23/10527836.aspx
• Difficile à résumer, mais ce texte de 2014 par Adam Butler relate une machine à café qui préparait du café à chaque fois qu'un serveur Web plantait... https://medium.com/@adambutler/why-i-connected-my-coffee-machine-to-the-internet-bd0c1546c03c
• Russ Cox, en 2014, relate un bogue subtil de concurrence et explique ce qu'on peut en tirer sur le plan de la compréhension plus globale du système touché : http://debuggers.co/concurrency/c/systems-programming/2014/07/15/Russ-Cox.html
• Le « plaisir » de déboguer le code de démarrage d'un système d'exploitation, surtout lorsque le bogue rencontré se manifeste de manière intermittente. Cas vécu relaté par Valerie Aurora en 2013 : http://blog.valerieaurora.org/2013/12/17/heres-my-favorite-operating-systems-war-story-whats-yours/
• En 2014, Alex Clemmer relate comment il a trouvé un bogue dans le code du Framework de .NET, et comment il lui a injecté un correctif « maison » : http://blog.nullspace.io/clr-bug.html
• Résoudre un cas de corruption de fichier sur iOS, texte de Slobodan Predolac et Nicolas Spiegelberg en 2014 : https://code.facebook.com/posts/313033472212144/debugging-file-corruption-on-ios/
• Nicholas Nethercote relate, en 2014, le suivi et la résolution d'un bogue pervers de gestion de mémoire avec Firefox, et explique au passage comment la collaboration avec les « victimes » du bogue a permis de le cibler et de le régler efficacement : https://blog.mozilla.org/nnethercote/2014/08/15/the-story-of-a-tricky-bug/
• En 2014, Nick Hamann a découvert un comportement erroné dans les fonctions de recherche dans des chaînes de caractères de Rust, faisant en sorte que "nan" et "nanas" soient dans "bananas" mais que "nana" n'y soit pas, et a ciblé deux bogues pervers en investigant la cause : http://www.wabbo.org/blog/2014/22aug_on_bananas.html
• Il arrive qu'un bogue survive en se cachant très longtemps là où on ne regarde pas. À cet effet, texte de Ryan Zezeski en 2014 : http://zinascii.com/2014/crossed-signals.html
• Texte de 2014 sur les Slow Bugs, ces bogues qui demandent un temps de test démesuré à reproduire. L'auteur prend d'ailleurs la peine d'établir un « modèle » approximatif de la quantité de tests requise pour établir, à un certain niveau de confiance, que le bogue a été réglé : http://www.embeddedfool.net/blog/2014/12/27/slow-bugs/
• Un bogue de certains jeux vidéo qui a donné naissance à des techniques de jeu, et qu'on nomme le Bunny Hopping, expliqué en 2015 par Adrian Biagioli : http://flafla2.github.io/2015/02/14/bunnyhop.html
• Déboguer un émulateur 6502, par Matt Godblot en 2014 : http://xania.org/201410/debugging-with-jsbeeb
• Article de 2015 par Julia Evans, intitulé Nancy Drew and the Case of the Slow Program : http://jvns.ca/blog/2015/03/15/nancy-drew-and-the-case-of-the-slow-program/
• Certains bogues sont particulièrement pervers, comme ce « bogue » de plus de 40 ans que l'on retrouve dans ASP .NET... qui n'existait alors même pas! http://metaltheater.com/2015/03/An-ASP-NET-bug-from-1973
• En 2014, Luke Shumaker relate « son bogue préféré », qui cause un segfault en Java : https://lukeshu.com/blog/java-segfault.html
• Que faire quand on outil d'analyse ou de profilage rapporte un nombre élevé de Page Faults? Texte de Riley Berton en 2014 : http://sdf.org/~riley/blog/2014/10/27/why-are-my-page-faults-to-high/
• En 2015, on a appris qu'un Boeing 787 actif pour 248 jours consécutifs verra ses systèmes s'éteindre, même s'il est en vol. Pourquoi? Le calcul du temps qui passe s'y fait aux $\frac{1}{100}$ème de seconde, et est encodé sur 32 bits signés, or $2^{31}\times\frac{1}{100}=248 \times 24 \times 60 \times 60$... Semble qu'un avion n'aime pas les temps négatifs :
  • article de Simon Sharwood en 2015 : http://www.theregister.co.uk/2015/05/01/787_software_bug_can_shut_down_planes_generators/
  • article d'Edgar Alvarez en 2015 : http://www.engadget.com/2015/05/01/boeing-787-dreamliner-software-bug/
  • article de Dan Goodin en 2015 : http://arstechnica.com/information-technology/2015/05/01/boeing-787-dreamliners-contain-a-potentially-catastrophic-software-bug/
• Le bogue d'un million de dollars, par Jacques Mattheij en 2014 : http://jacquesmattheij.com/the-several-million-dollar-bug
• Cinq bogues des plus... embarrassants de l'histoire, rapportés par David Pogue en 2014 : http://www.scientificamerican.com/article/pogue-5-most-embarrassing-software-bugs-in-history/
• En 2013, Dave Baggett relate le pire bogue qu'il aurait rencontré, soit un bogue matériel : http://www.gamasutra.com/blogs/DaveBaggett/20131031/203788/My_Hardest_Bug_Ever.php?1
• Un programme qui ne plante que le mercredi? Cas vécu relaté par Jani Patokallio en 2015 : http://gyrovague.com/2015/07/29/crashes-only-on-wednesdays/
• Texte de 2005 par Simon Garfinkel qui relate quelques-uns des pires bogues de l'histoire : http://archive.wired.com/software/coolapps/news/2005/11/69355?currentPage=all
• En 2015, Swizec Teller relate sa rencontre avec un vrai bogue de compilateur (car, avouons-le, bien qu'ils existent, on ne les frappe pas à tous les jours, la plupart des bogues étant plutôt de notre faute) : http://swizec.com/blog/dont-worry-its-a-compiler-bug/swizec/6764
• Le bogue favori de la carrière de Ryan Kennedy, relaté en 2016 : http://ryan.hypnoticocelot.com/post/136617949294/my-favorite-debug-ever
• Il est sage de signaler les bogues quand vous les rencontrez, même s'ils semblent bénins, car nous ne connaissons pas nécessairement le contexte dans lequel ils ont été produits, ou les autres outils qui pourraient avoir les mêmes bogues mais dans le contexte desquels ils pourraient être dangereux. Texte d'Aran Khanna en 2016 : https://medium.com/@arankhanna/how-finding-a-fun-little-bug-can-avert-disaster-176f158bf823
• Les conséquences d'une expression régulière défectueuse, par David Galbraith en 2016 : http://davidvgalbraith.com/how-i-fixed-atom/
• En 2015, Tyler R. relate une expérience qu'il qualifie d'horrible, soit la méthode assert_called_once() de son serveur : http://engineeringblog.yelp.com/2015/02/assert_called_once-threat-or-menace.html
• Quelques Bug Reports classiques, rapportés par John Regehr en 2015 : http://blog.regehr.org/archives/1270
• Histoire d'un bogue de type Back to the Future, relaté par Jeff Moser en 2015 : http://www.moserware.com/2015/10/back-from-the-future-bugs.html
• En 2015, Marek Majkowski raconte l'histoire d'un « pic » de latence inattendu (et inacceptable) : https://blog.cloudflare.com/the-story-of-one-latency-spike/
• Textes de Dan Luu :
  • en 2014, Dan Luu relate sa « semaine de bogues » : https://danluu.com/everything-is-broken/
  • il tient à jour sa propre liste d'histoires de débogage : https://github.com/danluu/debugging-stories
  • enseigner le débogage est une tâche périlleuse : http://danluu.com/teach-debugging/
• Texte d'Andrei Karpov en 2015, qui collige des erreurs propres à des programmes 64 bits : https://software.intel.com/en-us/articles/a-collection-of-examples-of-64-bit-errors-in-real-programs
• Texte de 2016 par Brian Hayes, sur « le bogue qui a "mangé" le mardi » : http://bit-player.org/2016/the-bug-that-ate-thursday
• Retrouver la source d'un flux UDP suspect à partir d'une chambre d'hôtel, cas vécu relaté par Gökberk Yaltıraklı en 2016 : http://wiki.gkbrk.com/Hotel_Music.html
• En 2016, Linus Akesson relate un problème de VSP (Variable Screen Position) sur Commodore 64 : http://www.linusakesson.net/scene/safevsp/index.php
• En 2016, Mark Dominus relate une séance de débogage où le problème était, littéralement, ailleurs : http://blog.plover.com/tech/tmpdir.html
• En 2012, Jonathan Corbet relate un bogue de compilateur, vu par certains plus comme un Feature que comme un bogue, et qui a affecté le bon fonctionnement du noyau de Linux : https://lwn.net/Articles/478657/
• Texte de 2016 par Bee Hollander, qui relate un bogue qui a persisté six mois, et qui explique que son expérience est aussi la raison pour laquelle il n'abrège plus les noms de variables : https://beehollander.wordpress.com/2016/07/08/the-6-month-bug-and-why-i-will-never-abbreviate-variable-names/
• Article de 2016 par Kieren McCarthy, qui explique qu'un bogue aurait mené une banque à traiter de vraies transactions comme des données de tests pendant des années, entraînant des pertes financières importantes : http://www.theregister.co.uk/2016/07/13/coding_error_costs_citigroup_7m
• Histoire d'une grande tristesse, relatée en 2015 par Adam Fabio, où des bogues dans le logiciel d'équipement médical (conditions de course, débordements de compteurs) ont mené à la mort de patients : http://hackaday.com/2015/10/26/killed-by-a-machine-the-therac-25/
• En 2016, Kenton Varda relate ce qu'il nomme « The Mysterious Fiber Bomb Problem » : https://sandstorm.io/news/2016-09-30-fiber-bomb-debugging-story
• Une histoire de bogue sur x86 résultant d'un problème d'alignement en mémoire, relatée par Pavel Zemtsov en 2016 : http://pzemtsov.github.io/2016/11/06/bug-story-alignment-on-x86.html
• Un bogue célèbre, soit celui du processeur Pentium qui réalisait des divisions erronnées, relaté par Aleksey Statsenko en 2016 : http://www.viva64.com/en/b/0454/
• Dans ce texte de 2016, Emil Ernerfeldt relate un bogue qui est, pour lui, insoluble : http://www.ilikebigbits.com/blog/2016/11/22/the-unfixable-bug
• En 2016, Aleksey Statsenko relate l'histoire du premier bogue sur Mars : http://www.viva64.com/en/b/0462/
• L'histoire d'un bogue prénommé Sleeping Beauty, un bogue qui a « dormi » dans les sources de EVE Online pendant longtemps avant d'être enfin résolu, le tout relaté en 2017 :