Separate 'Debug' und 'Release' baut?

https://stackoverflow.com/questions/420343

05-07-2019
|

Frage

Ich denke, es ist besser, die Version der Software zu veröffentlichen, die Ihre Entwickler tatsächlich getestet; Ich neige dazu, also die ‚Debug‘ Ziel des Projekts / Make-Datei zu löschen, so dass es nur eine Version ist, die (und getestet, getestet und ihre Fehler, und freigegeben) gebaut werden kann.

Aus einem ähnlichen Grund, ich nicht verwenden ‚Behauptungen‘ (siehe auch Behauptungen sind immer schlecht? ...).

Eine Person behauptet es, dass der Grund für eine ‚Debug‘ -Version ist, dass es einfacher zu debuggen ist: aber ich Gegen argumentiert, dass Sie schließlich zu unterstützen und zu debuggen möchten, was auch immer es ist, Sie freigegeben, und so müssen Sie bauen eine Freigabe, die Sie bei Bedarf debug können ... diese Debug-Symbole ermöglichen bedeuten kann, und einige Optimierungen zu deaktivieren, auch in der ‚Freisetzung‘ bauen.

Jemand anderes sagte, dass „das ist so eine schlechte Idee“; es ist eine Politik, die ich vor einigen Jahren entwickelt, durch das verbrannt worden ist:

einige Tests der Entwickler ihre Debug aber nicht Release-Versionen
Einige Entwickler schreiben Bugs, die nur in der Release-Version zeigen
Das Unternehmen ist die Freigabe der Release-Version nach unzureichende Prüfung (ist es immer völlig ausreichend?)
bezeichnet zu werden auf debuggen die Release-Version

Seitdem habe ich gesehen mehr als eine andere Entwicklung Läden dieser Praxis folgen (das heißt nicht getrennten Debug hat und Release-Builds).

Was ist Ihre Politik?

Lösung

Dies könnte gering sein, aber es summiert sich zu dem, was andere hier gesagt haben. Einer der Vorteile von QA Test-Release mit aufbaut, ist, dass die eingebauten Debugging- und Protokollierungsfunktionen Ihrer Software voran aufgrund der Bedürfnisse von Entwicklern, die im Laufe der Zeit benötigen, um herauszufinden, warum die Dinge falsch laufen in QA.

Je mehr die Entwickler benötigen, um Debug-Release-Builds, die bessere Werkzeuge werden Sie später, wenn Kunden mit Fragen beginnen. Natürlich im Rahmen des Entwicklungszyklus baut kein Grund für Entwickler auf Freigabe zu arbeiten.

Auch ich kenne kein Software-Unternehmen, das lange genug Zyklen zu leisten, den Aufwand für das Schalt QA von Debug durch eine Version des Builds auf halber Strecke Testphase zu. einen vollständigen QS-Zyklus zu tun, ist etwas, das allzu oft ziemlich selten geschieht.

Andere Tipps

Mit separaten Debug- und Release-Builds ist eine gute Idee, weil es die Entwicklung einfacher macht.

Aber Debug-Builds sollte, nicht nur für die Prüfung für die Entwicklung sein. Sie testen Release nur baut. Und Sie nicht verwenden Entwickler zu testen diese Builds, Sie Tester verwenden.

Es ist eine einfache Politik, die das Beste aus beiden Welten, IMO.

Edit: In Antwort auf einen Kommentar, ich denke, es ist offensichtlich, dass Debug-und Release-Builds (können) unterschiedlichen Code generieren. Think "-DDEBUG" vs. "-DNDEBUG" und "#if defined (DEBUG)", etc.

So ist es wichtig, dass Sie den Code testen, die Sie bis Versand beenden. Wenn Sie Sie verschiedene Code im Debug erzeugen und Release-Builds, die Prüfung zweimal bedeutet -., Unabhängig davon, ob sie von derselben Person getestet ist

Debug-Symbole sind nicht so groß ein Problem, aber. Immer bauen mit Bugsymbol, eine Kopie des unstripped binären halten, aber ein Release ist eine vereinfachte binär. Solange Sie jede binäre mit einer Build-Nummer markieren, irgendwie, sollten Sie immer in der Lage sein, die unstripped binär zu identifizieren entspricht dem gestrippt binären, die Sie debuggen haben ...

Wie Binärdateien und Last Symbole in Ihrem Debugger von einer externen Quelle strippen ist plattformabhängig.

Unsere Politik ist Entwickler haben die Arbeit an Debug baut, aber alle anderen (QA, BAs, Vertrieb etc.) läuft die Release-Version. Gestern hatte ich einen Fehler zu beheben, die nur in dem Release-Build auftauchten es war offensichtlich, was einfach passiert war, weil es nur in Release auftauchte

Es ist erster hier in diesem Geschäft, und ich habe hier 18 Monate oder so.

Wo die Dinge haarig ist, wenn das Release-Build verschiedene Dinge auf den Debug-Build tut -. Ja, ich habe in der Hölle gewesen und dies in einigem sehr alten gesehen, sehr zähen Produktionscode

Ich sehe keinen Grund, warum nicht beide zu haben, wenn der einzige Unterschied zwischen den Konfigurationen sind Debug-Symbole und Optimierungen.

, so dass Sie eine Freigabe bauen müssen die Sie können, wenn nötig Debug ... diese kann bedeuten, Debug-Symbole ermöglichen, und einige Optimierungen zu deaktivieren, auch in die 'Freisetzung' zu bauen.

Ähm ... es klingt wie Sie ein Debug-Build mir antust ... nicht wahr?

Der Teil, wo Sie schief gelaufen ist diese Aussage:

Ich denke, es ist besser, das lösen Version der Software, die Ihre Entwickler tatsächlich getestet

Entwickler keinen Code testen. Tests Test-Code.

Ihre Unit-Tests testen sollte alle bauen Konfigurationen. Sie nicht Ihre Entwickler mit einer Hand machen arbeiten hinter ihrem Rücken gefesselt - lassen Sie sie alle Debugging-Tools verwenden sie dort zur Verfügung haben. Ein Debug-Build ist eine davon.

In Bezug behauptet: die Verwendung von Behauptungen hängt stark davon ab, ob Sie durch einen Vertrag programmieren. Wenn Sie das tun, dann nur Behauptungen, den Vertrag in einem Debug-Build überprüfen.

Wie pro meine Antwort im verlinkten Thread, verwenden wir auch die gleiche Build für Debug und Release für sehr ähnlichen Gründen. Die 10% bis 20% Performance-Gewinne aus dem optimiser neigen dazu, sehr gering zu sein, wenn auf manuelle Optimierungen bei Algorithmus Ebene verglichen. Ein einzelnes Build beseitigt viele potenzielle Fehler. Im Einzelnen;

Uninitialised Variablen und kleiner Pufferüberlauf können mit sehr unterschiedlichen Ergebnissen in debug am Ende und optimierte Version baut.
Auch mit den symbolischen Informationen zur Verfügung, eine optimierte Release Debuggen kann schwierig sein, wenn das Objekt nicht die Quelle übereinstimmen, z.B. Variablen optimiert geführt worden sein und Code neu angeordnet wurden. So Bugs in getesteten Release berichtet baut kann schwieriger sein, und daher zeitaufwendig ist, nach unten zu verfolgen.

Nachdem im Vergleich nicht optimiert und optimieren Builds unter automatisierten Regressionstests, hat die Leistungssteigerung durch die Optimierung zur Verfügung gestellt nicht genug Mehrwert bietet zwei in meinem Fall aufbaut. Es lohnt sich sein Hinweis darauf, dass die Software, die ich entwickeln, ist sehr CPU-hungrig (zum Beispiel die Erstellung und Bearbeitung von großen Oberflächenmodelle).

Wenn Sie mit Java zu entwickeln, ich hasse nicht-Debug-Versionen. Wenn eine Ausnahme ausgelöst wird, erhalten Sie keine Online-Informationen, die es schwer oder sogar unmöglich machen, Fehler aufzuspüren. Auch die Laufzeitdifferenz zwischen Debug- und Nicht-Debug ist um 5% mit Java 5 oder höher, so ist dies wirklich kein Problem und mit dem heutigen Festplatten, Größe spielt keine Rolle mehr.

Auf der Plusseite mit Debug-Version:

Stack-Spuren enthalten alle Informationen, die Sie benötigen
können Variablen untersucht werden
Wenn Sie ein Problem in der Produktion haben, können Sie einfach auf den laufenden Prozess anhängen, ohne den Server zu stoppen, die erste eine Debug-Version zu installieren.
Sie werden nicht durch geschickte Optimierung Fehler erwischt
Der Build ist einfacher (nur ein Artefakt)

Entwickler arbeiten mit Debug-Builds, QA und alle anderen die Release-Version verwendet, die wir als „Produktion“ nennen. Der Hauptvorteil liegt darin, dass in dem Debug-Build, wir eine Menge zusätzlicher Codes und Behauptungen hinzufügen können. Einige Objekte enthalten zusätzliche Stücke von Informationen, die keine Verwendung hat, außer wenn der Code im Debugger angezeigt wird. Einige Objekte validieren sich in regelmäßigen Abständen, um sicherzustellen, dass alle Statusinformationen konsistent ist. Diese Dinge machen die Debug-Version viel langsamer, aber sie haben uns geholfen, kein Ende der Bugs, die Hölle gewesen wäre, in der Produktion bauen zu finden.

Wie gesagt, alle unsere QA und Performance-Tests verwendet Produktion baut, und wir laufen gelegentlich Probleme, die in der Produktion zeigen, aber nicht in Debug. Aber sie sind relativ selten, und als Entwickler die Vorteile der Debuggen ein Debug-Build anstatt eine Produktions Build weit schwerer wiegen als das Problem.

Ich denke, es ist an der Projektgröße abhängt und welche Art von Build-System und Tests, die Sie verwenden.

Wenn Sie ein automatisiertes Build-System verfügen, und es ist einfach Einheit und Funktionstests an einem bestimmten Build ausführen kann, dann sollten Sie nie irgendwelche Probleme haben mit mehreren Build-Typen.

Ich habe immer abonniert das „Schiff, was Sie debuggen, so können Sie debuggen, was Sie versenden“ -Ansatz, für alle Gründe, die Sie in Ihrer Frage Liste.

Meiner Meinung nach dieser Diskussion einen sehr wichtigen Punkt fehlt:

Es hängt wirklich davon, welche Art von Projekt es ist!

Wenn Sie eine native erstellen (C / C ++) Projekt, das Sie wird in der Tat gezwungen werden Debug erstellen baut, einfach weil Compiler-Optimierungen Debuggen fast unmöglich in einigen Fällen machen kann.

Wenn Sie Web-Anwendungen erstellen Sie lieber wünschen könnten einfach ein Build haben (obwohl „Build“ ist eher irreführend für einige Web-Anwendungen), die Protokollierungsfunktionen während der Laufzeit aktivieren.

Obwohl eine native C ++ Projekt und eine PHP-Web-Anwendung sind natürlich nicht alle Arten von Projekt, das vorhanden ist, hoffe ich, mein Punkt über bekam.

P. S .: Wenn für C # entwickeln, die Sie in einen Grenzfall laufen da, obwohl ein Debug-Build mit Compiler-Optimierungen deaktiviert, in meiner Erfahrung werden Sie nicht in annähernd so viele Unterschiede wie bei C ++ ausführen

hier entwickeln wir im Debug-Modus und alle tun Unit-Tests im Release-Modus. Wir sind ein kleines Geschäft mit nur wenige (unter 12 Jahren) Anwendung von klassischen ASP, ASP.Net, VB.Net und C # zu unterstützen. Wir haben auch eine engagierte Person alle Tests zu handhaben, sind ausgetestet Probleme an die Entwickler zurückgeworfen.

Wir bauen immer beide, nicht einmal in Betracht gezogen nicht zu tun. Debug Aktivieren Optionen erhöht die Codegröße und verlangsamt die Leistung, die möglicherweise nicht ein Problem mit Ihrer Art von Software bei der Prüfung, aber was ist, wenn der Kunde den Code plus 5 andere Anwendungen läuft ...

Die Probleme mit der Prüfung kann mit automatisierten Test aussortiert werden, so dass Sie Release-Build sind mühelos getestet werden können, wenn Sie denken, dass Sie bereit sind, zu lösen. Der Ausfall Ihrer Entwickler oder Unternehmen, um richtig Test Release-Builds ist kein Fehler in der Idee von Ausfuhr und Debug baut aber in Ihrem Entwickler und oder Unternehmen.

An Ihrem letzten Punkt habe ich noch nie aufgefordert worden, ein Release-Build zu debuggen, nur um es zu beheben ...

Es ist ein Kompromiss. Da die CPU-Zyklen sind billig und immer billiger, während menschliche Zyklen teuer bleiben, ist es sehr viel Sinn macht nur eine einzige Version eines großen, komplexen Programm zu halten -. Debug (Giebel) Version

Immer mit Behauptungen immer ist eine sicherere Politik als nie mit ihnen. Wenn getrennte Debug-Produktion und Release-Versionen, wieder aktivieren, was #defined Symbole gewährleisten müssen, dass Behauptungen auch in der Release-Version aktiviert sind.

Ich glaube, der Kompromiss ist einfach: ja, nur mit einem Release-Build, die Sie wirklich testen was tatsächlich ausgeliefert. Auf der anderen Seite, haben Sie für Ihre Entwickler und / oder Leistung für den Benutzer einen Preis in einfache Debugging zahlen, so ist es an Ihnen, beide Fälle zu überprüfen.

Bei den meisten mittel- bis großen Projekte, einfacher Debugging sorgt für ein besseres Produkt für die Benutzer am Ende.

Sehen Sie diese Was Ihre umstrittenste Programmierung Meinung ist?

Zitat:

Meinung: Nie haben unterschiedliche   Code zwischen "debug" und "release"   baut

Der Hauptgrund ist, dass die Freisetzung   Code so gut wie nie wird getestet. Besser   den gleichen Code haben in Test läuft   wie es in der freien Natur ist.

das „Debug-Ziels“ Durch das Entfernen Sie Entwickler zwingen auf der Release-Version der Software zu debuggen. Was das woanders vermutlich bedeutet in der Praxis zwei Dinge:

1) "Release-Builds" wird Optimierungen deaktiviert haben (otherwised-Entwickler können nicht einen Debugger verwenden)

2) baut keine spezielle Präprozessormakros ihrer Ausführung haben zu ändern.

Also, was Sie wirklich tun wird, um die Freigabe und Debug-Konfigurationen verschmelzen, anstatt nur den „debug“ Modus eliminiert wird.

Ich habe persönlich dieses ohne negative Auswirkungen mit iOS Entwicklung getan. Die Menge an Zeit in unserem geschriebenen Code ausgegeben wird, weniger als 1% von dem, was wirklich geschieht, so dass die Optimierungen waren nicht signifikant Mitwirkenden. In diesem Fall schien sie wirklich eine Zunahme um Fehler zu verursachen, aber auch wenn sie die Idee der Prüfung eine Art und Weise nicht, tun, dann mit verschiedenen Code QA geben stellt nur einen weiteren Faktor mit Fragen zu prüfen.

Auf der anderen Seite gibt es Fälle, in denen die Optimierungen notwendig sind, wo sie nützlich sind, und auch dort, wo es genug Zeit sowohl für die Prüfung. Üblicherweise werden die Änderungen zwischen Debug- und Release sind so gering, dass es niemanden verursacht keine Probleme auf allen.

Wenn Sie eine echte QA Gruppe haben, die auf gezählt werden können, um voll und ganz die Sache zu testen, würde ich sagen, debuggen baut, bis Sie in der Nähe der Veröffentlichung, und dann stellen Sie sicher, ein vollständiger QA-Zyklus auf das getan wird gleiche Build, die Tür geht aus.

Auch wenn in mindestens einem Fall wir etwas veröffentlicht, die immer noch in ihm einige Debug-Code hatte. Die einzige Folge war es lief ein klein wenig langsamer und die Log-Dateien waren verdammt groß.

In meiner Firma haben wir beide Debug und Veröffentlichung. - Die Entwickler verwenden, um die Debug-Version richtig zu finden und Fehler zu beheben. -. Wir TDD verwenden, und so haben wir eine große Test-Suite, die wir auf unserem Server laufen, die sowohl Debug-Tests und Freigabe Konfigurationen bauen sowie 64/32 baut auch wir haben

Also, wenn mit der „debug“ Konfiguration einen Entwickler hilft, einen Fehler zu finden schneller gibt es keinen Grund, es nicht zu verwenden - wenn der Code in den Server geht (wird weiter getestet) oder prüfte wir verwenden, um die „Release“ eine .

habe ich gelernt, die Release-Version zu bauen mit PDB-Dateien schon vor langer Zeit, so dass ich die Release-Version debuggen konnte. Was viele Programmierer neigen dazu zu vergessen, dass, wenn Sie die Debug-Version laufen, wobei alle Optimierungen ausgeschaltet, Sie ein anderes Programm zusammen debuggen. Es mag wie das Release-Build verhalten (zum größten Teil), aber es ist noch ein anderes Programm als das Release-Build.

Darüber hinaus Debuggen des Release-Build ist nicht so schwierig. Und wenn Sie eine Crash-Dump erhalten, müssen Sie in der Lage sein, es trotzdem zu tun.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow