Pourquoi le débogage est-il meilleur dans un IDE? [fermé]

Je suis développeur de logiciels depuis plus de vingt ans, programmant en C, Perl, SQL, Java, PHP, JavaScript et récemment Python. Je n'ai jamais eu de problème que je ne pouvais pas déboguer en réfléchissant soigneusement et en utilisant des printinstructions de débogage bien placées .

Je respecte le fait que beaucoup de gens disent que mes techniques sont primitives, et utiliser un vrai débogueur dans un IDE est bien meilleur. Pourtant, d'après mon observation, les utilisateurs de l'IDE ne semblent pas déboguer plus rapidement ou avec plus de succès que moi, en utilisant mes couteaux en pierre et mes peaux d'ours. Je suis sincèrement ouvert à l'apprentissage des bons outils, je n'ai tout simplement jamais vu un avantage convaincant à utiliser des débogueurs visuels.

De plus, je n'ai jamais lu un tutoriel ou un livre qui montrait comment déboguer efficacement à l'aide d'un IDE, au-delà des bases de la définition des points d'arrêt et de l'affichage du contenu des variables.

Qu'est-ce que je rate? Qu'est-ce qui rend les outils de débogage IDE tellement plus efficaces qu'une utilisation réfléchie des printinstructions de diagnostic ?

Pouvez-vous suggérer des ressources (didacticiels, livres, screencasts) qui montrent les techniques les plus fines de débogage IDE?

Douces réponses! Merci beaucoup à tous d'avoir pris le temps. Très éclairant. J'ai voté pour beaucoup et aucun contre.

Quelques points notables:

• Les débogueurs peuvent m'aider à effectuer une inspection ou une modification ad hoc de variables, de code ou de tout autre aspect de l'environnement d'exécution, tandis que le débogage manuel m'oblige à arrêter, modifier et réexécuter l'application (nécessitant éventuellement une recompilation).
• Les débogueurs peuvent s'attacher à un processus en cours d'exécution ou utiliser un vidage sur incident, alors qu'avec le débogage manuel, des «étapes pour reproduire» un défaut sont nécessaires.
• Les débogueurs peuvent afficher des structures de données complexes, des environnements multithreads ou des piles d'exécution complètes facilement et d'une manière plus lisible.
• Les débogueurs offrent de nombreuses façons de réduire le temps et le travail répétitif pour effectuer presque toutes les tâches de débogage.
• Les débogueurs visuels et les débogueurs de console sont tous deux utiles et ont de nombreuses fonctionnalités en commun.
• Un débogueur visuel intégré dans un IDE vous donne également un accès pratique à l'édition intelligente et à toutes les autres fonctionnalités de l'EDI, dans un seul environnement de développement intégré (d'où le nom).

Quelques exemples de certaines capacités qu'un débogueur IDE vous donnera sur les messages de trace dans le code:

• Affichez la pile d'appels à tout moment, vous donnant un contexte pour votre frame de pile actuel.
• Entrez dans des bibliothèques que vous ne pouvez pas recompiler dans le but d'ajouter des traces (en supposant que vous ayez accès aux symboles de débogage)
• Changer les valeurs des variables pendant l'exécution du programme
• Modifier et continuer - la possibilité de modifier le code pendant son exécution et de voir immédiatement les résultats du changement
• Être capable de regarder les variables, voir quand elles changent
• Être capable de sauter ou de répéter des sections de code pour voir comment le code fonctionnera. Cela vous permet de tester les modifications théoriques avant de les apporter.
• Examiner le contenu de la mémoire en temps réel
• Vous alerte lorsque certaines exceptions sont levées, même si elles sont gérées par l'application.
• Point d'arrêt conditionnel ; arrêter l'application uniquement dans des circonstances exceptionnelles pour vous permettre d'analyser la pile et les variables.
• Affichez le contexte du thread dans les applications multi-thread, ce qui peut être difficile à réaliser avec le traçage (car les traces de différents threads seront entrelacées dans la sortie).

En résumé, les instructions d'impression sont (généralement) statiques et vous devrez recompiler pour obtenir des informations supplémentaires si vos instructions d'origine n'étaient pas suffisamment détaillées. L'EDI supprime cette barrière statique, vous donnant une boîte à outils dynamique à portée de main.

Quand j'ai commencé à coder, je ne pouvais pas comprendre ce qu'était le gros problème avec les débogueurs et je pensais que je pouvais faire n'importe quoi avec le traçage (d'accord, c'était sur unix et le débogueur était GDB). Mais une fois que vous avez appris à utiliser correctement un débogueur graphique, vous ne voulez plus revenir aux instructions d'impression.

• Un débogueur IDE vous permet de modifier les valeurs des variables au moment de l'exécution.

• Un débogueur IDE vous permet de voir la valeur des variables que vous ne saviez pas que vous vouliez voir lorsque l'exécution a commencé.

• Un débogueur IDE vous permet de voir la pile d'appels et d'examiner l'état de la fonction ayant passé des valeurs étranges. (pensez que cette fonction est appelée à partir de centaines d'endroits, vous ne savez pas d'où viennent ces valeurs étranges)

• Un débogueur IDE vous permet d'interrompre conditionnellement l'exécution à tout moment du code, en fonction d'une condition et non d'un numéro de ligne.

• Un débogueur IDE vous permettra d'examiner l'état du programme dans le cas d'une exception non gérée au lieu de simplement craquer.

Voici une chose que vous ne pouvez certainement pas déboguer avec l'instruction "print", c'est-à-dire lorsqu'un client vous apporte un vidage de mémoire et vous dit "votre programme a planté, pouvez-vous me dire pourquoi?"

• Imprimer des instructions tout au long de votre code réduit la lisibilité.
• Les ajouter et les supprimer uniquement à des fins de débogage prend du temps
• Les débogueurs suivent la pile d'appels, ce qui vous permet de voir facilement où vous vous trouvez
• Les variables peuvent être modifiées à la volée
• Des commandes ad hoc peuvent être exécutées pendant une pause dans l'exécution pour aider au diagnostic
• Peut être utilisé EN CONJONCTION avec des instructions d'impression: Debug.Write ("...")

Je pense que le débogage à l'aide d'instructions d'impression est un art perdu et qu'il est très important pour chaque développeur d'apprendre. Une fois que vous savez comment faire cela, certaines classes de bogues deviennent beaucoup plus faciles à déboguer de cette façon que via un IDE. Les programmeurs qui connaissent cette technique ont également une très bonne idée des informations utiles à mettre dans un message de journal (sans oublier que vous finirez par lire le journal) à des fins autres que de débogage.

Cela dit, vous devriez vraiment savoir comment utiliser le débogueur pas à pas, car pour une classe différente de bogues, c'est BEAUCOUP plus facile. Je laisse le soin aux autres excellentes réponses déjà postées d'expliquer pourquoi :)

Du haut de ma tête:

1. Débogage d'objets complexes - Les débogueurs vous permettent de pénétrer profondément dans les entrailles d'un objet. Si votre objet a, par exemple, un tableau d'objets complexes, les instructions d'impression ne vous mèneront pas plus loin.
2. La possibilité de dépasser le code - Les débogueurs vous permettront également d'ignorer le code que vous ne souhaitez pas exécuter. Certes, vous pouvez également le faire manuellement, mais c'est beaucoup plus de code que vous devez injecter.

Comme alternative au débogage dans l'IDE, vous pouvez essayer une excellente console PHP d' extension Google Chrome avec une bibliothèque php qui permet de:

• Voir les erreurs et les exceptions dans la console JavaScript Chrome et dans les fenêtres contextuelles de notification.
• Videz n'importe quelle variable de type.
• Exécutez le code PHP à distance.
• Protégez l'accès par mot de passe.
• Regroupez les journaux de la console par demande.
• Aller au fichier d'erreur: ligne dans votre éditeur de texte.
• Copiez les données d'erreur / de débogage dans le presse-papiers (pour les testeurs).

Je n'ai pas développé depuis près de 20 ans, mais je trouve qu'en utilisant un IDE / débogueur, je peux:

• voir toutes sortes de choses que je n'aurais peut-être pas pensé inclure dans une déclaration imprimée
• parcourir le code pour voir s'il correspond au chemin que je pensais qu'il faudrait
• définir des variables sur certaines valeurs pour que le code prenne certaines branches

Une des raisons d'utiliser l'EDI pourrait être que les IDE modernes prennent en charge plus que de simples points d'arrêt. Par exemple, Visual Studio propose les fonctionnalités de débogage avancées suivantes:

• définir des points d'arrêt conditionnels (rupture uniquement si une condition est remplie, ou uniquement à la n-ième fois que l'instruction au point d'arrêt est exécutée)
• break sur une exception non gérée ou chaque fois qu'une ecxeption (spécifique) doit être lancée
• changer la variable pendant le débogage
• répéter un morceau de code en définissant la ligne suivante à exécuter
• etc.

De plus, lorsque vous utilisez le débogueur, vous n'aurez pas à supprimer toutes vos instructions d'impression une fois le débogage terminé.

Une chose que je suis surpris de ne pas avoir vu dans une autre réponse est que les 2 méthodes de débogage ne sont pas mutuellement exclusives .

printfle débogage peut fonctionner très bien même si vous utilisez un débogueur standard (qu'il soit basé sur IDE ou non). En particulier avec un cadre de journalisation afin que vous puissiez laisser tout ou partie du produit publié pour vous aider à diagnostiquer les problèmes des clients.

Comme indiqué dans à peu près toutes les autres réponses ici, la principale chose intéressante à propos d'un débogueur standard est qu'il vous permet d'examiner plus facilement (et potentiellement de modifier) ​​les détails de l'état du programme. Vous n'avez pas besoin de savoir à l'avance ce que vous voudrez peut-être regarder - tout est disponible à portée de main (plus ou moins).

D'après mon expérience, les impressions simples ont un énorme avantage que personne ne semble mentionner.

Le problème avec un débogueur IDE est que tout se passe en temps réel. Vous arrêtez le programme à un certain moment, puis vous parcourez les étapes une à une et il est impossible de revenir en arrière si vous voulez soudainement voir ce qui s'est passé auparavant. Ceci est complètement en contradiction avec le fonctionnement de notre cerveau. Le cerveau recueille des informations et forme progressivement une opinion. Il peut être nécessaire de répéter les événements plusieurs fois pour ce faire, mais une fois que vous avez dépassé un certain point, vous ne pouvez pas revenir en arrière.

Contrairement à cela, une série sélectionnée d'impressions / journalisation vous donne une "projection spatiale des événements temporels". Cela vous donne une histoire complète de ce qui s'est passé, et vous pouvez revenir en arrière et en quatrième plusieurs fois très facilement en faisant simplement défiler vers le haut et vers le bas. Il est facile de répondre à des questions telles que "A est-il arrivé avant B". Cela peut vous faire voir des modèles que vous ne cherchiez même pas.

Donc d'après mon expérience. L'EDI et les débogueurs sont des outils fantastiques pour résoudre des problèmes simples lorsque quelque chose dans une seule pile d'appels a mal tourné, et explorer l'état actuel de la machine lors d'un certain crash.

Cependant, lorsque nous abordons des problèmes plus difficiles, il s'agit d'un changement d'état progressif. Là où, par exemple, un algorithme corrompait une structure de données, cela provoquait à son tour l'échec d'un autre algorithme. Ou si nous voulons répondre à des questions telles que «à quelle fréquence cela se produit-il», «les choses se passent-elles dans l'ordre et de la manière dont je les imagine». etc. Ensuite, la technique de journalisation / impression «à l'ancienne» a un net avantage.

La meilleure chose à faire est d'utiliser l'une ou l'autre de ces techniques quand elle est la plus appropriée, par exemple, utiliser la journalisation / l'impression pour accéder à certains bogues et faire une pause à un point d'arrêt où nous devons explorer l'état actuel plus en détail.

Il existe également des approches hybrides. Par exemple, lorsque vous faites console.log (objet), vous obtenez un widget de structure de données dans le journal que vous pouvez développer et explorer plus en détail. C'est souvent un net avantage par rapport à un journal de texte "mort".

Parce que le débogage des applications multithreads avec des instructions print vous rendra bananes. Oui, vous pouvez toujours le faire avec des instructions d'impression, mais vous en auriez besoin beaucoup et démêler l'impression séquentielle des instructions pour émuler l'exécution multi-threadg prendrait beaucoup de temps.

Les cerveaux humains ne sont malheureusement qu'un fil conducteur.

Depuis que vous avez demandé des pointeurs vers des livres ... En ce qui concerne le débogage Windows, John Robbins a plusieurs éditions d'un bon livre sur le débogage Windows:

Débogage d'applications pour Microsoft .NET et Microsoft Windows

Notez que l'édition la plus récente ( Débogage des applications Microsoft .NET 2.0 ) est .NET uniquement, vous pouvez donc en vouloir une plus ancienne (comme dans le premier lien) si vous souhaitez un débogage de code natif (il couvre à la fois .NET et natif).

Personnellement, je pense que la réponse est aussi simple que "Un débogueur / IDE intégré vous donne rapidement une multitude d'informations différentes sans avoir besoin de saisir des commandes. Les informations ont tendance à être là devant vous sans que vous ne lui disiez quoi te montrer.

La facilité avec laquelle les informations peuvent être récupérées est ce qui les rend meilleures que le débogage en ligne de commande ou le débogage "printf".

Avantages d'un débogueur par rapport à un printf ( notez pas un débogueur IDE mais n'importe quel débogueur )

1. Peut définir des points de surveillance. C'est l'une de mes façons préférées de trouver des corruptions de mémoire

2. Peut déboguer un binaire que vous ne pouvez pas recompiler pour le moment

3. Peut déboguer un binaire qui prend beaucoup de temps à recompiler

4. Peut changer les variables à la volée

5. Peut appeler des fonctions à la volée

6. N'a pas le problème où les états de débogage ne sont pas vidés et, par conséquent, le problème de synchronisation ne peut pas être débogué de manière précise

7. Les débogueurs aident avec les vidages de mémoire, les instructions d'impression ne sont pas

C'est ce que j'utilise le plus sur les fenêtres de débogage VS.NET:

• Pile d'appels, qui est également un excellent moyen de comprendre le code de quelqu'un d'autre
• Les habitants et les montres.
• Fenêtre immédiate, qui est essentiellement une console C # et me permet également de modifier le contenu des variables, d'initialiser des éléments, etc.
• La possibilité de sauter une ligne, définir l'instruction suivante à exécuter ailleurs.
• La possibilité de survoler les variables et d'avoir une info-bulle me montrant leurs valeurs.

En résumé, cela me donne une vue à 360 degrés de l'état de mon code en cours d'exécution, pas seulement une petite fenêtre.

Je n'ai jamais trouvé de livre enseignant ce genre de choses, mais là encore, cela semble assez simple, c'est à peu près WYSIWYG.

• Un débogueur peut s'attacher à un processus en cours d'exécution

• Souvent plus facile de déboguer le code thread à partir d'un débogueur

Avec un débogueur IDE, vous pouvez voir les valeurs de TOUTES les variables dans la portée actuelle (tout le long de la pile d'appels) chaque fois que vous arrêtez l'exécution.

Déclarations d'impression peut être grande , mais le dumping tellement d' informations à l'écran à un endroit donné peut produire un ensemble beaucoup d'états d'impression.

En outre, de nombreux débogueurs IDE vous permettent de taper et d'évaluer des méthodes, et d'évaluer les membres pendant que vous êtes arrêté, ce qui augmente encore la quantité d'instructions d'impression que vous devez faire.

Je pense cependant que les débogueurs sont meilleurs pour certaines langues que pour d'autres ...

Mon opinion générale est que les débogueurs IDE sont absolument, incroyablement merveilleux pour les langages gérés comme Java ou C #, sont assez utiles pour C ++ et ne sont pas très utiles pour les langages de script comme Python (mais il se pourrait que je n'ai tout simplement pas essayé un bon débogueur pour tous les langages de script).

J'adore le débogueur d'IntelliJ IDEA lorsque je fais du développement Java. J'utilise simplement des instructions d'impression lorsque j'utilise Python.

Comme quelqu'un l'a dit ci-dessus: Debugger! = IDE.

gdb et (à l'époque) TurboDebugger (autonome) fonctionnent très bien pour les langues qu'ils supportent [ed], merci. (ou une technologie encore plus ancienne: le débogueur Clipper lié à l'exécutable xBase lui-même) - aucun de ceux-ci ne nécessitait un IDE

De plus, bien que le codage C / ++ soit plus rare, les instructions printf masquent parfois le bogue que vous essayez de trouver! (problèmes d'initialisation dans les variables automatiques sur la pile, par exemple, ou allocation / alignement de la mémoire)

Enfin, comme d'autres l'ont indiqué, vous pouvez utiliser les deux. Certains problèmes en temps réel nécessitent presque une impression, ou au moins un judicieux "* video_dbg = (is_good? '+': '-');" quelque part dans la mémoire vidéo. Mon âge se montre, c'était sous DOS :-)

TMTOWTDI

En plus de beaucoup de ce que les autres affiches ont dit, j'aime vraiment parcourir une ligne à la fois avec l'ordinateur, car cela me force à penser à une ligne à la fois. Souvent, j'attraperai le bogue sans même regarder les valeurs des variables simplement parce que je suis obligé de le regarder lorsque je clique sur le bouton «ligne suivante». Cependant, je ne pense pas que ma réponse vous aidera, Bill, car vous avez probablement déjà cette compétence.

En ce qui concerne les ressources d'apprentissage, je n'en ai utilisé aucune - j'explore simplement tous les menus et options.

Est-ce même une vraie question d'un vrai programmeur?

Quiconque a passé même 5 minutes à déboguer avec des instructions d'impression et à déboguer avec IDE - cela se produira pour lui / elle sans même demander!

J'ai utilisé à la fois des impressions et des IDE pour le débogage et je préférerais de beaucoup déboguer à l'aide d'un IDE. Le seul moment pour moi où cela ne fonctionne pas, c'est dans des situations critiques (comme le débogage de jeux en ligne) où vous jongez le code avec des instructions d'impression, puis regardez les fichiers journaux après que cela a terriblement mal tourné. Ensuite, si vous ne pouvez toujours pas le comprendre, ajoutez d'autres impressions et répétez.

Je voulais juste mentionner une fonctionnalité utile d'un débogueur de console vs printf et vs debugger dans un IDE.

Vous pouvez vous attacher à une application distante (évidemment, compilée en mode DEBUG) et inspecter son état en vidant la sortie du débogueur dans un fichier à l'aide de POSIX tee utilitaire . Par rapport à printf, vous pouvez choisir l'emplacement de sortie de l'état au moment de l'exécution.

Cela m'a beaucoup aidé lorsque je déboguais des applications Adobe Flash déployées dans un environnement agressif . Il vous suffit de définir certaines actions qui affichent l'état requis dans chaque point d'arrêt, de démarrer le débogueur de console avec fdb | tee output.loget de parcourir certains points d'arrêt. Après cela, vous pouvez imprimer le journal et analyser les informations par une comparaison approfondie de l'état dans différents points d'arrêt.

Malheureusement, cette fonctionnalité [se connecter à un fichier] est rarement disponible dans les débogueurs GUI, ce qui oblige les développeurs à comparer l'état des objets dans leur tête.

Au fait, mon avis est qu'il faut planifier où et quoi déboguer avant de lancer un débogueur.

Eh bien, une autre chose est que si vous rejoignez un nouvel ancien projet et que personne ne sait vraiment comment le code fait ce qu'il fait, vous ne pouvez pas déboguer en faisant écho à des variables / objets / ... b / c vous n'avez aucune idée de ce qu'est le code exécuté du tout.

Dans mon travail, je suis confronté exactement à ce genre de situation et le XDebuging visuel m'aide à me faire une idée de ce qui se passe et où, du tout.

Meilleures salutations

Raffael

En plus des nombreuses choses qui ont déjà été mentionnées, l'un des avantages les plus importants d'un débogueur par rapport à printf est que l'utilisation des instructions printf suppose que vous savez dans quelle fonction réside le bogue. Dans de nombreux cas, vous ne le faites pas, vous devez donc faire quelques suppositions et ajouter des instructions d'impression à de nombreuses autres fonctions afin de le localiser. Le bogue peut être dans le code du framework ou quelque part loin de là où vous pensez qu'il se trouve. Dans un débogueur, il est beaucoup plus facile de définir des points d'arrêt pour examiner l'état dans différentes zones du code et à différents moments.

En outre, un débogueur décent vous permettra de faire un débogage de style printf en attachant des conditions et des actions à des points d'arrêt, de sorte que vous conserviez toujours les avantages du débogage printf, mais sans modifier le code.

Le débogage dans un IDE est inestimable dans un environnement où les journaux d'erreurs et l'accès au shell ne sont pas disponibles, comme un hôte partagé. Dans ce cas, un IDE avec un débogueur distant est le seul outil qui vous permet de faire des choses simples telles que view stderrou stdout.

Un problème avec l'utilisation des instructions d'impression est que cela gâche votre code. IE, vous avez une fonction avec 10 parties et vous savez qu'elle plante quelque part, mais vous ne savez pas où. Vous ajoutez donc 10 instructions d'impression supplémentaires pour localiser le bogue. Une fois que vous avez trouvé et résolu votre bogue, vous devez maintenant nettoyer en supprimant toutes ces instructions d'impression. Vous ferez peut-être cela. Peut-être que vous l'oublierez et cela finira en production et la console de votre utilisateur sera pleine d'impressions de débogage.

Wauw, j'aime cette question. Je n'ai jamais osé le poser ...

Il semble que les gens ont simplement des méthodes de travail différentes. Pour moi, ce qui fonctionne le mieux est:

• Avoir un modèle d'esprit solide de mon code, y compris la gestion de la mémoire
• Utiliser l'instrumentation (comme les instructions d'impression) pour suivre ce qui se passe.

Je gagne ma vie en programmation depuis plus de 40 ans maintenant, travaillant quotidiennement sur des applications techniques et scientifiques non triviales en C ++ et Python, et j'ai l'expérience personnelle qu'un débogueur ne m'aide pas du tout.

Je ne dis pas que c'est bien. Je ne dis pas que c'est mauvais. Je veux juste le partager.

Ce n'est pas seulement du débogage. Un IDE vous aide à créer de meilleurs logiciels plus rapidement de nombreuses manières:

• outils de refactoring
• intellisense pour rendre les API plus découvrables, ou pour rappeler l'orthographe exacte / la casse d'éléments familiers (pas très utile si vous avez utilisé le même système pendant 15 ans, mais c'est rare)
• économiser sur la saisie en remplissant automatiquement les noms de variables et de classes
• trouver certains types d'erreurs avant même de commencer à compiler
• Passer automatiquement aux déclarations / définitions de variable / méthode / classe, même si elles ne sont pas dans le même fichier ou dossier.
• Pause sur les exceptions non gérées et gérées

Je pourrais continuer.