Warum ist das Debuggen in einer IDE besser? [geschlossen]

Ich bin seit über zwanzig Jahren Softwareentwickler und programmiere in C, Perl, SQL, Java, PHP, JavaScript und kürzlich in Python. Ich hatte noch nie ein Problem, das ich mit sorgfältigen Überlegungen und einem gut platzierten Debugging nicht debuggen konnteprint Anweisungen .

Ich respektiere, dass viele Leute sagen, dass meine Techniken primitiv sind und die Verwendung eines echten Debuggers in einer IDE viel besser ist. Nach meiner Beobachtung scheinen IDE-Benutzer mit meinen Steinmessern und Bärenfellen nicht schneller oder erfolgreicher zu debuggen als ich. Ich bin aufrichtig offen für das Erlernen der richtigen Tools. Ich habe noch nie einen überzeugenden Vorteil bei der Verwendung von visuellen Debuggern gesehen.

Darüber hinaus habe ich noch nie ein Tutorial oder Buch gelesen, in dem gezeigt wurde, wie man mit einer IDE effektiv debuggt, abgesehen von den Grundlagen zum Festlegen von Haltepunkten und zum Anzeigen des Inhalts von Variablen.

Was vermisse ich? Was macht IDE-Debugging-Tools so viel effektiver als die sorgfältige Verwendung von Diagnoseanweisungen print?

Können Sie Ressourcen (Tutorials, Bücher, Screencasts) vorschlagen, die die feineren Techniken des IDE-Debuggens zeigen?

Süße Antworten! Vielen Dank an alle, die sich die Zeit genommen haben. Sehr aufschlussreich. Ich habe viele hoch und keine runter gestimmt.

Einige bemerkenswerte Punkte:

• Debugger können mir helfen, Variablen, Code oder andere Aspekte der Laufzeitumgebung ad hoc zu überprüfen oder zu ändern, während ich beim manuellen Debuggen die Anwendung stoppen, bearbeiten und erneut ausführen muss (möglicherweise muss sie neu kompiliert werden).
• Debugger können eine Verbindung zu einem laufenden Prozess herstellen oder einen Absturzspeicherauszug verwenden, während beim manuellen Debuggen "Schritte zur Reproduktion" eines Fehlers erforderlich sind.
• Debugger können komplexe Datenstrukturen, Multithread-Umgebungen oder vollständige Laufzeitstapel einfach und besser lesbar anzeigen.
• Debugger bieten viele Möglichkeiten, um die Zeit und die sich wiederholende Arbeit für fast alle Debugging-Aufgaben zu reduzieren.
• Visuelle Debugger und Konsolen-Debugger sind beide nützlich und haben viele Funktionen gemeinsam.
• Ein in eine IDE integrierter visueller Debugger bietet Ihnen außerdem bequemen Zugriff auf die intelligente Bearbeitung und alle anderen Funktionen der IDE in einer einzigen integrierten Entwicklungsumgebung (daher der Name).

Einige Beispiele für einige Fähigkeiten, die Ihnen ein IDE-Debugger über Ablaufverfolgungsnachrichten im Code bietet:

• Zeigen Sie den Aufrufstapel zu jedem Zeitpunkt an und geben Sie einen Kontext für Ihren aktuellen Stapelrahmen an.
• Betreten Sie Bibliotheken , die Sie zum Hinzufügen von Traces nicht neu kompilieren können (vorausgesetzt, Sie haben Zugriff auf die Debug-Symbole).
• Ändern Sie die Variablenwerte, während das Programm ausgeführt wird
• Bearbeiten und fortfahren - die Möglichkeit, Code während der Ausführung zu ändern und sofort die Ergebnisse der Änderung anzuzeigen
• Sie können Variablen beobachten und sehen, wann sie sich ändern
• Sie können Codeabschnitte überspringen oder wiederholen , um zu sehen, wie der Code funktioniert. Auf diese Weise können Sie theoretische Änderungen testen, bevor Sie sie vornehmen.
• Untersuchen Sie den Speicherinhalt in Echtzeit
• Benachrichtigen Sie, wenn bestimmte Ausnahmen ausgelöst werden, auch wenn sie von der Anwendung behandelt werden.
• Bedingte Haltepunkte ; Beenden der Anwendung nur in Ausnahmefällen, damit Sie den Stapel und die Variablen analysieren können.
• Zeigen Sie den Thread-Kontext in Multithread-Anwendungen an, was mit der Ablaufverfolgung schwierig zu erreichen sein kann (da die Ablaufverfolgungen von verschiedenen Threads in der Ausgabe verschachtelt werden).

Zusammenfassend sind Druckanweisungen (im Allgemeinen) statisch und Sie müssen sie neu kompilieren, um zusätzliche Informationen zu erhalten, wenn Ihre ursprünglichen Anweisungen nicht detailliert genug waren. Die IDE beseitigt diese statische Barriere und bietet Ihnen ein dynamisches Toolkit zur Hand.

Als ich anfing zu programmieren, konnte ich nicht verstehen, was die große Sache mit Debuggern war, und ich dachte, ich könnte mit Tracing alles erreichen (zugegeben, das war unter Unix und der Debugger war GDB). Sobald Sie jedoch gelernt haben, wie Sie einen grafischen Debugger richtig verwenden, möchten Sie nicht mehr zum Drucken von Anweisungen zurückkehren.

• Mit einem IDE-Debugger können Sie die Werte von Variablen zur Laufzeit ändern.

• Mit einem IDE-Debugger können Sie den Wert von Variablen anzeigen, von denen Sie nicht wussten, dass Sie sie zu Beginn der Ausführung sehen wollten.

• Mit einem IDE-Debugger können Sie den Aufrufstapel anzeigen und den Status der Funktion überprüfen, die seltsame Werte übergeben hat. (Denken Sie, diese Funktion wird von Hunderten von Orten aufgerufen. Sie wissen nicht, woher diese seltsamen Werte kommen.)

• Mit einem IDE-Debugger können Sie die Ausführung an jedem Punkt im Code bedingt unterbrechen, basierend auf einer Bedingung, nicht einer Zeilennummer.

• Mit einem IDE-Debugger können Sie den Status des Programms im Falle einer nicht behandelten Ausnahme überprüfen, anstatt nur zu scheißen.

Hier ist eine Sache, die Sie mit der Anweisung "print" definitiv nicht debuggen können. Wenn ein Kunde Ihnen einen Speicherauszug bringt und sagt: "Ihr Programm ist abgestürzt, können Sie mir sagen, warum?"

• Das Drucken von Anweisungen im gesamten Code verringert die Lesbarkeit.
• Das Hinzufügen und Entfernen nur zu Debug-Zwecken ist zeitaufwändig
• Debugger verfolgen den Aufrufstapel, sodass Sie leicht erkennen können, wo Sie sich befinden
• Variablen können im laufenden Betrieb geändert werden
• Ad-hoc-Befehle können während einer Ausführungspause ausgeführt werden, um die Diagnose zu erleichtern
• Kann in Verbindung mit print-Anweisungen verwendet werden: Debug.Write ("...")

Ich denke, das Debuggen mit print-Anweisungen ist eine verlorene Kunst und für jeden Entwickler sehr wichtig zu lernen. Sobald Sie wissen, wie das geht, lassen sich bestimmte Fehlerklassen auf diese Weise viel einfacher debuggen als über eine IDE. Programmierer, die diese Technik kennen, haben auch ein gutes Gefühl dafür, welche nützlichen Informationen in eine Protokollnachricht eingefügt werden müssen (ganz zu schweigen davon, dass Sie das Protokoll tatsächlich lesen werden), und zwar auch für Nicht-Debugging-Zwecke.

Das heißt, Sie sollten wirklich wissen, wie man den Step-Through-Debugger verwendet, da es für eine andere Klasse von Fehlern viel einfacher ist. Ich überlasse es den anderen ausgezeichneten Antworten, die bereits veröffentlicht wurden, um zu erklären, warum :)

Aus dem Kopf:

1. Debuggen komplexer Objekte - Mit Debuggern können Sie tief in die Innereien eines Objekts eindringen. Wenn Ihr Objekt beispielsweise über ein Array komplexer Objekte verfügt, werden Sie mit print-Anweisungen nur so weit gebracht.
2. Die Möglichkeit, Code zu überschreiten - Mit Debuggern können Sie auch Code überspringen, den Sie nicht ausführen möchten. Sie können dies zwar auch manuell tun, aber es ist so viel mehr Code, den Sie einfügen müssen.

Als Alternative zum Debuggen in IDE können Sie die großartige Google Chrome-Erweiterung PHP Console mit einer PHP-Bibliothek ausprobieren, die Folgendes ermöglicht:

• Siehe Fehler und Ausnahmen in der Chrome JavaScript-Konsole und in Benachrichtigungs-Popups.
• Dump eine beliebige Typvariable.
• Führen Sie PHP-Code remote aus.
• Schützen Sie den Zugriff mit einem Passwort.
• Gruppieren Sie Konsolenprotokolle auf Anfrage.
• Zur Fehlerdatei springen: Zeile in Ihrem Texteditor.
• Kopieren Sie Fehler- / Debug-Daten in die Zwischenablage (für Tester).

Ich habe seit fast 20 Jahren nicht mehr entwickelt, aber ich finde, dass ich mit einem IDE / Debugger:

• Sehen Sie alle möglichen Dinge, von denen ich vielleicht nicht gedacht hätte, dass sie in einer Druckerklärung enthalten sind
• Gehen Sie den Code durch, um zu sehen, ob er mit dem Pfad übereinstimmt, den ich erwartet hatte
• Setzen Sie Variablen auf bestimmte Werte, damit der Code bestimmte Zweige annimmt

Ein Grund für die Verwendung der IDE könnte sein, dass moderne IDEs mehr als nur einfache Haltepunkte unterstützen. Beispielsweise bietet Visual Studio die folgenden erweiterten Debugging-Funktionen:

• Definieren Sie bedingte Haltepunkte (Unterbrechung nur, wenn eine Bedingung erfüllt ist, oder nur beim n-ten Mal, wenn die Anweisung am Haltepunkt ausgeführt wird)
• Unterbrechen Sie eine nicht behandelte Ausnahme oder wann immer eine (bestimmte) Ausnahme ausgelöst werden soll
• Variable beim Debuggen ändern
• Wiederholen eines Codeteils durch Setzen der nächsten auszuführenden Zeile
• etc.

Wenn Sie den Debugger verwenden, müssen Sie nach dem Debuggen nicht alle Druckanweisungen entfernen.

Eine Sache, die mich überrascht, dass ich sie in keiner anderen Antwort gesehen habe, ist, dass sich die beiden Debugging-Methoden nicht gegenseitig ausschließen .

printfDas Debuggen kann sehr gut funktionieren, selbst wenn Sie einen Standard-Debugger verwenden (ob IDE-basiert oder nicht). Insbesondere mit einem Protokollierungsframework, sodass Sie das gesamte oder den größten Teil des freigegebenen Produkts belassen können, um bei der Diagnose von Kundenproblemen zu helfen.

Wie in so ziemlich allen anderen Antworten hier erwähnt, ist das Schöne an einem Standard-Debugger, dass Sie damit die Details des Programmstatus einfacher untersuchen (und möglicherweise ändern) können. Sie müssen nicht im Voraus wissen, was Sie sich ansehen möchten - alles steht Ihnen zur Verfügung (mehr oder weniger).

Nach meiner Erfahrung haben einfache Ausdrucke einen großen Vorteil, den niemand zu erwähnen scheint.

Das Problem mit einem IDE-Debugger ist, dass alles in Echtzeit geschieht. Sie stoppen das Programm zu einer bestimmten Zeit, gehen dann die Schritte nacheinander durch und es ist unmöglich, zurück zu gehen, wenn Sie plötzlich sehen möchten, was vorher passiert ist. Dies steht im Widerspruch zu der Funktionsweise unseres Gehirns. Das Gehirn sammelt Informationen und bildet allmählich eine Opposition. Möglicherweise müssen Sie die Ereignisse dabei mehrmals wiederholen. Wenn Sie jedoch einen bestimmten Punkt überschritten haben, können Sie nicht mehr zurückkehren.

Im Gegensatz dazu erhalten Sie mit einer ausgewählten Reihe von Ausdrucken / Protokollierungen eine "räumliche Projektion der zeitlichen Ereignisse". Es gibt Ihnen eine vollständige Geschichte darüber, was passiert ist, und Sie können ganz einfach mehrmals ganz einfach zurück und viert gehen, indem Sie einfach auf und ab scrollen. Es macht es einfach, Fragen wie "Ist A aufgetreten, bevor B passiert ist" zu beantworten. Es kann Sie Muster sehen lassen, nach denen Sie nicht einmal gesucht haben.

Also meiner Erfahrung nach. IDE und Debugger sind fantastische Tools, um einfache Probleme zu lösen, wenn in einem einzelnen Aufrufstapel ein Fehler aufgetreten ist, und um den aktuellen Status des Computers bei einem bestimmten Absturz zu untersuchen.

Wenn wir uns jedoch schwierigeren Problemen nähern, bei denen es zu einem allmählichen Zustandswechsel kommt. Wo zum Beispiel ein Algorithmus eine Datenstruktur beschädigte, führte dies wiederum dazu, dass ein anderer Algorithmus fehlschlug. Oder wenn wir Fragen wie "Wie oft passiert das?" Beantworten möchten, "Geschehen die Dinge in der Reihenfolge und in der Art und Weise, wie ich sie mir vorstelle". usw. Dann hat die "alte modische" Protokollierungs- / Ausdruckstechnik einen klaren Vorteil.

Am besten verwenden Sie eine der beiden Techniken, wenn sie am besten geeignet ist. Verwenden Sie beispielsweise Protokollierung / Ausdrucke, um einige Fehler zu beheben, und halten Sie an einem Haltepunkt an, an dem wir den aktuellen Status genauer untersuchen müssen.

Es gibt auch hybride Ansätze. Wenn Sie beispielsweise console.log (Objekt) ausführen, erhalten Sie ein Datenstruktur-Widget im Protokoll, das Sie erweitern und genauer untersuchen können. Dies ist oft ein klarer Vorteil gegenüber einem "toten" Textprotokoll.

Weil das Debuggen von Multithread-Anwendungen mit Druckanweisungen zu Bananen führt. Ja, Sie können dies immer noch mit print-Anweisungen tun, aber Sie würden viele davon benötigen, und das Auflösen des sequentiellen Ausdrucks von Anweisungen zum Emulieren der Multithread-Ausführung würde lange dauern.

Das menschliche Gehirn ist leider nur einfädig.

Da Sie nach Hinweisen auf Bücher gefragt haben ... Was das Windows-Debugging betrifft, hat John Robbins mehrere Ausgaben eines guten Buches zum Windows-Debugging:

Debuggen von Anwendungen für Microsoft .NET und Microsoft Windows

Beachten Sie, dass die neueste Ausgabe ( Debuggen von Microsoft .NET 2.0-Anwendungen ) nur .NET ist. Wenn Sie natives Code-Debuggen wünschen (es deckt sowohl .NET als auch native ab), möchten Sie möglicherweise eine ältere (wie im ersten Link).

Ich persönlich bin der Meinung, dass die Antwort so einfach ist wie "Ein integrierter Debugger / eine integrierte IDE bietet Ihnen schnell eine Fülle verschiedener Informationen, ohne dass Sie Befehle eingeben müssen. Die Informationen sind in der Regel vor Ihnen vorhanden, ohne dass Sie ihnen gesagt haben, was sie tun sollen." zeig es dir.

Die Leichtigkeit, mit der die Informationen abgerufen werden können, macht sie besser als nur das Debuggen in der Befehlszeile oder das Debuggen von "printf".

Vorteile eines Debuggers gegenüber einem printf ( beachten Sie nicht einen IDE-Debugger, sondern einen Debugger )

1. Kann Überwachungspunkte setzen. Dies ist eine meiner Lieblingsmethoden, um Speicherbeschädigungen zu finden

2. Kann eine Binärdatei debuggen, die Sie derzeit nicht neu kompilieren können

3. Kann eine Binärdatei debuggen, deren Neukompilierung lange dauert

4. Kann Variablen im laufenden Betrieb ändern

5. Kann Funktionen im laufenden Betrieb aufrufen

6. Hat nicht das Problem, dass Debug-Statemenets nicht gelöscht werden und daher das Timing-Problem nicht genau debuggt werden kann

7. Debugger helfen bei Core-Dumps, Print-Anweisungen nicht

Folgendes verwende ich am häufigsten in VS.NET-Debugging-Fenstern:

• Call Stack, mit dem Sie auch den Code eines anderen herausfinden können
• Einheimische & Uhren.
• Sofortiges Fenster, das im Grunde eine C # -Konsole ist und in dem ich auch variable Inhalte ändern, Inhalte initialisieren usw. kann.
• Wenn Sie eine Zeile überspringen können, legen Sie die nächste Anweisung fest, die an einer anderen Stelle ausgeführt werden soll.
• Die Fähigkeit, über Variablen zu schweben und einen Tooltip zu haben, der mir ihre Werte zeigt.

Zusammenfassend gibt es mir eine 360-Grad-Ansicht des Status meines ausführenden Codes, nicht nur ein kleines Fenster.

Ich habe noch nie ein Buch gefunden, in dem solche Dinge gelehrt werden, aber andererseits scheint es ziemlich einfach zu sein, es ist ziemlich WYSIWYG.

• Ein Debugger kann eine Verbindung zu einem laufenden Prozess herstellen

• Oft ist es einfacher, Thread-Code von einem Debugger zu debuggen

Mit einem IDE-Debugger können Sie die Werte ALLER Variablen im aktuellen Bereich (bis zum Aufrufstapel) anzeigen, wenn Sie die Ausführung anhalten.

Druckanweisungen können großartig sein, aber wenn so viele Informationen an einem bestimmten Ort auf den Bildschirm gestellt werden, kann dies zu einem Ganzen führen Menge Druckanweisungen.

Außerdem können Sie in vielen IDE-Debuggern Methoden eingeben und auswerten sowie Mitglieder auswerten, während Sie angehalten sind, was die Anzahl der zu druckenden Druckanweisungen weiter erhöht.

Ich bin jedoch der Meinung, dass Debugger für einige Sprachen besser sind als für andere ...

Meine allgemeine Meinung ist, dass IDE-Debugger für verwaltete Sprachen wie Java oder C # absolut erstaunlich gut sind, für C ++ ziemlich nützlich sind und für Skriptsprachen wie Python nicht sehr nützlich sind (aber es könnte sein, dass ich einfach kein gutes ausprobiert habe Debugger für alle Skriptsprachen noch).

Ich liebe den Debugger in IntelliJ IDEA, wenn ich Java entwickle. Ich verwende nur print-Anweisungen, wenn ich Python verwende.

Wie oben gesagt: Debugger! = IDE.

gdb und (früher) TurboDebugger (eigenständig) funktionieren gut für die Sprachen, die sie unterstützen [ed], danke. (oder eine noch ältere Technologie: Clipper-Debugger, der mit der ausführbaren xBase-Datei selbst verknüpft ist) - Für keine dieser Technologien ist eine IDE erforderlich

Auch wenn C / ++ - Codierung seltener ist, maskieren printf-Anweisungen manchmal genau den Fehler, den Sie suchen! (Initialisierungsprobleme beispielsweise bei automatischen Variablen auf dem Stapel oder Speicherzuweisung / -ausrichtung)

Schließlich können Sie, wie bereits erwähnt, beide verwenden. Einige Echtzeitprobleme erfordern fast einen Ausdruck oder zumindest ein vernünftiges "* video_dbg = (is_good? '+': '-');" irgendwo in den Videospeicher. Mein Alter zeigt, das war unter DOS :-)

TMTOWTDI

Zusätzlich zu vielem, was die anderen Poster gesagt haben, gehe ich sehr gerne zusammen mit dem Computer durch eine Zeile, da ich gezwungen bin, über jeweils eine Zeile nachzudenken. Oft werde ich den Fehler abfangen, ohne auch nur variable Werte zu betrachten, nur weil ich gezwungen bin, ihn zu betrachten, wenn ich auf die Schaltfläche "Nächste Zeile" klicke. Ich glaube jedoch nicht, dass meine Antwort Ihnen helfen wird, Bill, weil Sie diese Fähigkeit wahrscheinlich bereits haben.

Was die Lernressourcen angeht, habe ich keine verwendet - ich erkunde nur alle Menüs und Optionen.

Ist das überhaupt eine echte Frage von einem echten Programmierer?

Jeder, der sogar 5 Minuten mit dem Debuggen mit Druckanweisungen und dem Debuggen mit IDE verbracht hat - es wird ihm / ihr passieren, ohne zu fragen!

Ich habe sowohl Drucke als auch IDEs zum Debuggen verwendet und würde viel lieber mit einer IDE debuggen. Die einzige Zeit für mich, in der dies nicht funktioniert, sind zeitkritische Situationen (wie das Debuggen von Online-Spielen), in denen Sie den Code mit Druckanweisungen verunreinigen und dann die Protokolldateien anzeigen, nachdem sie schrecklich schief gelaufen sind. Wenn Sie es dann immer noch nicht herausfinden können, fügen Sie weitere Ausdrucke hinzu und wiederholen Sie den Vorgang.

Ich wollte nur eine nützliche Funktion eines Konsolen-Debuggers gegen printf und gegen den Debugger in einer IDE erwähnen.

Sie können eine Verbindung zu einer Remoteanwendung herstellen (offensichtlich im DEBUG-Modus kompiliert) und deren Status überprüfen, indem Sie die Debugger-Ausgabe mit dem POSIX- teeDienstprogramm in eine Datei sichern . Im Vergleich zu printf können Sie auswählen, wo der Status zur Laufzeit ausgegeben werden soll.

Es hat mir sehr geholfen, als ich Adobe Flash-Anwendungen debuggte, die in einer aggressiven Umgebung bereitgestellt wurden . Sie müssen nur einige Aktionen definieren, die den erforderlichen Status in jedem Haltepunkt drucken, den Konsolen-Debugger mit starten fdb | tee output.logund einige Haltepunkte durchlaufen. Danach können Sie das Protokoll drucken und die Informationen analysieren, indem Sie den Status an verschiedenen Haltepunkten gründlich vergleichen.

Leider ist diese Funktion [Protokollierung in einer Datei] in GUI-Debuggern selten verfügbar, sodass Entwickler den Status von Objekten in ihrem Kopf vergleichen können.

Übrigens ist meine Meinung, dass man planen sollte, wo und was zu debuggen ist, bevor man einen Debugger anstarrt.

Eine andere Sache ist, dass Sie keine Ahnung haben, was Code ist, wenn Sie einem neuen alten Projekt beitreten und niemand wirklich weiß, wie der Code das tut, was er tut überhaupt ausgeführt.

Bei meiner Arbeit bin ich mit genau dieser Situation konfrontiert, und visuelles XDebuging hilft mir, eine Vorstellung davon zu bekommen, was überhaupt vor sich geht und wo.

Freundliche Grüße

Raffael

Neben den vielen bereits erwähnten Dingen besteht einer der wichtigsten Vorteile eines Debuggers gegenüber printf darin, dass bei der Verwendung von printf-Anweisungen davon ausgegangen wird, dass Sie wissen, in welcher Funktion sich der Fehler befindet. In vielen Fällen ist dies nicht der Fall, daher müssen Sie einige Vermutungen anstellen und print-Anweisungen zu vielen anderen Funktionen hinzufügen, um sie zu lokalisieren. Der Fehler kann im Framework-Code oder an einem Ort liegen, von dem Sie glauben, dass er sich befindet. In einem Debugger ist es viel einfacher, Haltepunkte festzulegen, um den Status in verschiedenen Bereichen des Codes und zu verschiedenen Zeitpunkten zu untersuchen.

Mit einem anständigen Debugger können Sie auch das Debuggen im Printf-Stil durchführen, indem Sie Bedingungen und Aktionen an Haltepunkte anhängen, sodass Sie die Vorteile des Printf-Debuggens beibehalten, ohne den Code zu ändern.

Das Debuggen in einer IDE ist in einer Umgebung von unschätzbarem Wert, in der Fehlerprotokolle und Shell-Zugriff nicht verfügbar sind, z. B. auf einem gemeinsam genutzten Host. In diesem Fall ist eine IDE mit einem Remote-Debugger das einzige Tool, mit dem Sie einfache Dinge wie Ansicht stderroder ausführen können stdout.

Ein Problem bei der Verwendung von print-Anweisungen besteht darin, dass Ihr Code durcheinander gebracht wird. IE, Sie haben eine Funktion mit 10 Teilen und Sie wissen, dass sie irgendwo abstürzt, aber Sie sind sich nicht sicher, wo. Sie fügen also 10 zusätzliche Druckanweisungen hinzu, um festzustellen, wo der Fehler liegt. Sobald Sie Ihren Fehler gefunden und behoben haben, müssen Sie ihn bereinigen, indem Sie alle diese Druckanweisungen entfernen. Vielleicht machst du das. Vielleicht werden Sie es vergessen und es wird in der Produktion landen und die Konsole Ihres Benutzers wird voller Debug-Drucke sein.

Wauw, mag ich diese Frage? Ich habe es nie gewagt, es zu posieren ...

Es scheint, dass die Menschen nur unterschiedliche Arbeitsweisen haben. Für mich funktioniert am besten:

• Ich habe ein solides Modell meines Codes, einschließlich Speicherverwaltung
• Verwenden von Instrumenten (wie Druckanweisungen), um zu verfolgen, was passiert.

Ich habe meinen Lebensunterhalt mit Programmierung seit über 40 Jahren verdient und arbeite täglich an nicht trivialen technischen und wissenschaftlichen Anwendungen in C ++ und Python. Ich habe die persönliche Erfahrung, dass mir ein Debugger kein bisschen hilft.

Ich sage nicht, dass das gut ist. Ich sage nicht, dass das schlecht ist. Ich möchte es nur teilen.

Es geht nicht nur um das Debuggen. Mit einer IDE können Sie auf vielfältige Weise schneller bessere Software erstellen:

• Refactoring-Tools
• Intellisense, um APIs besser auffindbar zu machen oder an die genaue Schreibweise / den Fall vertrauter Elemente zu erinnern (nicht viel zu gebrauchen, wenn Sie 15 Jahre lang dasselbe System verwendet haben, aber das ist selten)
• Sparen Sie bei der Eingabe, indem Sie Variablen- und Klassennamen automatisch vervollständigen
• Finden Sie bestimmte Arten von Fehlern, bevor Sie überhaupt mit dem Kompilieren beginnen
• Wechseln Sie automatisch zu Variablen- / Methoden- / Klassendeklarationen / -definitionen, auch wenn sie sich nicht in derselben Datei oder demselben Ordner befinden.
• Brechen Sie unbehandelte und behandelte Ausnahmen ab

Ich könnte weitermachen