Einfache Möglichkeiten zur Verbesserung der Release-Qualität in einer RAD-Umgebung

Ein bisschen Hintergrundwissen - wir sind ein kleines Team von 5 RAD-Entwicklern, die für die interne Softwareentwicklung in einem großen Nicht-Software-Unternehmen verantwortlich sind. "Interne Software" unterscheidet sich von einer Desktop-.NET-Anwendung, die MSSQL-Server als Backend für Python-Skripte verwendet, die im Hintergrund für MS Word-Dokumente und -Vorlagen ausgeführt werden - ein Zoo von Technologien.

Das gesamte Team besteht aus Allroundern, die in der Lage sind, die Anforderungen der Benutzer zu erfassen, zu codieren, zu testen und in der Produktion einzusetzen. Sobald die Software in der Produktion ist, wird sie von einem anderen Team betreut, aber es fällt uns normalerweise leicht, einzugreifen, wenn etwas schief geht.

Bisher klingt alles gut, aber es gibt ein Problem: Wir müssen ein RAD-Team häufig freigeben, und es vergeht kein Tag, an dem wir neue Versionen von ein oder zwei Anwendungen freigeben (oder es könnte sich um ein Skript oder ein aktualisiertes Word-Dokument handeln) , C ++ - Konsolen-App usw.) in die Produktion ein. Wir führen Entwicklungstests durch und beziehen Endbenutzer mit ein, indem sie die Software in einer UAT-Umgebung ausführen lassen ...

... aber die Bugs schleichen sich trotzdem in die Produktion ein. Die Benutzer verstehen, dass diese Fehler und die gelegentliche Instabilität der Preis sind, den sie dafür zahlen, dass sie wirklich schnell das bekommen, was sie wollen, aber gleichzeitig haben wir darüber nachgedacht - vielleicht könnten wir unsere Entwicklungs- oder Veröffentlichungspraktiken verbessern, um die Stabilität des zu verbessern Software und reduzieren Sie die Anzahl der Fehler, die wir beim Hinzufügen einer neuen Funktionalität einführen.

Das Gute ist, dass wir nicht wirklich viel von den Prozessen haben, daher sollte es einfach sein, mit der Verbesserung zu beginnen. Das Schlechte ist, dass wir als kleines RAD-Team nicht wirklich viel Zeit und Ressourcen haben, um sie umzusetzen etwas Großes, aber wir haben über die folgenden Initiativen nachgedacht und würden uns über Feedback, Tipps, Hinweise und Vorschläge freuen.

1. Gegenwärtig werden einige der Anwendungen direkt nach dem Entwicklertest in die Produktion freigegeben, wobei der Benutzerakzeptanztest umgangen wird. Diese Praxis sollte eingestellt werden und selbst eine kleine Änderung muss von einem Endbenutzer getestet werden. Jede Anwendung verfügt über einen speziellen Beta-Tester, der von den Endbenutzern ausgewählt wird. Erst nachdem ein Beta-Tester die neue Version freigegeben hat, wird sie vom Test in die Produktionsumgebung befördert.

2. Wir führen keine Codeüberprüfungen durch, aber wir werden Codeüberprüfungen durchführen, bevor einer von uns den Änderungssatz eincheckt. Ich habe auch über eine "Rollout-Überprüfung" nachgedacht - im Grunde muss einer der Entwickler neben dem anderen sitzen und zusehen, wie er / sie das Software-Rollout durchführt (Binärdateien kopieren, Konfigurationen aktualisieren, neue Tabelle zur Datenbank hinzufügen usw.) - normalerweise nur Dauert 5-10 Minuten, so dass eine "Rollout-Überprüfung" nicht viel Zeit in Anspruch nimmt.

3. So verkürzen Sie die Rollback-Zeit, wenn sich herausstellt, dass eine neue Version fehlerhaft genug ist, um aus der Produktion genommen zu werden und durch eine gute frühere Version ersetzt zu werden. Wir speichern eine Historie aller Releases (als Binärdateien), um es einfach zu machen, eine Version zurück zu gehen - und obwohl es schnell geht, "neu veröffentlichte Binärdateien mit Binärdateien einer früheren Version zu überschreiben", ist es immer noch ein manueller Prozess, der fehleranfällig ist und manchmal fordernd "was ist, wenn der Rollback fehlschlägt und das System unbrauchbar anstatt fehlerhaft macht".

Hier sind uns die Ideen ausgegangen und wir würden gerne Ihr Feedback dazu erhalten. Wenn Sie uns einige einfache Tipps zur Verbesserung von Release- und Entwicklungsprozessen geben könnten, wäre das großartig.

+1 für das Ansprechen eines großartigen Themas. Wenn wir die Entwicklungslinie "Frühes Release häufig veröffentlichen" durchführen, beschleunigen sich die Dinge erheblich, und da die Dynamik zunimmt, treten viele solche Probleme auf (wie Sie beschrieben haben), auf die wir ansonsten nicht sehr vorbereitet sind. Die schlimmste Angst ist, wenn die Menschen Geschwindigkeit als Feind guter Arbeit ansehen.

Ich habe diesbezüglich nur eine sehr begrenzte Literatur gesehen, dies ist jedoch das, was wir üben, was definitiv hilft:

1. Effektives Bug-Tracking
Machen Sie das Bug-Tracking effektiver - wir führen nicht nur eine Liste mit Bugs und Häkchen, sondern müssen beim Schließen bestimmte Dinge definieren wie "Waren die Probleme reproduzierbar?". "Ist dies eine dauerhafte Lösung?" oder Arbeit beheben? "," Was ist die Hauptursache "von Problemen? Dies ermöglicht die Kenntnis darüber, was passiert ist, als dieser Fehler das letzte Mal sichtbar war. Dies ist der Schlüssel, um sicherzustellen, dass Fehler nicht oft wiederholt werden.

2. Definieren der wichtigsten Fallback-Punkte
Wir alle wissen, dass Fehler auftreten werden, daher müssen wir ein effektives Fallback bereitstellen, das am häufigsten funktioniert. Immer wieder stellen wir (in unserem Fall mit einem Verhältnis von etwa 1 zu 10) eine häufigste Version fertig, die überall auf zuverlässigste Weise funktioniert. Die Gesamtzahl der Veröffentlichungen kann sehr hoch sein, aber wenn etwas schief geht, werden nur wenige Ausweichversionen ausgewählt, und Sie müssen nicht weiter darauf zurückgreifen. Eine der einfachsten Methoden, um den besten Fallback zu ermitteln, besteht darin, die früheste Version zu ermitteln, die in der Produktion am längsten ohne große Probleme ausgeführt wurde.

3. Unterscheiden Sie zwischen riskanten und stabilen Releases oder Releases mit kleinen Fehlerkorrekturen.
Wenn wir wissen, dass sich ein großer Algorithmus ändert, besteht eine höhere Wahrscheinlichkeit, dass sich Fehler in Szenarien einschleichen, die nicht alle vorgesehen sind. Wo, wie es Zeiten gibt, in denen Probleme sehr klein (oder gut verstanden) sind und nur ein geringes Risiko besteht. Do NOT Club eine solche Funktionalität und einfache Fehler in gleichen Versionen. Habe immer zuerst einen kleineren Fehler behoben, der überall hingehen muss. Machen Sie dedizierte Releases für spezielle Funktionssätze, bestenfalls können Sie diese Funktion verwerfen, aber alle anderen wichtigen Fehler sind noch in früheren Releases behoben.

4. Verzweigung für signifikante Feature-Entwicklung
Alle Änderungen, die Auswirkungen auf das Design haben, müssen in einer Verzweigung separat vorgenommen werden. Größere Entwicklungen werden im Vergleich zu kleineren Fehlern nicht schnell abgeschlossen. Wenn wir Intermediate-Commits einführen, bei denen "Teil" -Aufgaben im Zusammenhang mit Funktionen, die noch nicht verwendet werden, eine potenzielle Region für die Einführung von Fehlern darstellen. Die Fehler, die nicht aufgetreten wären, wenn die vollständige Arbeit für das Feature atomar abgeschlossen worden wäre - daher sind dies Fehler, die wir nicht lösen müssten, wenn es Verzweigungen gäbe.

5. Planen Sie immer
themenbasierte Releases. Oftmals kommen verschiedene Fehler in verschiedenen Releases an. Es ist jedoch am besten, Fehler (und Funktionen) zu organisieren, die ähnliche Module betreffen, um die Wiederholungsarbeit zu vereinfachen und die Anzahl der Fehler zu minimieren, die durch diese Arbeit verursacht wurden. Bereiten Sie die Release-Roadmap immer frühzeitig vor. Fehler häufen sich - und das fällt in verschiedene Zielversionen, um eine gute Gruppe von Fehlern zu haben, die in einer guten Version zusammengeschossen werden können. Wenn ähnliche Fehler miteinander kombiniert werden, erhalten Sie immer einen besseren Einblick in widersprüchliche Szenarien.

6. Erstes Ausdehnen einer neuen Version auf einige wenige Kunden
In unserem Fall wird diese zuerst an einigen Standorten getestet, und allen anderen Standorten wird eine Version nur dann angewendet, wenn eine Nachfrage danach besteht. Manchmal sprangen einige (oder die meisten) Benutzer nur von einer stabilen Version zu einer anderen stabilen Version.

7. Regressionstests Entspricht
den gesammelten Fehlern - Erstellen Sie einen Regressionsanzug. Auch wenn möglich, markieren Sie kritische Fehler und prüfen Sie, ob sie am wichtigsten sind. Dies sind Mindestqualifizierungskriterien, die geprüft werden müssen, bevor ein Release-Kandidat tatsächlich zu einem Release wird.

8. Pause und Nachdenken
Wenn viele Dinge auf Hochtouren laufen, sollte es Zeit geben, einige Pausen einzulegen - machen Sie eine Pause und lassen Sie Releases laufen, die funktionell nicht besser sind. In der Tat haben Urlaub von Veröffentlichungen für einige Zeit. (Die Dauer ist umgekehrt proportional zur Frequenz). Zum Beispiel haben wir oft diese sogenannten "Clean-up" -Versionen, die aus funktionaler Sicht nichts Neues erreichen - aber das hilft großartig, den Code wartbar zu halten. Die meisten dieser Veröffentlichungen sind großartige Fallback-Punkte, an die Sie sich vorher so gut wie nie erinnern.

9. Vielleicht das seltsamste, was
ich finde, ist, dass es oft schwierig zu implementieren ist, aber es ist ein sicherer guter Trick. Tauschen Sie den Besitzer bestimmter Module aus. Wenn die Leute aufgefordert werden, Code-Überprüfungen durchzuführen, ergibt sich aus dieser Praxis nicht viel. Aber wenn Sie sich ernsthaft mit diesem neuen Code auseinandersetzen müssen, wenn Sie Autoren austauschen, werden potenzielle "schlimme" Leiden schnell bemerkt, bevor sie den Code verunreinigen. Das verringert natürlich die Geschwindigkeit - aber wenn Sie dies oft tun, besteht die Möglichkeit, dass die Leute verschiedene Teile des Codes beherrschen und etwas über das gesamte Produkt lernen, was ansonsten sehr schwierig zu lehren ist.

10. Last but not least
Erfahren Sie, wie Sie häufig zu Whiteboards zurückkehren. Je mehr Sie überdenken, als ob diese Funktion Teil unseres ursprünglichsten Entwurfs gewesen wäre, wie hätten wir damals an den Entwurf gedacht? Manchmal besteht die größte Herausforderung bei inkrementeller Arbeit nur darin, dass wir durch die Reihenfolge der Funktionen, die wir zuerst erstellt haben, zu eingeschränkt sind und nicht immer auf die Grundlagen zurückgreifen können. Der Trick besteht darin, immer wieder zu sehen, wie wir diese neue Funktion oder dieses neue Szenario verallgemeinern und nicht anpassen würden. Dies setzt voraus, dass das Design aktuell bleibt, und das passiert nur, wenn wir oft zurückgehen und Zeichenbrett spielen. Wenn Programmierer der neuen Generation hinzukommen, werden sie Teil der Denkfabrik, anstatt nur Patches zu verteilen.

BEARBEITEN
11. Behalten Sie die Übersicht über Umgehungsmöglichkeiten und Konstruktionslücken.
Sehr oft stehen wir unter Zeitdruck, um den Fehler zu beheben und in der Produktion freizugeben. Wenn sich der Fehler jedoch auf Design-Ebene befindet, müssen einige Dinge geändert werden, aber oft werden die Leute durch einige Abkürzungen Abhilfe schaffen, um die Frist einzuhalten. Das ist in Ordnung . Mit zunehmender Anzahl solcher Umgehungslösungen wird der Code jedoch zerbrechlich. Behalten Sie einen besonderen Überblick darüber, wie viele Konstruktionslücken bereits vorhanden sind. Wenn Sie die Zeitpläne mit dem Projektmanager aushandeln, ist es in der Regel am besten, ihn / sie zu verpflichten, dies in Kürze zu liefern, um die Produktion zu schonen, aber wir müssen es auch tun Zeitleiste und Ressourcen für eine dauerhafte Lösung.

Ich arbeite auch in einem kleinen Entwicklerteam (nur 2 von uns) und wir hatten ähnliche Probleme, die Sie erwähnt haben. Das Hauptproblem für uns ist, dass wir beide dazu neigen, an separaten Aufgaben zu arbeiten, und es für uns zu üblich wurde, eine Aufgabe / Funktion abzuschließen, sie zu testen (nur vom Entwickler getestet) und schnell freizugeben. Dies führte zu vielen kleinen Releases, in denen Benutzer über kleine Fehler berichteten, die beim Testen leicht hätten aufgedeckt werden können.

Um unseren Prozess zu verbessern, habe ich zunächst ein Kanban- Board eingeführt. Das Board war anfangs sehr einfach und hatte nur wenige Spalten (Aufbau mit Whiteboard, Karteikarten und farbigen Magneten):

Rückstand | Zu tun | Erledigt

Dies entwickelte sich jedoch schnell und spiegelte unseren tatsächlichen Prozess wider:

Rückstand | Entwicklung | Dev. Test | UAT | Fertig Veröffentlicht

Zusammen mit dem Board haben wir die Regel, dass jede Aufgabe / jedes Feature von einem anderen Entwickler (sowie von dem Entwickler, der das Feature implementiert hat) getestet werden muss. Wenn die Karte die Spalte "Fertig" erreicht, sollte sie von mindestens 2 Entwicklern getestet und auch auf Benutzerakzeptanz getestet worden sein.

Kanban bietet viele weitere Vorteile. Für uns hat es die Kommunikation verbessert und uns geholfen, Wissen zu teilen, da wir beide zu einem gewissen Grad an jeder Aufgabe beteiligt sind. Es hat auch unseren Freigabeprozess verbessert, da wir jetzt genau sehen können, welche Aufgaben / Funktionen zur Freigabe bereitstehen / erledigt sind, und manchmal auf die Freigabe warten können, wenn wir wissen, dass bald andere Aufgaben erledigt werden. Für Personen außerhalb des Teams dient der Vorstand auch als Kurzreferenz, um zu sehen, welche Aufgaben wir geplant haben, welche Arbeiten gerade ausgeführt werden und was kürzlich veröffentlicht wurde.

Daneben verwenden wir farbige Magnete (einen pro Entwickler), um die Karte zu kennzeichnen, an der wir gerade arbeiten. Eine weitere Option besteht darin, Schwimmbahnen (Reihen) hinzuzufügen, eine pro Entwickler und Kanban-Karten in die entsprechenden Schwimmbahnen zu legen. Dies ist wiederum eine schnelle Referenz, um zu sehen, woran die einzelnen Entwickler gerade arbeiten.

Andere Links, die ich nützlich fand:

Kanban für die Softwareentwicklung: von agil bis schlank

Ein Kanban-System für Software Engineering - Video

Hoffentlich würde Kanban Punkt 1 in Ihrer Frage ansprechen. In Bezug auf Codeüberprüfungen führen wir dies in der Entwicklungsprüfungsphase durch, damit alle Änderungen, die nach der Überprüfung erforderlich sind, erneut getestet werden, bevor Sie zu UAT gehen. Das Rollback hängt von Ihrer Umgebung ab, aber wir stellen Anwendungsdateien auf Terminalservern mithilfe von Stapeldateien bereit, die aktuelle Dateien umbenennen und neue Dateien von einem zentralen Server kopieren. Sie können das Rollback relativ einfach durchführen, indem Sie die Sicherungskopie (vorherige Dateien) an der zentralen Stelle ablegen und erneutes Ausführen von Skripten.

Sie haben bereits festgestellt, dass es Probleme mit Ihren Prozessen gibt, die sich auf die Qualität Ihrer Software auswirken, und obwohl diese Frage eine Reihe von Antworten hervorruft, ist mein Vorschlag, sich mit dem Thema Softwareentwicklung zu befassen und zu versuchen, was zu lernen Die Entwickler finden sich in diesem Bereich immer mehr zurecht. Ich schlage vor, Sie lesen ein paar gute Ressourcen, um loszulegen. Ein paar, die mir einfallen:

• Die Lean-Software-Entwicklung von Mary und Tom Poppendeick bietet eine großartige Lektüre für Menschen, die lernen möchten, wie "Abfälle" identifiziert werden und wie Prozesse geändert werden können, um schlanker und effizienter zu werden.
• Head First Software Development von Dan Pilone und Russ Miles ist auf den ersten Blick ein bisschen wie eines dieser "For Dummies" -Bücher, aber wenn man ein wenig über den chaotischen Präsentationsstil hinausschaut, enthält es die meisten Informationen zu den Grundlagen des Software-Engineerings und hat einen kurzen Bericht über Test Driven Development.
• Die Einführung von BDD ist die Seite von Dan North über den Einstieg in die behaviourgesteuerte Entwicklung, oder vielleicht bevorzugen Sie ein BDD-Wiki . Dies sind Einstiegsreferenzen für BDD, und Sie werden wahrscheinlich nach Tools und Frameworks suchen müssen, um Hilfe zu erhalten. Es ist wichtig zu verstehen, dass BDD effektiv auf eine höhere konzeptionelle Ebene gebracht wird. Es ermöglicht Ihnen, über Tests nachzudenken, während Sie über Spezifikationen nachdenken, und in derselben Sprache zu testen, die Sie beim Schreiben von Spezifikationen verwenden. Die Frameworks lassen sich im Allgemeinen in andere Unit-Testing-Frameworks integrieren, sodass Sie das Beste aus beiden Welten herausholen können, wenn Sie entscheiden, dass Ihre Tests möglicherweise nicht unbedingt von der BDD-Syntax profitieren.
• Der Wikipedia-Artikel zur agilen Softwareentwicklung ist eine gute Einführung in die agile Softwareentwicklung und bietet eine Reihe nützlicher Verweise und Links zu Artikeln einiger angesehener Entwickler.

Um Ihre Arbeitsweise zu verbessern, müssen Sie sich völlig aufgeschlossen zeigen und gewillt sein, Ihre Komfortzone zu verlassen, um zu lernen, wie Sie Ihre Arbeitsweise verbessern können, ohne an bestimmten Konzepten festzuhalten, die Sie möglicherweise finden angenehmer zu hängen. Aus persönlicher Erfahrung ist dies wahrscheinlich das Schwierigste, was man tun oder bei anderen ermutigen kann.

Veränderungen sind im besten Fall schwierig, auch wenn Sie das Gefühl haben, aktiv nach Veränderungen zu suchen. Der beste Rat, den ich Ihnen geben kann, ist, sich die verschiedenen agilen Methoden anzuschauen, die im Laufe der Jahre entwickelt wurden, um sich mit den Praktiken vertraut zu machen die als am wichtigsten erachtet werden (z. B. Unit Testing, Continuous Integration, Refactoring usw.), und wählen Sie dann die Methodik aus, die Ihrer und Ihrem Team am nächsten zu kommen scheint. Wenn Sie Ihre Entscheidung getroffen haben, passen Sie die Vorgehensweisen und Ihren Entwicklungsprozess an, wie Ihr Team am liebsten arbeiten würde. Berücksichtigen Sie dabei die schlanken Prinzipien und die Art und Weise, wie Sie arbeiten möchten, damit Ihr Team den größten Nutzen aus dem Nutzen ziehen kann am wenigsten Abfall. Schließlich,

Wenn Sie der Meinung sind, dass Ihre Prozesse lediglich optimiert werden müssen, Ihre Toolkette jedoch nicht ganz mit Ihren Anforderungen Schritt hält, sollten Sie sich dort vielleicht um Verbesserungen bemühen. Ein Continuous-Integration-Integrationsprodukt (wie Continuum, Cruise Control oder Hudson) und ein Issue-Tracking-System (wie Jira oder Redmine) sollten mindestens Vorrang haben, damit Sie einige Ihrer Build- und Release-Prozesse automatisieren können. und um Ihre Bugs und Feature Requests in Schach zu halten.

Die Realität ist, dass unabhängig von der RAD-Qualität Ihrer Prozesse Ihre Probleme mit der Zeit weiter zunehmen und Ihre Wahrnehmung der verfügbaren Zeit zunehmen wird, wenn Sie nicht in die Investition von Zeit investieren, um die Dinge für Ihr Team "richtig" zu machen entsprechend schrumpfen. Große Veränderungen sind normalerweise unter hohem Zeitdruck nicht in Frage zu stellen. Geben Sie sich jedoch ein wenig Spielraum, um Systeme einzurichten, die Sie dabei unterstützen, die Vision Ihres Teams von einer idealen Methodik zu verwirklichen.

Wann immer ich von Mängeln höre, sind meine ersten Fragen, woher die Mängel stammen und wo sie entdeckt und beseitigt werden. Die Effizienz der Fehlerbeseitigung ist eine gute Möglichkeit, dies zu messen und zu verfolgen. Indem Sie wissen, wo Fehler entstehen, und die Prozesse in diesen Phasen verbessern, können Sie Zeit und Kosten eines Projekts reduzieren. Es ist allgemein bekannt, dass es billiger ist, Fehler näher an ihrem Injektionspunkt zu beheben. Wenn Sie also wissen, woher die Fehler stammen, können Sie sich die Änderungen der Aktivitäten ansehen, um diese Phasen zu verbessern.

Sobald Sie Informationen darüber haben, woher die Mängel stammen, können Sie genau prüfen, welche Techniken und Technologien Sie anwenden möchten. Abhängig von den Phasen, in denen Fehler auftreten, sollten Sie die Überprüfung der Anforderungen, des Designs und des Codes, automatisierte Tests, statische Analysen, kontinuierliche Integration und umfangreichere benutzergesteuerte Tests in Betracht ziehen.

Um Ihren Wunsch nach Codeüberprüfungen zu erweitern, sollten Sie auch verschiedene Ebenen von Codeüberprüfungen berücksichtigen, die auf der Priorität und dem Risiko eines Moduls basieren. Module mit niedrigem Risiko und niedriger Priorität benötigen möglicherweise überhaupt keine Codeüberprüfung, oder es kann auch nur eine einfache Schreibtischüberprüfung durchgeführt werden, bei der ein anderer Entwickler den Code nur selbst liest und Kommentare abgibt. Andere Techniken zur Codeüberprüfung umfassen die Programmierung von Paaren, exemplarische Vorgehensweisen, Kritiken und Inspektionen mit einer unterschiedlichen Anzahl von Entwicklern.

Zum Zurücksetzen würde ich versuchen, diesen Prozess mithilfe von Skripten zu automatisieren, um ihn schneller und weniger fehleranfällig zu machen. In einer perfekten Welt möchte ich die Qualität der gelieferten Produkte so verbessern, dass kein Rollback erforderlich ist, und Sie können dies erreichen. Die Fähigkeit zu haben, mag eine gute Idee sein, aber es so schmerzlos wie möglich zu machen.

Wie bereits erwähnt, wird das Hinzufügen von Regressionstests dazu beitragen, zu verhindern, dass in Zukunft dieselben Fehler auftreten. Wenn Sie jedoch auf neue Fehler stoßen, ist es möglicherweise an der Zeit, dem Code Zusicherungen (auch Verträge genannt) hinzuzufügen, die die Vor- und Nachbedingungen sowie die Invarianten der Klassen und Methoden angeben.

Wenn Sie beispielsweise eine Klasse haben, in der eine Methode nur Zahlen zwischen 10 und 25 akzeptieren kann (dies wird als Vorbedingung bezeichnet), fügen Sie am Anfang der Methode eine assert-Anweisung hinzu. Wenn diese Behauptung fehlschlägt, stürzt das Programm sofort ab und Sie können der Methodenkette folgen, die zu diesem Fehler geführt hat.

Python, PHP und andere Programmiersprachen sind dynamisch typisiert und fügen Methoden nicht viele Bedingungen hinzu. Damit etwas funktioniert, muss lediglich eine bestimmte Methode implementiert werden. Ich vermute, dass Sie mehr Bedingungen für Ihre Methoden benötigen. Sie müssen definieren und testen, um sicherzustellen, dass eine Methode tatsächlich in ihrer Umgebung funktioniert.

Bei C / C ++ - Programmen stellte ich fest, dass das Hinzufügen von Zusicherungen zum Testen der Speicherzuordnung sehr hilfreich ist, um die Anzahl der Speicherverluste im Programm zu verringern.