Quel est l'avantage d'éviter l'utilisation d'un débogueur?
Au cours de ma carrière, j'ai remarqué que certains développeurs n'utilisent pas d'outils de débogage, mais effectuent une vérification ponctuelle du code erroné pour déterminer le problème.
Bien que plusieurs fois être capable de trouver rapidement des erreurs dans le code sans débogueur soit une bonne compétence, il semble qu'il soit moins productif de passer beaucoup de temps à rechercher des problèmes lorsqu'un débogueur trouverait facilement de petites erreurs comme des fautes de frappe.
Est-il possible de gérer un complexe sans débogueur? Est-ce conseillé? Quels sont les avantages à utiliser en utilisant " débogage psychique ?"
Ce qui ressemble à une supposition de l'extérieur s'avère souvent être ce que j'appelle "le débogage dans votre esprit". D'une certaine manière, cela est similaire à la capacité des grands maîtres à jouer aux échecs sans regarder un échiquier.
C'est de loin la technique de débogage la plus efficace que je connaisse, car elle ne nécessite aucun débogueur. Votre cerveau explore plusieurs chemins de code en même temps, ce qui donne un meilleur délai que celui que vous pourriez obtenir avec un débogueur.
Je n'étais pas conscient de cette technique avant d'entrer brièvement dans le monde de programmation compétitive , où l'utilisation d'un débogueur signifiait perdre de précieuses secondes. Après environ un an de compétition, j'ai commencé à utiliser cette technique presque exclusivement comme ma première ligne de défense, suivie de la journalisation du débogage, avec l'utilisation d'un débogueur réel assis à la troisième place éloignée. Un effet secondaire utile de cette pratique a été que j'ai commencé à ajouter de nouveaux bogues à un rythme plus lent, car le "débogage dans mon esprit" ne s'est pas arrêté lorsque j'ai écrit du nouveau code.
Bien sûr, cette méthode a ses limites, principalement en raison des limites de son esprit à visualiser plusieurs chemins à travers le code. J'ai appris à respecter ces limites de mon esprit, en me tournant vers un débogueur pour corriger les bugs dans des algorithmes plus avancés.
Plus je connais une base de code, moins j'ai besoin d'un débogueur (mais je vérifierais toujours l'erreur signalée, c'est un indice important dans tout raisonnement).
C'est un bon outil pour comprendre certains comportements dynamiques de complexité petite à moyenne, mais je découvre souvent qu'il me concentre sur les détails plutôt que sur une vue d'ensemble. Et après un certain temps, c'est là que se trouvent les problèmes: dans des interactions de plus grande portée dont le comportement dynamique a tendance à être plus facilement compréhensible avec d'autres outils (journalisation des entrées et des sorties aux limites du module par exemple).
Ce ne sont peut-être pas de mauvais programmeurs, mais ce sont probablement des dépanneurs terriblement inefficaces.
J'ai tendance à suivre les conseils de Débogage: les 9 règles indispensables pour trouver même les problèmes logiciels et matériels les plus insaisissables (David Agans), et celui-ci tombe carrément sous la direction de "Arrêtez de penser et regardez"
Tout travail nécessite d'utiliser les bons outils de la bonne façon. Si vous avez un débogueur, utilisez-le pour voir ce qui se passe réellement. La plupart des bogues sont causés par des hypothèses.
J'ai travaillé avec des développeurs qui refusent d'utiliser les débogueurs parce qu'ils savaient mieux. La réponse classique que j'ai eue une fois était "le crash n'est pas provoqué par moi, j'ai passé toute la journée à inspecter le code [où il plantait] et il n'y a rien de mal". (Qu'en est-il de cette valeur nulle qui a été lue dans la base de données?) Le patron semblait penser que c'était une excellente réponse, mais le client ne l'a pas fait.
J'ai quitté cette équipe aussi vite que possible. Leur but était de faire évoluer le travail et de transformer un simple problème de 10 minutes en un problème toute la journée.
Votre meilleur guide pour la pratique du débogage est le livre de Steve McConnel Code Complete. Le chapitre 23 couvre le débogage en détail, et je vais en distiller quelques points.
- Comprendre le problème est important et l'utilisation du débogueur ne le remplace pas.
- Deviner est une mauvaise approche du débogage. Si vos collègues utilisent vraiment les conjectures, plutôt que de penser au problème, ils font du mauvais travail. Deviner signifie coller des instructions d'impression aléatoires dans le code et espérer trouver quelque chose d'utile.
- Si vos collègues ne savent vraiment pas comment utiliser un débogueur (plutôt que de choisir de ne pas en utiliser), alors oui, ils sont incompétents, tout comme quelqu'un qui ne connaît pas la syntaxe du langage qu'ils sont censés utiliser.
Je suis surpris que la discussion sur ce sujet n'ait pas fait mention de "tests unitaires".
Parce que je fais du développement piloté par les tests, je ne passe pas beaucoup de temps dans le débogueur. Il y a 10 ans, je suivais consciencieusement le débogueur:
- Après avoir écrit un morceau de code pour vous assurer qu'il fonctionne et
- Quand j'ai reçu un rapport de bogue pour essayer de diagnostiquer le problème
Ce que j'ai trouvé après 10 ans de développement piloté par les tests, c'est que je suis beaucoup plus productif en tant que programmeur si:
- J'écris des tests unitaires avant J'écris le code pour m'assurer de l'avoir écrit correctement
- J'écris des tests unitaires immédiatement après avoir reçu un rapport de bogue pour tenter de dupliquer et d'explorer le problème.
Permettre à l'ordinateur de parcourir le code et de valider le résultat est des milliers de fois plus rapide que je ne le pense ou de parcourir le code pour valider mentalement les résultats, et ne fait pas d'erreurs.
Je dois encore faire un pas dans le débogueur de temps en temps, et je suis toujours engagé dans l'analyse mentale du code ... mais seulement rarement, et surtout pour le code très délicat.
Dur à dire. Le débogage en devinant pourrait fonctionner si vous avez déjà une idée de ce qu'est le bogue (valeur incorrecte transmise à une fonction de bibliothèque, éventuellement SQL non valide, etc.). J'avoue que je le fais parfois lorsque l'erreur elle-même semble petite ou évidente, comme "tampon de caractères trop petit" - la trace de la pile me montre la ligne sur laquelle elle a échoué et je n'ai pas besoin d'un débogueur pour résoudre celle-ci.
Faire cela tout le temps peut être contre-productif et si les premières "suppositions" échouent, deviner est probablement la mauvaise stratégie de résolution de problème et un vrai débogueur devrait être appelé. Normalement, je dirais qu'il y a absolument rien de mal à utiliser le débogueur.
Cela étant dit, j'ai travaillé avec des outils et des environnements où le débogueur était si difficile à faire fonctionner correctement, ou si minime et inutile que deviner était malheureusement souvent une meilleure approche. J'ai travaillé avec des outils propriétaires qui n'avaient même pas de débogueurs appropriés. Je suppose qu'il est possible que si une personne travaille dans de tels environnements trop longtemps, elle finisse par perdre sa confiance dans les débogueurs et se fie uniquement à l'approche par devinettes.
Personnellement, j'essaie de minimiser l'utilisation d'un débogueur en:
- en utilisant vérificateurs statiques et des options de compilation similaires qui suggèrent des sources possibles de bogues simplement en analysant le code
- écrire du code avec aussi peu d'effets secondaires que possible, dans le style le plus fonctionnel possible, en éliminant si possible l'état mutable
- écriture tests unitaires avec la granularité raisonnable minimale
- ne pas avaler d'exceptions
Bien sûr, tout le monde fait des erreurs, donc même lors de la composition de programmes de cette façon, si un test échoue, j'utilise le débogueur pour inspecter la valeur d'une expression intermédiaire. Mais en adhérant aux principes ci-dessus, le défaut est plus facile à localiser et le débogage ne signifie pas un processus douloureux et indéterministe.
Utilisez le débogueur autant que possible. Le débogueur résoudra simplement le problème (oh regardez, nous n'avons pas vérifié cette valeur), ou fournira beaucoup de contexte qui est utile lors de l'analyse du code pertinent (wow, la pile est totalement foirée, je vais que ce soit un problème de dépassement de tampon).
Le débogage est un outil très utile pour inspecter l'état des objets et des variables dans votre code au moment de l'exécution.
Comme mentionné précédemment dans les réponses ci-dessus, le débogage est extrêmement utile, mais dans certains cas, il est limité.
D'après mon expérience, je trouve que l'utilisation du débogueur est très utile car elle aide à révéler les fausses hypothèses que je faisais sur l'état de mon code. Certaines personnes ne sont pas aussi habiles à lire le code pour trouver un bogue, donc le débogage peut aider à révéler de fausses hypothèses que vous ou un autre développeur avez faites sur l'état du code.
Peut-être vous attendez-vous à ce qu'un paramètre ne soit jamais nul lorsqu'il est transmis à une méthode, vous ne vérifiez donc jamais ce cas et continuez dans la méthode comme si ce paramètre ne serait jamais nul. La réalité est que le paramètre will finira par être nul à un moment donné même si vous définissez comme condition préalable à la méthode que le paramètre ne doit jamais être nul. Cela arrivera toujours.
Contrairement à l'utilité des débogueurs dans les exemples susmentionnés, je trouve difficile et quelque peu inutile à utiliser lorsque le multithread (c'est-à-dire la concurrence, le traitement asynchrone) est impliqué. Cela peut aider, mais il est facile de perdre votre orientation dans le brouillard multithread lorsque les points d'arrêt du débogueur sont atteints dans un thread au point A et un thread complètement séparé au point B. Le développeur est forcé de pousser le nouveau point d'arrêt " processus de pensée "au sommet de la" pile "de son cerveau et s'orienter vers le code au point du nouveau point d'arrêt. Une fois que la pertinence du point d'arrêt B diminue, le développeur revient ensuite au premier point d'arrêt et doit se rappeler ce qu'il cherchait avant le déclenchement du point d'arrêt B. Je sais que cela peut être une explication déroutante, mais mon point dans ce paragraphe est que le débogage où la concurrence est utilisée peut être très ADD (Attention Deficit Disorder) et il peut donc être plus difficile de rester productif dans votre schéma de réflexion de débogage.
L'imprévisibilité du code simultané peut également distraire davantage le développeur lors du débogage du code simultané.
En conclusion, à mon avis honnête:
- Débogage lorsque la simultanéité est utilisée = tendance accrue à perdre le focus du "modèle de pensée de débogage"
et
- n'importe quand autrement = augmentation de la productivité de débogage b/c votre attention n'est pas interrompue par des points d'arrêt inattendus (inattendus en raison des conditions de concurrence).
Je pense qu'ils sont un peu trop hardcore. Personnellement, lorsque je rencontre un bogue, je revérifie le code, j'essaie de le retracer dans ma tête à partir de la logique du programme, car cela m'aide parfois à découvrir d'autres problèmes ou effets secondaires plus facilement que d'utiliser simplement le débogueur et de corriger le bogue là où il se manifeste. .
Même quand je pense que je l'ai cloué, je le débogue habituellement pour m'assurer d'avoir raison. Lorsque le problème est un peu plus complexe, je pense que le débogage est absolument essentiel.
Aussi ... juste mon avis mais, il n'y a aucune excuse pour ne pas tirer un avantage décent des outils modernes IDE peut apporter à la table. Si cela vous aide à terminer votre travail plus rapidement et en d'une manière plus fiable, vous devriez l'utiliser.
Je déteste généraliser, mais de nombreux programmeurs que j'ai rencontrés pensent qu'il n'y a qu'une seule façon de résoudre un problème (à leur manière). Il est facile de supposer que tous les tests possibles ont été pensés. Une perspective différente peut être très précieuse.
La programmation par essais et erreurs peut proposer de nouvelles approches formidables et attraper des choses que d'autres ont manquées.
L'inconvénient, prend généralement beaucoup plus de temps.
Euh, cela dépend de la personne. Personnellement, je n'utilise pas beaucoup de débogueurs moi-même. Lorsque je programme des microcontrôleurs, j'utilise essentiellement des LED ou j'écris des données sur des EEPROM pour "déboguer" le code dessus. Je n'utilise pas JTAG.
Lorsque je programme des logiciels pour PC ou serveurs, j'ai tendance à utiliser la journalisation et de nombreuses sorties de console. Pour les langages de style C, j'utilise des directives de préprocesseur et en Java j'ai utilisé des niveaux de log.
Puisque je n'utilise pas de débogueurs, diriez-vous que je fais quelque chose de mal? Ce sont les tâches des éditeurs, pour me montrer où j'ai des erreurs syntaxiques, et quand il y a une erreur logique, je n'ai qu'à exécuter des tests.
Il y a une différence entre ne pas avoir besoin d'utiliser un débogueur et ne pas savoir comment (ou refuser) d'utiliser un débogueur. Le débogueur n'est qu'un des nombreux outils à utiliser pour suivre et corriger les bogues. J'ai travaillé avec des développeurs qui peuvent le comprendre dans leur tête et d'autres qui pensent qu'ils le peuvent.
Le meilleur mélange est d'écrire votre code afin qu'il soit facile de tester via des tests unitaires et de consigner les erreurs. Ensuite, vous espérez que vous n'avez pas besoin de consulter les journaux ou d'utiliser le débogueur. C'est un peu comme acheter une assurance. J'espère que vous n'aurez jamais besoin de l'utiliser, mais une fois que vous rencontrez un bogue qui ne peut pas être résolu en revérifiant le code, il est trop tard pour ajouter une gestion/journalisation des erreurs appropriée, des tests unitaires ou apprendre à utiliser un débogueur.
Différents outils/plates-formes favorisent différentes techniques de débogage (débogueur, journalisation, tests unitaires, etc.) Tant qu'un développeur connaît certaines des techniques de sa plate-forme/outil, en plus de simplement revérifier le code, alors ils peuvent être un développeur qualifié, mais s'ils n'ont qu'une seule astuce en matière de débogage, ils finiront par rencontrer un bogue qu'ils ne peuvent pas trouver ou corriger.
Beaucoup de réponses, mais pas une mention sur Heisenbug ?!?!
Les Heisenbugs se produisent parce que les tentatives courantes de débogage d'un programme, telles que l'insertion d'instructions de sortie ou son exécution dans un débogueur, modifient généralement le code, changent les adresses mémoire des variables et le calendrier de son exécution.
J'utilise le débogueur, uniquement dans le pire des cas (pour les bogues difficiles à trouver). En outre, conformément aux meilleures pratiques dont de nombreux développeurs/testeurs acclamés ont parlé, il est bon de tester soigneusement le code. De cette façon, vous pouvez couvrir la plupart des problèmes et donc il ne serait pas nécessaire d'utiliser le débogueur.
Avec de bons tests unitaires et des exceptions qui vous fournissent la trace, vous devez rarement utiliser un débogueur.
La dernière fois que j'ai utilisé un débogage, c'est quand j'ai obtenu un fichier principal dans une application héritée.
Suis-je un "serviteur débogueur" ou ces gars sont-ils "trop hardcore"?
Ni. Ce sont juste des gens qui aiment rendre leur vie plus difficile que ça ne devrait l'être.
J'ai lu un argument contre le débogage du débogage ici récemment (ou était-ce StackOverflow?). Vous devriez avoir des cas de test par rapport à votre code. Si vos tests réussissent, votre débogage ne va probablement pas exercer le bogue (hypothèse: vous déboguerez avec des données similaires à vos données de test).
En revanche, la journalisation est obligatoire. Si vous réussissez vos tests et que vous déployez en production, vous pouvez constater que vous avez un bogue. La preuve du bug provient de quelque chose qui s'est produit dans le passé. c.-à-d. quelqu'un dit: "Comment est-ce arrivé là-dedans?" Si vous n'avez pas de bons journaux, vous n'en trouverez jamais la cause. Même un débogueur peut ne pas être utile à ce stade, car vous ne savez pas à quoi ressemblaient les données qui ont réellement exercé le bogue. Vous devez pouvoir déboguer l'application à partir des journaux.
Malheureusement, je paraphrase un peu et je ne suis peut-être pas en train de rendre l'argument original. En particulier, la position "Il existe des aides de débogage importantes pour passer du temps de développement à soutenir" pourrait être orthogonale à l'importance des débogueurs. Mais la partie sur la difficulté de définir l'état du système dans une configuration qui rend le débogage utile pour trouver des bogues m'a semblé quelque chose à penser.
Le débogage n'est qu'un outil qu'un bon développeur doit utiliser avec compétence.
Certes, parfois, vous pouvez savoir par cœur où se trouve le bogue si vous connaissez la base de code. Mais vous pouvez également perdre une journée ou une semaine entière pour trouver un bug embêtant simplement en consultant le code.
Dans les langages typés dynamiquement sans sorte de débogage (même s'il ne s'agit que de vider des valeurs sur la console), il devient parfois impossible de deviner.
Donc, pour répondre à votre question - ce sont peut-être de brillants programmeurs, mais leurs compétences en dépannage et leur compétence lors de la chasse aux bogues sont mauvaises.
Dépend de l'étendue d'un problème. Si le programme est petit et que les choses sont bien divisées, vous pouvez probablement le découvrir en regardant. Si le programme comprend 4,5 millions de lignes de code développées par une équipe de plus de 100 personnes au cours de plusieurs années, certains bogues seront impossibles à repérer.
Celui en question dans ledit programme (en C) était un écrasement de mémoire. Le débogueur avec un point d'arrêt mémoire a identifié la ligne de code incriminée dès l'apparition du bogue. Mais dans ce cas, il n'y a aucun moyen que quelqu'un puisse lire et conserver les 4,5 millions de lignes de code pour identifier le seul endroit que quelqu'un a écrit devant leur tableau (en plus, il devrait avoir connu la disposition d'exécution de la mémoire pour l'état du programme gargantuesque environ 10 minutes dans une longue série d'entrées pour y arriver).
Le point étant: dans les petits programmes ou les choses qui sont hautement modulaires, vous pouvez vous en sortir sans débogueur. Si le programme est vraiment gros et complexe, le débogueur peut vous faire gagner beaucoup de temps. Comme d'autres l'ont dit, c'est un outil, et il a ses situations où il excelle au-dessus de toute autre méthode, et d'autres où ce n'est pas le meilleur choix.
Si le bogue se produit sur l'ordinateur d'un client ou sur un ordinateur dont l'environnement est très différent du vôtre, la configuration d'un débogueur/débogueur distant est fastidieuse. Donc, pour la journée froide où vous obtenez un bug sur le terrain, la réponse "mais ... je n'ai pas de débogueur" n'aide pas. Par conséquent, vous devez développer un ensemble de compétences pour résoudre les problèmes et trouver le bogue simplement en comprenant le code et les fichiers journaux.