Was bringt die Vermeidung eines Debuggers?

Im Laufe meiner Karriere habe ich festgestellt, dass einige Entwickler keine Debugging-Tools verwenden, aber vor Ort nach fehlerhaftem Code suchen, um herauszufinden, wo das Problem liegt.

Während es oftmals eine gute Fähigkeit ist, Fehler im Code schnell zu finden, ohne einen Debugger zu haben, scheint es weniger produktiv zu sein, viel Zeit mit der Suche nach Problemen zu verbringen, wenn ein Debugger leicht kleine Fehler wie Tippfehler finden würde.

Ist es möglich, einen Komplex ohne einen Debugger zu verwalten? Ist es ratsam? Welche Vorteile bietet die Verwendung von " psychischem Debugging "?

Was aussieht, als würde man von außen raten, entpuppt sich oft als das, was ich "Debugging in your mind" nenne. In gewisser Weise ähnelt dies der Fähigkeit der Großmeister, Schach zu spielen, ohne auf ein Schachbrett zu schauen.

Es ist bei weitem das effizienteste Debugging-Verfahren, das ich kenne, da es überhaupt keinen Debugger erfordert. Ihr Gehirn untersucht mehrere Codepfade gleichzeitig und erzielt so einen besseren Turnaround, als Sie ihn möglicherweise mit einem Debugger erzielen könnten.

Ich war mir dieser Technik nicht bewusst, bevor ich kurz in die Welt des wettbewerbsorientierten Programmierens einstieg , bei dem die Verwendung eines Debuggers kostbare Sekunden bedeutete. Nach ungefähr einem Jahr im Wettbewerb begann ich, diese Technik fast ausschließlich als meine erste Verteidigungslinie zu verwenden, gefolgt von der Debug-Protokollierung, wobei ein tatsächlicher Debugger auf dem fernen dritten Platz saß. Ein nützlicher Nebeneffekt dieser Übung war, dass ich langsamer neue Fehler hinzufügte, weil das "Debuggen in meinem Kopf" nicht aufhörte, als ich neuen Code schrieb.

Natürlich hat diese Methode ihre Grenzen, hauptsächlich aufgrund der geistigen Einschränkungen bei der Visualisierung mehrerer Pfade durch den Code. Ich habe gelernt, diese Einschränkungen meines Verstandes zu respektieren und habe mich an einen Debugger gewandt, um Fehler in fortgeschritteneren Algorithmen zu beheben.

Je mehr ich über eine Codebasis verfüge, desto weniger brauche ich einen Debugger.

Es ist ein gutes Werkzeug, um ein dynamisches Verhalten von kleiner bis mittlerer Komplexität zu verstehen, aber ich stelle oft fest, dass es mich auf die Details anstatt auf das Gesamtbild konzentriert. Und nach einer Weile liegen hier die Probleme: Interaktionen in größerem Umfang, deren dynamisches Verhalten mit anderen Tools besser verständlich ist (z. B. Protokollierung von Ein- und Ausgängen an Modulgrenzen).

Sie mögen keine schlechten Programmierer sein, aber sie sind wahrscheinlich schrecklich ineffiziente Problemlöser.

Ich neige dazu, den Ratschlägen des Debuggens zu folgen : Die 9 unabdingbaren Regeln, um selbst die schwer zu lösenden Software- und Hardwareprobleme zu finden (David Agans).

Für jede Arbeit müssen die richtigen Werkzeuge richtig eingesetzt werden. Wenn Sie einen Debugger haben, können Sie anhand dieses Debuggers sehen, was tatsächlich passiert. Die meisten Fehler werden durch Annahmen verursacht.

Ich habe mit Entwicklern zusammengearbeitet, die sich weigern, Debugger zu verwenden, weil sie es besser wussten. Die klassische Antwort, die ich einmal erhielt, war: "Der Absturz wird nicht von mir verursacht, ich habe den ganzen Tag den Code [dort, wo er abgestürzt ist] überprüft und es ist nichts falsch". (Was ist mit dem Nullwert, der von der Datenbank eingelesen wurde?) Der Chef schien zu denken, dass es eine großartige Antwort war, aber der Kunde tat es nicht.

Ich bin aus dem Team ausgestiegen, so schnell ich konnte. Ihr Ziel war es, den Job zu vereinfachen und ein einfaches 10-minütiges Problem in ein alltägliches Problem zu verwandeln.

Ihr bester Leitfaden für das Debuggen ist Steve McConnels Buch Code Complete . Kapitel 23 behandelt das Debuggen im Detail, und ich werde ein paar Punkte daraus herausarbeiten.

1. Es ist wichtig, das Problem zu verstehen, und die Verwendung des Debuggers ist kein Ersatz dafür.
2. Raten ist ein schlechter Ansatz zum Debuggen. Wenn Ihre Kollegen wirklich raten, anstatt über das Problem nachzudenken, dann machen sie einen schlechten Job. Rätselraten bedeutet, zufällige Druckaussagen in den Code zu schreiben und zu hoffen, etwas Nützliches zu finden.
3. Wenn Ihre Kollegen wirklich nicht wissen, wie man einen Debugger verwendet (anstatt ihn nicht zu verwenden), sind sie inkompetent, genau wie jemand, der die Syntax der Sprache, die sie verwenden sollen, nicht kennt.

Schwer zu erzählen. Debugging durch Erraten könnte funktionieren , wenn Sie bereits eine Vorstellung davon, was der Fehler ist (falscher Wert in einer Bibliothek - Funktion übergeben, möglicherweise ungültige SQL, etc.). Ich gebe zu, dass ich es manchmal mache, wenn der Fehler selbst klein oder offensichtlich erscheint, z. B. "Zeichenpuffer zu klein" - der Stack-Trace zeigt mir die Zeile an, auf der er fehlgeschlagen ist, und ich brauche keinen Debugger, um diesen Fehler zu beheben.

Dies die ganze Zeit zu tun kann kontraproduktiv sein und wenn die ersten "Vermutungen" fehlschlagen, ist Vermutung wahrscheinlich die falsche Strategie zur Problemlösung und es sollte ein echter Debugger aufgerufen werden. Normalerweise würde ich sagen, dass es absolut nichts Falsches an der Verwendung des Debuggers gibt .

Davon abgesehen habe ich mit Tools und Umgebungen gearbeitet, in denen es so schwierig war, den Debugger zum Laufen zu bringen, oder die so minimal und nutzlos waren, dass das Erraten leider oft ein besserer Ansatz war. Ich habe mit einigen proprietären Tools gearbeitet, die nicht einmal die richtigen Debugger hatten. Ich nehme an, es ist möglich, dass eine Person, die zu lange in solchen Umgebungen gearbeitet hat, irgendwann das Vertrauen in Debugger verliert und sich nur noch auf den Vermutungsansatz verlässt.

Ich bin überrascht, dass in der Diskussion zu diesem Thema "Unit Testing" nicht erwähnt wurde.

Da ich testgetriebene Entwicklung mache, verbringe ich nicht viel Zeit im Debugger. Vor 10 Jahren habe ich den Debugger pflichtbewusst durchlaufen:

1. Nachdem Sie ein Stück Code geschrieben haben, um sicherzustellen, dass es funktioniert und
2. Wenn ich einen Fehlerbericht erhalten habe, um zu versuchen, das Problem zu diagnostizieren

Was ich nach 10 Jahren testgetriebener Entwicklung festgestellt habe, ist, dass ich als Programmierer viel produktiver bin, wenn:

1. Ich schreibe Unit-Tests, bevor ich den Code schreibe, um sicherzustellen, dass ich ihn richtig geschrieben habe
2. Unmittelbar nach Erhalt eines Fehlerberichts schreibe ich Komponententests, um zu versuchen, das Problem zu duplizieren und einen Drilldown durchzuführen.

Es ist tausende Male schneller, dem Computer zu erlauben, den Code zu durchlaufen und das Ergebnis zu validieren, als ich denken oder durch den Code gehen kann, um die Ergebnisse mental zu validieren, und es werden keine Fehler gemacht.

Ich muss immer noch gelegentlich in den Debugger einsteigen und bin immer noch damit beschäftigt, den Code mental zu analysieren ... aber nur selten und meistens für sehr kniffligen Code.

Persönlich versuche ich, die Verwendung eines Debuggers zu minimieren, indem ich:

• Verwenden von statischen Prüfern und ähnlichen Compileroptionen, die auf mögliche Fehlerquellen hinweisen, indem Sie einfach den Code analysieren
• Schreiben Sie Code mit so wenig Nebenwirkungen wie möglich und mit der größtmöglichen Funktionalität, wobei Sie den veränderlichen Zustand nach Möglichkeit eliminieren
• Schreiben von Unit - Tests mit der minimal angemessenen Granularität
• keine Ausnahmen schlucken

Natürlich macht jeder Fehler. Selbst wenn ein Test auf diese Weise verfasst wird, kann ich den Debugger verwenden, um den Wert eines Zwischenausdrucks zu überprüfen. Wenn Sie sich jedoch an die oben genannten Grundsätze halten, ist der Fehler leichter zu lokalisieren, und das Debuggen ist kein schmerzhafter, unbestimmter Prozess.

Verwenden Sie nach Möglichkeit den Debugger. Der Debugger erkennt das Problem entweder einfach (oh, wir haben nicht nach diesem Wert gesucht) oder stellt eine Menge Kontext zur Verfügung, der bei der Analyse des relevanten Codes hilfreich ist (wow, der Stack ist total durcheinander, ich werde es tun) sei es ein Pufferüberlaufproblem).

Das Debuggen ist ein sehr nützliches Tool zum Überprüfen des Status der Objekte und Variablen in Ihrem Code zur Laufzeit.

Wie bereits in den obigen Antworten erwähnt, ist das Debuggen äußerst hilfreich, in einigen Fällen ist es jedoch begrenzt.

Nach meiner Erfahrung ist die Verwendung des Debuggers sehr nützlich, da hiermit falsche Annahmen über den Zustand meines Codes aufgedeckt werden können. Einige Leute sind nicht so schlau darin, den Code zu lesen, um einen Fehler zu finden. Daher kann das Debuggen dazu beitragen, falsche Annahmen aufzudecken, die Sie oder ein anderer Entwickler über den Status des Codes gemacht haben.

Möglicherweise erwarten Sie, dass ein Parameter bei der Übergabe an eine Methode niemals null ist. Überprüfen Sie diesen Fall also nie und fahren Sie mit der Methode fort, als wäre dieser Parameter niemals null. Die Realität ist, dass der Parameter irgendwann null wird, selbst wenn Sie als Vorbedingung für die Methode festlegen, dass der Parameter niemals null sein soll. Es wird immer passieren.

Im Gegensatz zur Nützlichkeit von Debuggern in den oben genannten Beispielen finde ich es schwierig und nicht sinnvoll, diese zu verwenden, wenn Multithreading (dh Parallelität, asynchrone Verarbeitung) involviert ist. Es kann helfen, aber es ist leicht, die Orientierung im Multithread-Nebel zu verlieren, wenn die Haltepunkte des Debuggers in einem Thread an Punkt A und in einem vollständig separaten Thread an Punkt B getroffen werden. Der Entwickler muss den neuen Haltepunkt verschieben. " Denkprozess "ganz oben auf dem" Stapel "seines Gehirns" und orientieren sich am Code am Punkt des neuen Haltepunkts. Nachdem die Relevanz von Haltepunkt B abgenommen hat, wechselt der Entwickler zurück zum ersten Haltepunkt und muss sich daran erinnern, wonach er / sie vor dem Auslösen von Haltepunkt B gesucht hat. Ich weiß, dass dies eine verwirrende Erklärung sein kann.

Auch die Unvorhersehbarkeit von gleichzeitigem Code kann den Entwickler beim Debuggen von gleichzeitigem Code weiter ablenken.

Fazit meiner ehrlichen Meinung nach:

• Debugging bei gleichzeitiger Verwendung = erhöhte Tendenz, den Fokus des "Debugging-Denkmusters" zu verlieren

und

• jederzeit = erhöhte Debugging-Produktivität, da Ihre Aufmerksamkeit nicht durch unerwartete Haltepunkte (unerwartet aufgrund der Rennbedingungen) unterbrochen wird.

Ich denke, sie sind ein bisschen zu hardcore. Wenn ich persönlich auf einen Fehler stoße, überprüfe ich den Code erneut und versuche, ihn aus der Programmlogik heraus zu finden, da mir dies manchmal dabei hilft, andere Probleme oder Nebenwirkungen leichter aufzudecken, als nur den Debbuger zu verwenden und den Fehler dort zu beheben, wo er sich manifestiert .

Selbst wenn ich denke, ich habe es geschafft, debugge ich es normalerweise, um sicherzugehen, dass ich Recht habe. Wenn das Problem etwas komplexer ist, halte ich das Debuggen für absolut notwendig.

Auch ... nur meine Meinung, aber es gibt keine Entschuldigung dafür, die Tools, die eine moderne IDE auf den Tisch bringen kann, nicht angemessen zu nutzen. Wenn es Ihnen hilft, Ihre Arbeit schneller und zuverlässiger zu erledigen, sollten Sie es verwenden.

Ich hasse es zu verallgemeinern, aber viele Programmierer, die ich getroffen habe, glauben, dass es nur einen Weg gibt, ein Problem zu lösen (ihren Weg). Es ist leicht anzunehmen, dass an jeden möglichen Test gedacht wurde. Eine andere Perspektive kann sehr wertvoll sein.

Das Programmieren durch Ausprobieren kann einige großartige neue Ansätze hervorbringen und Dinge erfassen, die andere übersehen haben.

Der Nachteil dauert in der Regel viel länger.

Ähm, es kommt auf die Person an. Persönlich benutze ich selbst weniger Debugger. Wenn ich Mikrocontroller programmiere, benutze ich im Allgemeinen LEDs oder schreibe Daten in EEPROMs, um den Code darauf zu "debuggen". Ich benutze kein JTAG.

Wenn ich Software für PCs oder Server programmiere, verwende ich in der Regel Protokollierung und viele Konsolenausgaben. Für Sprachen im C-Stil verwende ich Präprozessoranweisungen und in Java habe ich Protokollebenen verwendet.

Würden Sie sagen, dass ich etwas falsch mache, da ich keine Debugger verwende? Es ist die Aufgabe des Editors, mir zu zeigen, wo ich syntaktische Fehler habe, und wenn es einen logischen Fehler gibt, muss ich nur Tests durchführen.

Es gibt einen Unterschied zwischen dem Verzicht auf einen Debugger und dem Wissen, wie man einen Debugger verwendet (oder ablehnt). Der Debugger ist nur eines von vielen Tools, mit denen sich Fehler nachverfolgen und beheben lassen. Ich habe mit Entwicklern zusammengearbeitet, die es im Kopf rätseln können, und mit anderen, die glauben, dass sie es können.

Die beste Mischung besteht darin, Ihren Code so zu schreiben, dass er leicht über Unit-Tests getestet werden kann, und die Fehler zu protokollieren. Dann hoffen Sie, dass Sie sich die Protokolle nicht ansehen oder den Debugger verwenden müssen. Es ist wie der Kauf einer Versicherung. Sie werden es hoffentlich nie brauchen, aber sobald Sie auf einen Fehler stoßen, der nicht durch eine erneute Überprüfung des Codes behoben werden kann, ist es zu spät, eine ordnungsgemäße Fehlerbehandlung / -protokollierung, Komponententests oder den Umgang mit einem Debugger hinzuzufügen.

Unterschiedliche Tools / Plattformen bevorzugen unterschiedliche Debugging-Techniken (Debugger, Protokollierung, Komponententests usw.). Solange ein Entwickler mit einigen Techniken für seine Plattform / sein Tool vertraut ist, kann es auch sein, dass er nur den Code überprüft ein erfahrener Entwickler, aber wenn sie nur einen Trick beim Debuggen haben, werden sie irgendwann auf einen Fehler stoßen, den sie nicht finden oder beheben können.

Viele Antworten, aber keine Erwähnung von Heisenbug ?!?!

Heisenbugs treten auf, wenn häufig versucht wird, ein Programm zu debuggen, z. B. Ausgabeanweisungen einzufügen oder es in einem Debugger auszuführen. In der Regel wird der Code geändert, die Speicheradressen von Variablen werden geändert, und der Zeitpunkt der Ausführung wird geändert.

Ich benutze Debugger nur im schlimmsten Fall (für schwer zu findende Bugs). Gemäß den bewährten Methoden, über die viele anerkannte Entwickler / Tester gesprochen haben, ist es auch gut, den Code gründlich zu testen. Auf diese Weise können Sie die meisten Probleme abdecken, sodass der Debugger nicht verwendet werden muss.

Ich habe kürzlich hier ein Argument gegen Debugger-Debugging gelesen (oder war es StackOverflow?). Sie sollten Testfälle gegen Ihren Code haben. Wenn Ihre Tests erfolgreich sind, wird Ihr Debugging den Fehler wahrscheinlich nicht beheben (Annahme: Sie debuggen mit Daten, die Ihren Testdaten ähnlich sind).

Auf der anderen Seite ist die Protokollierung obligatorisch. Wenn Sie Ihre Tests bestehen und diese für die Produktion bereitstellen, ist möglicherweise ein Fehler aufgetreten. Der Beweis für den Fehler stammt von etwas, das in der Vergangenheit passiert ist. dh jemand sagt: "Wie ist das da reingekommen?" Wenn Sie keine guten Protokolle haben, werden Sie die Ursache nie finden. Selbst ein Debugger ist zu diesem Zeitpunkt möglicherweise nicht hilfreich, da Sie nicht wissen, wie die Daten aussahen, die den Fehler tatsächlich verursacht haben. Sie müssen in der Lage sein, die Anwendung über die Protokolle zu debuggen.

Leider paraphrasiere ich ziemlich viel und mache dem ursprünglichen Argument möglicherweise einen schlechten Dienst. Insbesondere könnte die Position "Es gibt wichtige Debugging-Hilfsmittel, um Entwicklungszeit für die Unterstützung zu verwenden" orthogonal zur Bedeutung von Debuggern sein. Aber der Teil über die Schwierigkeit, den Systemstatus in einer Konfiguration festzulegen, die das Debuggen zum Auffinden von Fehlern nützlich macht, schien mir ein Grund zum Nachdenken zu sein.

Mit guten Komponententests und Ausnahmen, die Ihnen die Rückverfolgung ermöglichen, müssen Sie selten einen Debugger verwenden.

Das letzte Mal, dass ich ein Debugging verwendet habe, war, als ich eine Kerndatei in einer Legacy-Anwendung erhalten habe.

Bin ich ein "Debbuger Minion" oder sind diese Typen "zu hardcore"?

Weder. Sie sind nur eine Art von Menschen, die es mögen, ihr Leben schwerer zu machen als es sein sollte.

Das Debuggen ist nur ein Werkzeug, das ein guter Entwickler kompetent einsetzen sollte.

Natürlich können Sie manchmal auswendig wissen, wo der Fehler liegen kann, wenn Sie die Codebasis kennen. Sie können aber auch einen ganzen Tag oder eine ganze Woche verlieren, um einen nervigen Fehler zu finden, indem Sie einfach den Code untersuchen.

In dynamisch getippten Sprachen ohne irgendeine Art von Debugging (auch wenn es nur darum geht, Werte auf die Konsole zu kopieren) wird das Erraten manchmal unmöglich.

Um Ihre Frage zu beantworten: Vielleicht sind sie brillante Programmierer, aber ihre Fähigkeiten zur Fehlerbehebung und ihre Kompetenz bei der Fehlersuche sind schlecht.

Hängt vom Umfang eines Problems ab. Wenn das Programm klein ist und die Dinge gut aufgeteilt sind, können Sie es wahrscheinlich herausfinden, indem Sie nachsehen. Wenn das Programm aus 4,5 Millionen Codezeilen besteht, die von einem Team von mehr als 100 Mitarbeitern über mehrere Jahre hinweg entwickelt wurden, können bestimmte Fehler nicht entdeckt werden.

Das fragliche in besagtem Programm (in C) war ein Speicherüberschreiben. Der Debugger mit einem Speicher-Haltepunkt identifizierte die fehlerhafte Codezeile, sobald der Fehler auftrat. In diesem Fall hätte jedoch niemand alle 4,5 Millionen Codezeilen lesen und beibehalten können, um die einzige Stelle zu identifizieren, die jemand hinter seinem Array geschrieben hat (außerdem müssten sie das Laufzeitlayout des Speichers für den Status des gigantischen Programms kennen etwa 10 Minuten in eine lange Reihe von Eingaben, um es zu diesem Punkt zu bringen).

Der springende Punkt: In kleinen Programmen oder Dingen, die stark modularisiert sind, können Sie ohne Debugger davonkommen. Wenn das Programm sehr umfangreich und komplex ist, kann der Debugger viel Zeit sparen. Wie andere bereits gesagt haben, handelt es sich um ein Tool, das sich in bestimmten Situationen von anderen Methoden abhebt, und bei anderen ist es nicht die beste Wahl.

Wenn der Fehler auf einem Client-Computer oder in einem Computer auftritt, dessen Umgebung sich stark von Ihrer unterscheidet, ist das Einrichten eines Debuggers / Remote-Debuggers umständlich. Für den kalten Tag, an dem Sie einen Fehler vom Feld bekommen, hilft die Antwort "aber ... ich habe keinen Debugger" nicht weiter. Daher müssen Sie eine Reihe von Fähigkeiten zur Fehlerbehebung und zum Auffinden des Fehlers entwickeln, indem Sie Code- und Protokolldateien verstehen.

Was für ein Unsinn: "Echte Programmierer brauchen keine Debugger." Könnte auch heißen, dass ein echter Programmierer keine IDE benötigt, gib mir nur einen Notizblock und einen stumpfen Stift. Der Debugger ist ein Tool wie jedes andere, das die Produktivität fördert.

Bedenken Sie außerdem, dass nicht jeder, der mit dem Debuggen von Code beauftragt ist, mit dem betreffenden Code vertraut ist. Viele Zeitunternehmer kommen in ein Umfeld, in dem sie nur ein allgemeines Ideal haben, was gerade passiert. Möglicherweise erhalten sie sogar eine detaillierte Beschreibung einer Umgebung - oder eine 20 Jahre alte Schemakarte und eine Anleitung zu arkanen Namenskonventionen (versuchen Sie, den Unterschied zwischen Tabelle X1234 und Tabelle X4312 mit den Feldern F1, F2 und F3 zu verstehen [ja, Müll wie dieser existiert], wenn Sie neu sind), aber oft ist diese Beschreibung falsch; Ansonsten, warum gibt es einen "mystery" Fehler.

Als Neueinsteiger in einer Umgebung können Sie Stunden oder Tage damit verbringen, eine große Datenbank für einen Problembereich zu "kennen", den Sie möglicherweise beheben und der dann nie wieder überprüft werden muss. Dies ist eine enorme Zeit- und Geldverschwendung. Wenn Sie Zugriff auf den Debugger haben, sehen Sie, was gerade passiert, korrigieren ihn und sind in wenigen Minuten verschwunden. All das "Sie brauchen keine Debugger" ist nur elitär.