Wie löscht man sicher einen Code, der so aussieht, als wäre er nie eingegeben worden?

125

Sie haben Code gefunden, der überflüssig aussieht, und der Compiler merkt das nicht. Was tun Sie, um sicherzustellen (oder so gut wie möglich), dass das Löschen dieses Codes keine Regression hervorruft?

Zwei Ideen kommen in den Sinn.

  1. Verwenden Sie "einfach" den Abzug basierend darauf, ob der Code so aussieht, als ob er ausgeführt werden soll oder nicht. Manchmal ist dies jedoch ein komplexer, zeitaufwändiger Job, der ein geringes Risiko birgt (Ihre Einschätzung ist fehleranfällig) und zu keinem wesentlichen Geschäftserfolg führt.

  2. Platzieren Sie die Protokollierung in diesem Codeabschnitt und sehen Sie, wie oft sie in der Praxis eingegeben wird. Nach einer ausreichenden Anzahl von Ausführungen sollten Sie sich darauf verlassen können, dass das Entfernen des Codes sicher ist.

Gibt es bessere Ideen oder so etwas wie einen kanonischen Ansatz?

Brad Thomas
quelle
55
Ein Blick in den Versionskontrollverlauf kann hilfreich sein: Wann wurde der "tote Code" erstellt? Sah es tot aus, als es geschaffen wurde? Wurde bei der Erstellung anderer Code (der seitdem geändert oder gelöscht wurde) in dem er verwendet wurde, überprüft?
ChrisW
9
Dem Compiler kann nicht vertraut werden, wenn irgendeine Form von Metaprogrammierung wie Reflektion im Spiel ist. Ein ordentliches grep des Basisverzeichnisses ist eine wesentliche Praxis. Es ist auch üblich, dass mehrere Anwendungen Code gemeinsam nutzen. Vergewissern Sie sich daher, dass Sie die richtige Verzeichnisebene auswählen.
Adam Caviness
16
Ich würde fragen - "Warum sich die Mühe machen, es zu löschen?". Wenn es in einem Randfall verwendet wird, der einmal in einem blauen Mond genannt wird, haben Sie Sachen gebrochen. Wenn es nie verwendet wird und Sie es dort belassen, besteht der Schaden darin, dass die ausführbare Datei ein kleines bisschen größer ist. Wenn dies nicht für ein Embedded-Gerät gilt, ist dies eine große Sache? Schreiben Sie einen Kommentar und nutzen Sie Ihre Zeit produktiv.
Mickeyf
40
@ Mickeyf Der Schaden ist, dass jemand diesen Code warten muss. Das heißt, ein Entwickler muss verstehen, was er tut. Der Entwickler muss es ändern, wenn sich etwas ändert, und der Code, der es umgibt, muss jetzt etwas anderes tun. Glauben Sie mir, wenn Sie Cruft herumliegen lassen, ist es ein großes Problem für jeden, der versucht, es später herauszufinden.
jpmc26
9
@MichaelJ. Mein Punkt ist, dass es überhaupt nicht hätte da sein sollen. Und wenn ich es verlasse, ist die Situation noch schlimmer: Jetzt muss es auch ein anderer Entwickler untersuchen. Je länger es bleibt, desto mehr Zeit wird aufgewendet, um es zu verstehen. Dies sind die Kosten für überflüssigen Code.
jpmc26

Antworten:

112

In meiner perfekten Fantasiewelt, in der ich eine 100% ige Einheitentestabdeckung habe, lösche ich sie einfach, führe meine Einheitentests durch, und wenn kein Test rot wird, gebe ich sie ein.

Aber leider muss ich jeden Morgen aufwachen und mich der harten Realität stellen, in der viele Codes entweder keine Komponententests haben oder in denen man sich nicht darauf verlassen kann, dass sie wirklich jeden möglichen Randfall abdecken. Ich würde also das Risiko / den Gewinn in Betracht ziehen und zu dem Schluss kommen, dass es sich einfach nicht lohnt:

  • Belohnung: Code ist in Zukunft etwas einfacher zu pflegen.
  • Risiko: Brechen Sie den Code in einem undurchsichtigen Fall, an den ich nicht gedacht habe, verursachen Sie einen Vorfall, wenn ich ihn am wenigsten erwarte, und machen Sie Fehler, weil ich meine OCD-Codequalität erfüllen und eine Änderung ohne erkennbaren geschäftlichen Wert vornehmen musste an alle Stakeholder, die selbst kein Kodierer sind.
Philipp
quelle
249
Nachdem ich den Stand umfangreicher Softwareprojekte beobachtet habe, bei denen Ingenieure zehn bis zwölf Jahre lang den Ansatz verfolgt haben, dass es sich nicht lohnt, wahrscheinlich überflüssigen Code zu entfernen, kann ich diesen Ansatz nicht empfehlen.
Njuffa
125
Unit-Tests sagen auch nichts darüber aus, ob dieser Code tatsächlich in der Produktion verwendet wird. Der Code konnte perfekt getestet werden, wurde aber in der Produktion noch nicht verwendet, daher überflüssig.
Knub
8
Nach meiner Erfahrung ist der Status solcher Projekte niemals auf einen Ansatz zurückzuführen, der es nicht wert ist, den Code nachträglich zu reparieren. Es liegt immer daran, dass an erster Stelle schlechter Code geschrieben wurde. Es ist ein Fehler, schlechten Code zu schreiben, aber es ist auch ein Fehler (ein weiter fortgeschrittener Fehler), zu glauben, dass es sich immer lohnt, den Code zu bereinigen.
Weyland Yutani
42
@Weyland Yutani Das passt überhaupt nicht zu meiner Erfahrung. Der größte Teil des wahrscheinlich überflüssigen Codes, den ich gesehen habe, war ausreichend gut geschrieben und in Anbetracht der Software - Spezifikationen, Hardware - Plattformen oder Betriebssystemversionen, die vor einem Jahrzehnt existierten und zur Umgehung von Fehlern oder Einschränkungen in der Toolkette oder früher verfügbarer Hardware usw .
njuffa
20
Bei der Beantwortung fehlt einer der wichtigsten und wichtigsten Vorteile, wenn Sie fortfahren und die Änderung vornehmen: etwas lernen. Nachdem Sie es gelernt haben, können Sie eine Struktur (Kommentare, Tests) hinzufügen, um die Wartungsentwickler später zu unterstützen. Die Entscheidung, etwas nicht zu ändern, weil Sie die Konsequenzen nicht kennen, ist Frachtkultprogrammierung, auch wenn diese Entscheidung nicht darin besteht, etwas zu löschen.
Kojiro
84

Dieser Prozess besteht aus zwei Hälften. Der erste bestätigt, dass der Code tatsächlich tot ist. Die zweite besteht darin, die Kosten für das Unrecht zu erfassen und sicherzustellen, dass sie angemessen gemindert werden.

Viele Antworten hier haben großartige Lösungen für die frühere Hälfte. Tools wie statische Analysegeräte eignen sich hervorragend zur Identifizierung von totem Code. grepkann in einigen Fällen dein Freund sein. Ein ungewöhnlicher Schritt, den ich oft unternehme, ist zu versuchen, den ursprünglichen Zweck des Codes zu identifizieren. Es ist viel einfacher zu argumentieren, dass "X nicht länger ein Merkmal unseres Produkts ist und das Codesegment Y das Merkmal X unterstützen soll", als zu sagen, "Ich sehe keinen Sinn für das Codesegment Y".

Die zweite Hälfte ist ein entscheidender Schritt, um zu entscheiden, ob Code entfernt werden soll. Sie müssen verstehen, welche Konsequenzen es hat, wenn die Antwort falsch ist. Wenn Menschen sterben, wenn Sie die falsche Antwort erhalten, achten Sie darauf! Vielleicht ist es ein guter Zeitpunkt, um zu akzeptieren, dass sich mit der Zeit Code Cruft entwickelt, und stattdessen zu versuchen, nicht mehr Cruft selbst zu schreiben. Wenn Menschen nicht sterben werden, fragen Sie sich, wie verzeihend Ihre Benutzer sind. Können Sie ihnen einen Hotfix senden, wenn Sie etwas kaputt gemacht haben und Ihre Kundenbeziehungen pflegen? Haben Sie ein Q & A-Team, das dafür bezahlt wird, solche Probleme zu finden? Diese Art von Fragen sind wichtig, um zu verstehen, wie sicher Sie sein müssen, bevor Sie die Löschtaste drücken.

In den Kommentaren wies rmun auf eine hervorragende Formulierung des Konzepts hin, den ursprünglichen Zweck des Codes zu verstehen, bevor er entfernt wird. Das Zitat ist jetzt als Chestertons Zaun bekannt . Obwohl es zu groß ist, um direkt in einem Kommentar zitiert zu werden, sollte es meiner Meinung nach hier richtig zitiert werden:

Bei der Reform der Dinge gibt es im Gegensatz zu ihrer Verformung ein einfaches Prinzip. Ein Prinzip, das wahrscheinlich als Paradox bezeichnet wird. In einem solchen Fall gibt es eine bestimmte Institution oder ein bestimmtes Gesetz. Lassen Sie uns der Einfachheit halber einen Zaun oder ein Tor über einer Straße errichten. Der modernere Reformertyp macht sich lustig und sagt: „Ich sehe keinen Sinn darin. Lassen Sie es uns wegräumen. “Worauf der intelligentere Reformertyp gut antworten kann:„ Wenn Sie die Verwendung nicht sehen, lasse ich Sie mit Sicherheit nicht wegräumen. Geh weg und denke nach. Dann, wenn Sie zurückkommen und mir sagen können, dass Sie den Gebrauch davon sehen, kann ich Ihnen erlauben, es zu zerstören.

Cort Ammon
quelle
14
Chestertons Zaun geht davon aus, dass die Entdeckung rein durch das Denken zustande kommt, und bietet keinen Rückgriff - eine eher altgriechische Philosophie. Die wissenschaftliche Methode ist moderner - entwickeln Sie ein kontrolliertes Experiment, um die Konsequenzen des Entfernens der Struktur zu bestimmen. Natürlich würde ich nicht ohne weiteres vorschlagen, dass dieses Experiment in der Produktion durchgeführt wird. Aber wenn es keine Alternative gibt und die Kosten für das Testen in der Produktion sehr hoch sind, würde ich lieber schnell einen Arbeitsplatz verlassen, der mir keine sicheren Mittel bietet, um zu erfahren, warum ein Code existiert - das persönliche Risiko bei einem solchen Job ist zu hoch .
Kojiro
15
@kojiro Das ist sehr wahr. Ich denke gerne, dass Chesterton in Ordnung wäre, wenn ich als "moderner Reformer" vorbeikäme und sagte: "Ich weiß nicht, warum dieser Zaun hier ist, ich gebe es zu. Aber ich würde ihn gerne rot streichen, um zu sehen, ob das gibt mir keine neuen informationen ", würde chesterton wahrscheinlich damit zufrieden sein.
Cort Ammon
41
Die VMS OS-Kernelmodus-Taktdecodierungsmethode SYS $ ASCTIM enthält eine Codezeile, mit deren Hilfe die siderische Abweichung des Frühlingsäquinoktiums korrigiert werden kann. Keiner der DEC-Komponententests übt diesen Code aus. Es lief einmal - richtig - am 28.02.2000 um 23: 59: 59: 999. Es wird erst im Jahr 2400 wieder ausgeführt. Bitte löschen Sie es nicht.
AI Breveleri
13
@ AIBreveleri Ich sollte hoffen, dass es einen Kommentar im Code selbst gibt, der dies erklärt, und nicht nur hier auf StackExchange: D
Kyle Strand
11
@KyleStrand Worüber sprichst du? Dies ist die Dokumentation. Können Sie sich einen besseren Ort vorstellen, um wichtige Informationen so abzulegen, dass andere Personen sie finden, als StackExchange? ;-)
Cort Ammon
43

Ich tendiere auch dazu, grepden Funktions- / Klassennamen im Code anzugeben, was einige zusätzliche Vorteile mit sich bringen kann, die eine Code-Analyse möglicherweise nicht bietet, beispielsweise wenn der Name in einem Kommentar, einer Dokumentationsdatei oder einem Skript erwähnt wird. Ich lasse grep auf den Akten im Quellbaum laufen und speichere das Resultat in einer Akte; In der Regel enthält das Ergebnis eine komprimierte Information: Dateiname / Pfad, Zeilennummer und die Zeile, in der der Name vorkommt. Dies kann Hinweise darauf geben, wo die Funktion / Klasse ohne semantische Bedeutung aufgerufen oder erwähnt wird (im Gegensatz zu einem Codeanalysator) ) und unabhängig von den Dateierweiterungen. Auf jeden Fall nicht die ultimative Lösung, aber eine schöne Ergänzung zu einer Analyse.

piwi
quelle
11
Ich bin kein Downvoter, aber was ist, wenn der Codeabschnitt, von dem Sie vermuten, dass er nie ausgeführt wird, keine vollständige Funktion oder Klasse ist, sondern ein Abschnitt einer Methode / Funktion?
Tulains Córdova
9
Abhängig von der Sprache ist dies möglicherweise nicht immer zuverlässig. In einigen Sprachen können Methodenaufrufe dynamisch durchgeführt werden. Zum Beispiel PHP:$object->$variableMethod($arg1, $arg2);
Dezza
9
@ TulainsCórdova Dann ist das wohl offensichtlich keine gute Lösung. Verwenden Sie jede mögliche Lösung, wenn sie im gegebenen Kontext sinnvoll ist. Aber vielleicht im grepzb. Eine Funktion, die den Codeabschnitt umfasst, kann Hinweise darauf geben, wie die Funktion verwendet wird und damit ihren Inhalt?
Piwi
7
"Wie wenn der Name in einem Kommentar oder in einer Dokumentationsdatei oder in einem Skript erwähnt wird" - oder wenn jemand Reflection verwendet, um die Methode aufzurufen (wenn eine Hochsprache / OO verwendet wird). Obwohl immer noch nicht 100% genau, da einige Sprachen einige sehr stumpfe Methoden zum Auffinden und Aufrufen von Methoden unterstützen.
Aroth
Dies ist hilfreich, wenn Sie Zugriff auf alle möglichen Codes haben, die die Funktion verwenden könnten. Wenn der Code jedoch Teil einer Bibliothek ist, woher wissen Sie dann, dass etwas, das Sie nicht durchsuchen können, nicht kaputt geht?
Kevin Shea
30
  • Identifizieren Sie den Code, der tot aussieht (statische Analyse usw.).
  • Fügen Sie für jeden Aufruf des angeblich toten Codes eine Protokollnachricht hinzu . Es ist einfach mit Funktionen / Methoden; Mit statischen Elementen wie Konstanten ist es schwieriger. Manchmal können Sie Code einfach als veraltet markieren, und die Laufzeit protokolliert automatisch eine Nachricht für Sie. Lassen Sie den Code ansonsten intakt.
    • Protokollieren Sie eine Nachricht, wenn das tote Modul geladen ist: Die meisten Sprachen haben die Möglichkeit, zum Ladezeitpunkt eine statische Initialisierung durchzuführen, die huckepack erfolgen kann.
    • Stellen Sie sicher , dass Ihre Log - Nachricht einen angemessenen Stack - Trace enthält, so dass Sie verstehen , was der angeblich tote Code genannt.
  • Führen Sie den geänderten Code in all Ihren Testsuiten aus. Ihre Testsuiten sollten auch auf bestimmte Zeiten prüfen, z. B. Mitternacht, Viertel- oder Jahreswechsel. Sehen Sie sich die Protokolle an, und aktualisieren Sie Ihr Verständnis für den Tod. Beachten Sie, dass Unit-Tests möglicherweise speziell den toten Code testen, während keine anderen Unit-Tests und keine Integrationstests ihn berühren.
  • Führen Sie den geänderten Code einige Wochen lang in der Produktion aus. Stellen Sie sicher, dass während dieses Zeitraums alle regelmäßigen Prozesse ausgeführt werden, z. B. die einmal im Monat durchgeführten ETL-Cron-Jobs.
  • Schauen Sie sich die Protokolle an. Alles, was protokolliert wurde, ist nicht wirklich tot. Die transitive Schließung des Aufrufgraphen über den Rest des toten Code ist auch möglicherweise nicht tot, auch wenn es nicht aufgerufen wurde. Analysiere es. Möglicherweise sind einige Zweige sicher tot (z. B. die Arbeit mit einer API eines inzwischen ausgestorbenen Dienstes), andere noch nicht. Möglicherweise wird ein ganzes Modul / eine ganze Klasse nur für eine darin definierte Konstante geladen, und Sie können sie leicht wieder verwenden.
  • Was übrig bleibt, ist sicher tot und kann entfernt werden.
9000
quelle
Es gibt für alles ein erstes Mal. Nur weil Code zuvor nicht ausgeführt wurde, heißt das nicht, dass er niemals ausgeführt wird, insbesondere, wenn es einen Ausführungspfad dafür gibt. Die Entscheidung , etwas zu entfernen, das ausgeführt werden kann, unterscheidet sich jedoch von der Entscheidung, ob es ausgeführt werden kann.
7
@nocomprende genau das, was passiert, wenn dieser Code nur für eine Jahresende-Funktion verwendet wird und Sie Ihren Test ausführen, wird von Februar bis November ausgeführt. Sie werden die Verwendung nicht finden, obwohl Sie sie fast ein ganzes Jahr lang profiliert haben.
Erik
1
@ 9000 Theoretisch stimme ich zu, aber in älteren Systemen gibt es viele versteckte Abhängigkeiten, die diese Art von Tests verhindern können. Damit Ihr Testbeispiel funktioniert, müssen Sie wissen, dass es eine Art zeitliche Kopplung gibt. Wenn die zeitliche Kopplung außerhalb des Codes liegt, den Sie testen, werden Sie sie im Code nicht sehen und wissen, dass die zeitliche Kopplung ein Faktor ist. Zum Beispiel ist der Code von Silo A im GAC installiert . Vor Jahren hat Silo B Silo A gebeten, einen Codepfad für einen Bericht hinzuzufügen, der für die Daten von Silo A ausgeführt werden soll. Fortsetzung
Erik
1
@ 9000 Forts. Jetzt hat der Code von Silo B eine zeitliche Kopplung mit einem "toten" Codepfad im Code von Silo A, die nicht durch bloßes Betrachten des Codes von Silo A ersichtlich ist. Wie würden Sie diese zeitliche Kopplung testen, da sich die zeitliche Kopplung nur im Code von Silo B befindet, ohne zu wissen, mit Silo B zu sprechen? Auch dann spielt die Zeit in Ihrem Code (Silo A) keine Rolle. Wie würde ein zeitlicher Test aussehen?
Erik
2
Erinnert sich jemand an die Y2k- Panik? Ein Code war im Jahr 2000 richtig, weil er für 2100 falsch war! Wir hatten ein potenzielles Problem, das einmal in 100 Jahren oder sogar einmal in 400 Jahren auftreten könnte.
Steve Barnes
16

Zusätzlich zu den bereits erwähnten Antworten können Sie den Code auch iterativ über mehrere Versionen hinweg entfernen.

In der anfänglichen Version konnten Sie eine Verfallswarnung ausführen, während der Codeblock noch funktionierte. In der darauf folgenden Version können Sie den Codeblock entfernen, aber eine Fehlermeldung hinterlassen, in der Benutzer die Funktion nicht mehr verwenden und nicht mehr verfügbar sind. In der endgültigen Version würden Sie den Codeblock und alle Nachrichten entfernen.

Dies kann helfen, unvorhergesehene Funktionen zu identifizieren, ohne die Endbenutzer zu warnen. Im besten Fall tut der Code wirklich nichts und alles, was passiert, ist, dass der nicht benötigte Code über mehrere Versionen hinweg aufbewahrt wird, bevor er entfernt wird.

user3196468
quelle
7
+1. Ich habe so viele Fehler und Kundenprobleme gesehen, die hätten vermieden werden können, wenn die Entwickler (oder ihr Management) gewillt wären, ein Projekt in zwei oder drei sichere Phasen zu unterteilen, anstatt zu versuchen, alles auf einmal zu tun, um ein Problem zu lösen beliebige Frist, bevor mit dem nächsten Projekt begonnen wird.
Ruakh
Dies beantwortet die im Titel gestellte Frage, aber wenn Sie mich fragen, hat die Frage den falschen Titel. Im Titel wird gefragt, wie der Code gelöscht werden soll. Im Textkörper wird jedoch zunächst ermittelt, ob der Code sicher gelöscht werden kann. Sie antworten auf jeden Fall auf Ersteres, aber ich bin mir nicht sicher, ob die OP das wirklich gefragt hat.
Underscore_d
7

Viele Leute schlagen vor, dass es "sicher" ist, den Code zu belassen, wenn man nicht nachweisen kann, dass er nicht verwendet wird.

Aber Code ist kein Aktivposten, sondern eine Verbindlichkeit.

Wenn Sie nicht erklären können, warum es wichtig ist, und auf seine Tests verweisen, besteht die "sicherere" Alternative möglicherweise darin, sie zu löschen.

Wenn Sie sich immer noch nicht sicher sind, fügen Sie mindestens Tests hinzu, um den Zombie-Code zu testen.

Adrian McCarthy
quelle
Schritt 1: Löschen Sie den gesamten Code. Schritt 2: Setzen Sie zurück, was benötigt wird. Schritt 3: wiederholen.
1
@Adrian Kann ich Sie auf Knight Capital aufmerksam machen? en.wikipedia.org/wiki/… - nur für den Fall, dass Sie Ihren Standpunkt mit einem Verweis darauf stärken möchten. Sie sind im Grunde implodiert, weil ein alter Code wieder zum Leben erweckt wurde und freundlicherweise fast 500 Millionen Dollar für sie verloren hat. Die folgende Untersuchung konzentrierte sich auf ihre Freigabeverfahren, aber das Hauptproblem war "tote Funktionalität wurde nicht gelöscht".
SusanW
6

Mithilfe von Feature-Umschaltern können Sie den Ausführungspfad Ihrer Software ändern, um den betreffenden Code vollständig zu ignorieren.

Auf diese Weise können Sie Ihre Änderung mit dem nicht verwendeten Code und dem Deaktivieren sicher bereitstellen. Wenn Sie einige schwerwiegende Fehler im Zusammenhang mit dem Code feststellen, schalten Sie den Schalter wieder ein und untersuchen Sie den möglichen Pfad dazu.

Dieser Ansatz sollte Ihnen Sicherheit geben, wenn Sie über einen längeren Zeitraum hinweg keine Probleme feststellen und die Möglichkeit haben, ihn ohne Bereitstellung wieder in Betrieb zu nehmen. Ein noch besserer Weg wäre jedoch, eine zusätzliche Protokollierung und Testabdeckung für das betreffende Gebiet anzuwenden, was mehr Beweise liefert, ob es verwendet wird oder nicht.

Weitere Informationen zum Umschalten finden Sie hier: https://martinfowler.com/articles/feature-toggles.html

Schärpe
quelle
6

Statische Analyse natürlich ... und das Schöne ist, dass Sie keine neuen Werkzeuge benötigen; Ihr Compiler verfügt über alle statischen Analyse-Tools, die Sie benötigen.

Ändern Sie einfach den Namen der Methode (z. B. Ändern DoSomethingin DoSomethingX) und führen Sie dann einen Build aus.

Wenn Ihr Build erfolgreich ist, wird die Methode offensichtlich von nichts verwendet. Sicher zu löschen.

Wenn Ihr Build fehlschlägt, isolieren Sie die Codezeile, die ihn aufruft, und überprüfen Sie, welche ifAnweisungen den Aufruf umgeben, um zu bestimmen, wie er ausgelöst werden soll. Wenn Sie keinen möglichen Datenverwendungsfall finden, der ihn auslöst, können Sie ihn sicher löschen.

Wenn Sie wirklich Bedenken haben, den Code zu löschen, sollten Sie ihn behalten und ihn mit einem ObsoleteAttribute (oder einem in Ihrer Sprache gleichwertigen Attribut) kennzeichnen . Geben Sie es für eine Version so frei, und entfernen Sie den Code, nachdem keine Probleme in freier Wildbahn gefunden wurden.

John Wu
quelle
8
Dies ist ein guter Rat für Programmiersprachen, die keine vollständige dynamische / späte Bindung haben . Für diejenigen, die haben, ist es jedoch schwieriger. Und natürlich wird die Methode möglicherweise auch dann von Code verwendet, wenn sie in der Produktion nie verwendet wird.
Eis
Die Frage setzt die Auflösung von Symbolen zur Kompilierungszeit voraus ( Sie haben also Code gefunden, der überflüssig aussieht. Der Compiler merkt das nicht. ) Sogar spät gebundene Funktionen oder Objekte werden normalerweise an zwei Stellen definiert, z. B. in einer Schnittstellen- oder Map-Datei, sodass der Build immer noch fehlschlagen würde.
John Wu
1
Hmm ... ich bin fasziniert, ich glaube nicht, dass das, was du sagst, wahr ist. Es ist nicht für Vanille Javascript (nicht vorkompiliert), Ruby, Python oder Smalltalk, oder? Wenn Sie auf Sachen verweisen, die nicht existieren, treten diese Fehler nur zur Laufzeit auf.
Eis
Vielleicht sind wir uns nicht einig darüber, was unter "Binden" zu verstehen ist, was für mich die Auflösung einer logischen Darstellung in eine physische Darstellung bedeutet, z. B. ein Symbol in eine Adresse. Javascript-Funktionen werden als Tag / Wert-Paare innerhalb des enthaltenden Objekts gespeichert, so dass der Begriff der Bindung nicht fortlaufend zu sein scheint.
John Wu
1
Ja, wir sind uns nicht einig. Der Begriff hat eine andere Bedeutung für Sprachen, die nicht vollständig spät gebunden sind (wie ich im ersten Kommentar erklärt habe). Wenn Sie Methoden zur Laufzeit binden - in Sprachen, die Methoden zur Laufzeit hinzufügen und entfernen können - verwenden Sie die späte Bindung so, wie ich es verstehe. Dies ist in Ruby / Python / Smalltalk-ähnlichen Sprachen der Fall und es gibt keine separaten Kartendateien. Da besonders Rubin und Python sehr verbreitet sind, bin ich mir nicht einig, was es "typisch" bedeuten würde.
Eis
4
  • Ich würde anfangen, einen Code-Analysator zu verwenden, um zu überprüfen, ob dies toter Code ist
  • Ich würde anfangen, meine Tests zu überprüfen und zu versuchen, den Code zu erreichen. Wenn ich den Code in einem Testfall nicht erreichen kann, ist er möglicherweise tot
  • Ich würde den Code entfernen und stattdessen eine Ausnahme auslösen. Bei einem Release ist die Ausnahme aktiviert und bei dem zweiten Release kann die Ausnahme entfernt werden. Setzen Sie aus Sicherheitsgründen ein Notfall-Flag (in Java eine Systemeigenschaft), um den ursprünglichen Code zu aktivieren, wenn ein Kunde die Ausnahme bemerkt. So kann die Ausnahme deaktiviert und der ursprüngliche Code in einer Produktionsumgebung aktiviert werden.
Markus Lausberg
quelle
6
-1. Es ist absolut nicht empfehlenswert, diese Änderungen in Produktivcode, Sicherheitsflag oder nicht vorzunehmen. Nur wenn man sicher ist, dass der fragliche Code nicht verwendet wird, sollte er im produktiven Code entfernt werden. Diese Art des Herumspielens ist genau der Grund, warum es immer unterschiedliche Produktiv- und Testumgebungen geben sollte.
Johannes Hahn
3
Dies funktioniert in der Fantasie, wenn die Testabdeckung fast 90% beträgt, aber wenn nicht, haben Sie ein Projekt mit 100.000 Codezeilen. Das ist, warum ich beschrieben habe, um zu versuchen, den Code zu testen, und wenn kein Test in der Lage ist, den Code zu erreichen ... könnte er tot sein.
Markus Lausberg
IMHO Wenn Sie nicht sicher genug sind, den Code nicht vollständig zu entfernen - Sie sollten keine Ausnahmen in der Produktion auslösen -, ist die vom OP vorgeschlagene Protokollierung eine viel bessere Alternative
Sebi
@ JohannesHahn Ich denke, Sie meinen "Produktionscode", der Code, der in einer Produktionsumgebung ausgeführt wird.
jpmc26
@ jpmc26 Ja natürlich.
Johannes Hahn
3

Nicht erreichbaren Code entfernen

In einer prinzipiell statisch typisierten Sprache sollten Sie immer wissen, ob der Code tatsächlich erreichbar ist oder nicht: entfernen Sie ihn, kompilieren Sie ihn, wenn kein Fehler vorliegt, war er nicht erreichbar.

Leider sind nicht alle Sprachen statisch typisiert und nicht alle statisch typisierten Sprachen sind prinzipiell. Mögliche Fehler sind (1) Reflexion und (2) grundlose Überladung.

Wenn Sie eine dynamische Sprache oder eine Sprache mit ausreichend leistungsstarker Reflektion verwenden, sodass möglicherweise zur Laufzeit über Reflektion auf den untersuchten Code zugegriffen werden kann, können Sie sich nicht auf den Compiler verlassen. Zu diesen Sprachen gehören Python, Ruby oder Java.

Wenn Sie eine Sprache mit einer prinzipienlosen Überladung verwenden, kann durch das Entfernen einer Überladung die Überlastungsauflösung einfach stillschweigend auf eine andere Überlastung umgeschaltet werden. In einigen dieser Sprachen können Sie eine Warnung / einen Fehler zur Kompilierungszeit programmieren, die / der mit der Verwendung des Codes zusammenhängt. Andernfalls können Sie sich nicht auf den Compiler verlassen. Zu diesen Sprachen gehören Java (Verwendung @Deprecated) oder C ++ (Verwendung [[deprecated]]oder = delete).

Wenn Sie also nicht das große Glück haben, mit strengen Sprachen zu arbeiten (was Rust in den Sinn kommt), können Sie sich wirklich in den Fuß schießen, indem Sie dem Compiler vertrauen. Und leider sind Testsuiten in der Regel unvollständig, sodass auch nicht viel mehr geholfen werden kann.

Cue den nächsten Abschnitt ...


Entfernen von möglicherweise nicht verwendetem Code

Wahrscheinlicher ist, dass tatsächlich auf den Code verwiesen wird, Sie vermuten jedoch , dass in der Praxis die darauf verweisenden Codezweige niemals verwendet werden.

In diesem Fall ist der Code unabhängig von der Sprache nachweislich erreichbar und es kann nur die Laufzeitinstrumentierung verwendet werden.

In der Vergangenheit habe ich erfolgreich einen 3-Phasen-Ansatz zum Entfernen solchen Codes verwendet:

  1. Protokollieren Sie auf jedem Zweig, von dem vermutet wird, dass er NICHT belegt ist, eine Warnung.
  2. Nach einem Zyklus eine Ausnahme auslösen / einen Fehler bei der Eingabe des spezifischen Codes zurückgeben.
  3. Löschen Sie nach einem weiteren Zyklus den Code.

Was ist ein Zyklus? Es ist der Zyklus der Verwendung des Codes. Zum Beispiel würde ich für eine finanzielle Bewerbung einen kurzen monatlichen Zyklus (mit Gehältern, die am Monatsende ausgezahlt werden) und einen langen jährlichen Zyklus erwarten. In diesem Fall müssen Sie mindestens ein Jahr warten, um sicherzustellen, dass keine Warnung ausgegeben wird, dass für das Inventar zum Jahresende Codepfade verwendet werden können, die ansonsten nie verwendet werden.

Hoffentlich haben die meisten Anwendungen kürzere Zyklen.

Ich empfehle, einen TODO-Kommentar mit einem Datum einzutragen und anzugeben, wann mit dem nächsten Schritt fortgefahren werden soll. Und eine Erinnerung in Ihrem Kalender.

Matthieu M.
quelle
1
Tatsächlich können Sie in C ++ Ihre verdächtige Überlastung markieren [[deprecated]], um Sites zu identifizieren, die diese Version aufrufen. Dann können Sie sie untersuchen, um festzustellen, ob sich ihr Verhalten ändert. Alternativ können Sie Ihre Überladung wie = deletefolgt definieren : In diesem Fall müssen Sie explizit Argumente verwenden, um eine der anderen Versionen zu verwenden.
Toby Speight
@TobySpeight: Das ist wahr und auch eine gute Alternative. Lassen Sie mich das nachbearbeiten.
Matthieu M.
"Doktor, es tut weh, wenn ich das tue." "Nun tu das nicht! " Benutze keine Ansätze, die den Code unhandlich machen.
2

Das Entfernen von Code aus der Produktion ist wie das Reinigen eines Hauses. In dem Moment, in dem Sie einen Gegenstand vom Dachboden wegwerfen, bringt Ihre Frau Sie am nächsten Tag um, weil Sie das Heimkehrgeschenk des dritten Neffen ihrer Urgroßmutter von ihrem 1923 verstorbenen Nachbarn weggeworfen haben.

Denken Sie ernsthaft daran, dass Sie nach einer kurzen Analyse mit verschiedenen Tools, die bereits von allen erwähnt wurden, und nach der Verwendung des bereits erwähnten Ansatzes der schrittweisen Abschreibung möglicherweise vom Unternehmen verschwunden sind, wenn die eigentliche Entfernung stattfindet. Es ist unerlässlich, den Code zu belassen und seine Ausführung protokollieren zu lassen und sicherzustellen, dass alle Warnungen bezüglich seiner Ausführung definitiv an Sie (oder Ihre Nachfolger und Beauftragten) übermittelt werden.

Wenn Sie diesen Ansatz nicht befolgen, werden Sie wahrscheinlich von Ihrer Frau getötet. Wenn Sie den Code behalten (wie jedes Andenken), können Sie sich darauf verlassen, dass Moores Gesetz zu Ihrer Rettung beiträgt und die Kosten für Speicherplatz, den der Code verbraucht, der sich wie ein "Stein in meinem Schuh" anfühlt, jeden verringern Jahr und Sie riskieren nicht, das Zentrum mehrerer Klatsch und seltsame Blicke in den Gängen des Wasserkühlers zu werden.

PS: Um als Antwort auf einen Kommentar zu klären ... Die ursprüngliche Frage lautet "Wie löscht man sicher ...". Natürlich wird in meiner Antwort die Versionskontrolle vorausgesetzt. Genau wie das Graben im Müll, um das Wertvolle zu finden, wird angenommen. Kein vernünftiger Körper wirft Code weg und die Versionskontrolle sollte Teil der Strenge eines jeden Entwicklers sein.

Das Problem betrifft Code, der möglicherweise überflüssig ist. Wir können niemals wissen, dass ein Teil des Codes überflüssig ist, es sei denn, wir können garantieren, dass 100% der Ausführungspfade ihn nicht erreichen. Und es wird angenommen, dass dies eine Software ist, die groß genug ist, dass diese Garantie so gut wie unmöglich ist. Und wenn ich die Frage nicht falsch lese, ist der gesamte Konversationsthread nur für Fälle relevant, in denen der entfernte Code aufgerufen wird und daher ein Laufzeit- / Produktionsproblem vorliegt. Die Versionskontrolle rettet niemanden, der aufgrund von Produktionsfehlern in Verzug ist. Daher ist der Kommentar zu "Versionskontrolle" nicht relevant für die Frage oder meinen ursprünglichen Punkt, dh über einen extrem langen Zeitraum hinweg wird die Versionskontrolle ordnungsgemäß abgelehnt, wenn Sie dies wirklich tun müssen.

IMHO ist der Kommentar überflüssig und ist ein Kandidat für die Entfernung.

LMSingh
quelle
12
Wenn ich das Äquivalent zur Versionskontrolle hätte , könnte der Einwand meiner Frau leicht rückgängig gemacht werden. Auch beim Löschen von Code: Es ist kein Morddelikt. Das Repository wird niemals weggeworfen.
JDługosz
Ich dachte, dass objektorientierte Programmierung den Umfang einschränken sollte, in dem eine Methode aufgerufen werden kann. Es sollte also zu Code führen, der einfacher zu verstehen und zu verwalten ist, oder? Warum machen wir es sonst so?
@nocomprende Nirgendwo in diesem Thread wird angegeben, dass die Diskussion nur auf OOP-Design / -Sprachen beschränkt ist. Ich bin mir nicht sicher, warum Sie das für relevant halten.
Underscore_d
1

Vielleicht ist der Compiler nicht feststellen , dass es einfach nicht viel Aufhebens machen.

Führen Sie einen Build mit vollständigen, auf die Größe ausgerichteten Compiler-Optimierungen aus. Löschen Sie dann den verdächtigen Code und führen Sie den Build erneut aus.

Vergleichen Sie die Binärdateien. Wenn sie identisch sind, hat der Compiler den Code bemerkt und unbemerkt gelöscht. Sie können es sicher aus der Quelle löschen.

Wenn die Binärdateien unterschiedlich sind ... dann ist es nicht schlüssig. Es könnte eine andere Veränderung sein. Einige Compiler enthalten sogar Datum und Uhrzeit der Kompilierung in der Binärdatei (und möglicherweise kann sie auch entfernt konfiguriert werden!).

Emilio M Bumachar
quelle
1
Nicht alle Sprachen werden kompiliert, nicht alle Compiler verfügen über Optimierungen und nicht alle Optimierungen sind gleich. Viele entfernen nicht aufgerufenen Code nicht, nur für den Fall, dass dieser Code aus einem bestimmten Grund vorhanden ist. Wenn sich der Code in einer gemeinsam genutzten Bibliothek / DLL befindet, wird er nicht gelöscht.
Steve Barnes
1
@SteveBarnes Ja, wenn Sie nicht LTO ausführen und alles statisch verknüpfen, haben Sie Schmerzen. Das ist eine gegebene.
Navin
1

Ich bin kürzlich auf genau diese Situation gestoßen, mit einer Methode namens "deleteFoo". Nirgendwo in der gesamten Codebasis wurde dieser String anders als in der Methodendeklaration gefunden, aber ich habe klugerweise eine Protokollzeile oben in der Methode geschrieben.

PHP:

public function deleteFoo()
{
    error_log("In deleteFoo()", 3, "/path/to/log");
}

Es stellt sich heraus, dass der Code verwendet wurde! Einige AJAX-Methoden rufen "method: delete, elem = Foo" auf, das dann verkettet und mit call_user_func_array () aufgerufen wird .

Wenn Sie Zweifel haben, melden Sie sich! Wenn Sie nicht genügend Zeit haben, ohne das Protokoll gefüllt zu sehen, sollten Sie den Code entfernen. Aber selbst wenn Sie den Code entfernen, belassen Sie das Login und einen Kommentar mit dem Datum, damit der Typ, der ihn warten muss, den Commit in Git leichter finden kann!

dotancohen
quelle
Es gibt Bibliotheken für PHP und Perl namens Tombstone (php: github.com/scheb/tombstone ), die hier nützlich sein können.
Alister Bulman
0

Verwenden Sie grepoder welche Tools Sie zuerst zur Verfügung haben, finden Sie möglicherweise Verweise auf den Code. (Ursprünglich nicht meine Anweisung / mein Rat.)

Entscheide dann, ob du riskieren willst, den Code zu entfernen, oder ob mein Vorschlag Verwendung finden könnte:

Sie können die Funktion / den Codeblock so ändern, dass er in eine Protokolldatei geschrieben wird. Wenn keine solche Meldung jemals in der Protokolldatei aufgezeichnet wurde, können Sie den Protokollierungscode wahrscheinlich entfernen.

Zwei Probleme:

  1. Abrufen des Protokolls von anderen Benutzern. Vielleicht können Sie ein globales Flag setzen, das das Programm beim Beenden zum Absturz bringt, und den Benutzer bitten, Ihnen das Fehlerprotokoll zu senden.

  2. Verfolgung des Anrufers. In einigen höheren Sprachen (z. B. Python) können Sie problemlos einen Traceback erhalten. In kompilierten Sprachen müssen Sie jedoch die Absenderadresse im Protokoll speichern und beim Beenden einen Core-Dump erzwingen (Punkt 1).
    In C sollte dies recht einfach sein: Verwenden Sie einen bedingten Block (z. B. #ifdef ... #endif), um dies nur zu verwenden, wenn Sie wissen, dass es funktioniert (und getestet haben, dass es funktioniert), und lesen Sie einfach die Rücksprungadresse aus dem Stapel (möglicherweise oder möglicherweise nicht Inline-Assemblersprache erforderlich).

Das Speichern der Argumente in der Protokolldatei kann nützlich sein oder auch nicht.

Oskar Skog
quelle
0

Wenn Sie wissen, was der umgebende Code bewirkt, testen Sie ihn, um festzustellen , ob er fehlerhaft ist. Dies ist die einfachste und kostengünstigste Möglichkeit, einen Code, an dem Sie arbeiten, umzugestalten, und sollte auf jeden Fall durchgeführt werden, um Änderungen am Code zu entwickeln, an dem Sie gerade arbeiten.

Wenn Sie andererseits einen Code umgestalten, bei dem Sie nicht wissen, was er tut, entfernen Sie ihn nicht . Verstehe es zuerst und überarbeite es dann, wenn du feststellst, dass es sicher ist (und nur, wenn du feststellen kannst, dass das Überarbeiten eine angemessene Nutzung deiner Zeit ist).

Nun, es könnte einige Umstände geben (ich weiß, dass ich selbst darauf gestoßen bin), unter denen der Code, der "tot" ist, tatsächlich mit nichts verbunden ist . Zum Beispiel von einem Auftragnehmer entwickelte Codebibliotheken, die nirgendwo implementiert wurden, weil sie unmittelbar nach der Bereitstellung der App veraltet waren (warum ja, ich habe ein bestimmtes Beispiel im Sinn, woher wussten Sie das?).

Ich persönlich habe den gesamten Code entfernt, aber es ist ein großes Risiko, dass ich nicht empfehle, ihn auf die leichte Schulter zu nehmen - abhängig davon, wie viel Code sich diese Änderung möglicherweise auf Sie auswirken könnte (da immer das Potenzial besteht, dass Sie etwas übersehen haben) sollten außerordentlich vorsichtig sein und aggressive Unit-Tests durchführen, um festzustellen, ob das Entfernen dieses alten Legacy-Codes Ihre Anwendung beschädigt.

Trotzdem lohnt es sich wahrscheinlich nicht , den Code so zu entfernen. Nicht, wenn es ein ernstes Problem mit Ihrer Anwendung wird (z. B. weil die Sicherheitsscans aufgrund aufgeblähter Anwendungen nicht abgeschlossen werden können ... warum ja, ich habe immer noch ein Beispiel im Sinn), daher würde ich es nur empfehlen, wenn Sie dies erreichen Eine solche Situation, in der der Code wirklich auf eine wirkungsvolle Weise zu faulen begonnen hat.

Kurz gesagt: Wenn Sie wissen, was der Code bewirkt, testen Sie ihn zuerst. Wenn Sie dies nicht tun, können Sie es wahrscheinlich in Ruhe lassen. Wenn Sie wissen, dass Sie es nicht alleine lassen können, widmen Sie Ihre Zeit dem aggressiven Testen der Änderung, bevor Sie die Änderung implementieren.

Zibbobz
quelle
0

Mein Ansatz, den ich in diesem Fall immer als Industriestandard angenommen habe, wurde bisher komischerweise nicht erwähnt:

Holen Sie sich ein zweites Paar Augen.

Es gibt verschiedene Arten von "unbenutztem Code", und in einigen Fällen ist das Löschen angebracht, in anderen Fällen sollten Sie eine Umgestaltung vornehmen, und in anderen Fällen rennen Sie so weit wie möglich davon und schauen niemals zurück. Sie müssen herausfinden, um welches es sich handelt und am besten mit einem erfahrenen zweiten Partner zusammenarbeiten! - Entwickler, der mit der Codebasis sehr vertraut ist. Dadurch wird das Risiko eines unnötigen Fehlers erheblich verringert, und Sie können die erforderlichen Verbesserungen vornehmen, um die Codebasis in einem wartbaren Zustand zu halten. Und wenn Sie dies nicht tun, werden Ihnen irgendwann die Entwickler ausgehen, die mit der Codebasis sehr vertraut sind.

Ich habe auch den Protokollierungsansatz gesehen - genauer gesagt, ich habe den Protokollierungscode gesehen: noch mehr toten Code, der 10 Jahre dort belassen wurde. Der Protokollierungsansatz ist recht anständig, wenn Sie über das Entfernen ganzer Features sprechen, aber nicht, wenn Sie nur einen kleinen Teil des toten Codes entfernen.

Peter
quelle
0

Die einfache Antwort auf Ihre Frage lautet, dass Sie nicht verstandenen Code nicht sicher löschen können. Dazu gehört auch, dass Sie nicht verstehen, wie er aufgerufen wird. Es besteht ein gewisses Risiko.

Sie müssen beurteilen, wie Sie dieses unvermeidbare Risiko am besten mindern können. Andere haben die Protokollierung erwähnt. Das Protokollieren kann natürlich beweisen, dass es verwendet wird, kann aber nicht beweisen, dass es nicht verwendet wird. Da das Hauptproblem bei totem Code darin besteht, dass er gewartet wird, können Sie möglicherweise einen Kommentar hinzufügen, der besagt, dass es sich vermutlich um toten Code handelt, und keine Wartungsarbeiten daran vornehmen.

Wenn sich der Code in der Quellcodeverwaltung befindet, können Sie immer herausfinden, wann er hinzugefügt wurde, und bestimmen, wie er dann aufgerufen wurde.

Letztendlich verstehst du es entweder, lässt es in Ruhe oder nutzt eine Chance.

jmoreno
quelle
0

Falls der Entwickler des fraglichen Codes noch verfügbar ist, überprüfen Sie die Entfernung des Codes mit ihm . Außerdem lesen Kommentare im Code .

Sie erhalten die richtige Erklärung, warum dieser Code hinzugefügt wurde und für welche Funktion er dient. Es kann leicht eine Unterstützung für den spezifischen Anwendungsfall sein, oder Sie verfügen möglicherweise nicht über genügend Fachwissen, um beurteilen zu können, ob dies wirklich nicht erforderlich ist. Im Extremfall kann es vorkommen, dass alle freien Anweisungen aus einem C-Programm entfernt werden und nichts Falsches bemerkt wird (es kann einige Minuten dauern, bis der Speicher voll ist).

Es ist wirklich eine schlechte Kultur, wenn der Autor des Codes neben Ihnen sitzt, aber Sie sehen keinen Grund zum Reden, weil Sie sicher sind, dass er nur schlechten Code schreibt und Ihr Code alles so perfekt ist. Und natürlich schreibt er nur zufällige Wörter in die Kommentare, ohne Zeit mit Lesen zu verschwenden.

Einer der wichtigsten Gründe, einen Kommentar in den Code zu schreiben, besteht darin, zu erklären, warum er auf diese Weise implementiert wurde. Sie können mit der Lösung nicht einverstanden sein, aber Sie müssen das Problem berücksichtigen.

Eine Diskussion mit dem Autor kann auch ergeben, dass der Code der historische Rest von etwas ist, das entfernt oder nie fertiggestellt wurde, und daher sicher gelöscht werden kann.

h22
quelle
-1

Ich stimme dem ersten Punkt von Markus Lausberg voll und ganz zu: Der Code sollte unbedingt mit Hilfe von Tools analysiert werden. Affengehirne sind mit dieser Art von Aufgabe nicht zu trauen !!

Die meisten Standard-Programmiersprachen können in IDEs verwendet werden, und jede IDE, die es wert ist, aufgerufen zu werden, verfügt über ein "Find for all Usages" -Feature, das genau das richtige Werkzeug für diese Art von Situation ist. (Strg + Umschalt + G in Eclipse zum Beispiel)

Natürlich: Statische Analysewerkzeuge sind nicht perfekt. Man muss sich komplizierterer Situationen bewusst sein, in denen die Entscheidung, dass die fragliche Methode aufgerufen wird, erst zur Laufzeit und nicht früher erfolgt (Aufrufe über Reflection, Aufrufe zu "eval" -Funktionen in Skriptsprachen usw.).

Johannes Hahn
quelle
5
Vielleicht sollten Affengehirne keinen Code schreiben? " Von Menschenhand unberührt " war früher ein Werbespruch. Ich stellte mir immer Gorillahände vor, die die Arbeit erledigten.
3
(Ape Gehirne schrieb die Werkzeuge auch) (Shhh! Sie werden die Geschichte ruinieren!)
1
Ich denke ihr beide habt meinen Standpunkt verfehlt. Ich habe klar gesagt, dass es keine Garantie dafür gibt, dass die statische Code-Analyse jeden Aufruf einer Methode oder Klasse findet. Es ist, wie es so schön heißt, eine statische Analyse. Es kann und sollte nicht erwartet werden, dass dynamische Aufrufe über Reflection, Eval () usw. gefunden werden. Mein Punkt ist, dass die statische Codeanalyse eine notwendige Voraussetzung für das Löschen eines Codeteils ist. Und je größer das Projekt ist, desto unwahrscheinlicher wird es, dass ein menschliches Gehirn überhaupt in der Lage ist, diese Analyse durchzuführen, geschweige denn, sie korrekt durchzuführen ...
Johannes Hahn,
1
... statische Code-Analyse ist mühsame, sich wiederholende Arbeit, die am besten von einem Computer erledigt wird. Genau die Art von Aufgabe, die zuverlässig von Computern ausgeführt werden kann, die jedoch notorisch unzuverlässig ist, wenn sie von einem Affenhirn ausgeführt wird. Letzteres sollte nur für Dinge verwendet werden, die ein Computer nicht tun kann, um diese kniffligen Überlegungen und Bewertungsaufrufe zu finden.
Johannes Hahn
1
Auch hier fehlt der Punkt. Auch wenn die Tools nicht perfekt sind, weil sie von Affenhirnen geschrieben wurden (und ich bin mir nicht sicher, ob ich das gewähren sollte! Das Berechnen von statischen Aufrufhierarchien ist nicht so schwierig), sind sie der manuellen Ausführung von Aufgaben immer noch weit überlegen. Dies ist keine Alles-oder-Nichts-Situation. Ein zu 99% zuverlässiges Tool ist immer noch einem Gehirn vorzuziehen, das mit 99% beginnt, aber nach den ersten tausend Codezeilen schnell auf viel niedrigere Raten sinkt.
Johannes Hahn
-1

Zwei Möglichkeiten:

  1. Sie haben eine Testabdeckung von über 99% : Löschen Sie den Code und machen Sie es fertig.
  2. Sie haben keine vertrauenswürdige Testabdeckung: Dann müssen Sie eine Warnung vor Verfall hinzufügen . Das heißt, Sie fügen diesem Ort Code hinzu, der etwas Vernünftiges bewirkt (protokollieren Sie eine Warnung an einem gut sichtbaren Ort, der beispielsweise nicht mit der täglichen Nutzung Ihrer Anwendung in Konflikt steht). Dann einige Monate / Jahre köcheln lassen. Wenn Sie nie ein Vorkommen davon gefunden haben, ersetzen Sie die Veraltetheit durch etwas, das eine Ausnahme auslöst. Lass das eine Weile stehen. Schließlich entfernen Sie alles vollständig.
AnoE
quelle
2
Dies scheint nichts Wesentliches über die in den vorherigen 17 Antworten gemachten und erklärten Punkte zu bieten. Sowohl Abdeckung und deprecation Warnung wurde dort bereits besprochen
gnat
@gnat, du hast recht. Als ich die Antworten zum ersten Mal gescannt habe, hatte ich aus irgendeinem Grund den Eindruck, dass ich mehrere Antworten gesehen habe, die oben nicht kurz und prägnant zu diesen beiden Punkten kamen. In der Mitte der Antworten gibt es einige davon.
AnoE