Ich bin gelegentlich unglücklich genug, Änderungen an sehr alten, schlecht nicht dokumentiert und schlecht nicht b> entworfener Code.
Es dauert oft lange, eine einfache Änderung vorzunehmen, da der vorhandene Code nicht sehr strukturiert ist und ich wirklich viel Code lesen muss, bevor ich ein Gefühl dafür habe, wo die Dinge liegen würden.
Was ich in solchen Fällen wahrscheinlich sehr hilfreich finde, ist ein Tool, mit dem man einen Überblick über den Code visualisieren und dann vielleicht sogar nach weiteren Details suchen kann. Ich vermute, dass ein solches Werkzeug sehr schwer zu bekommen wäre, wenn man versucht, Struktur zu finden, wo es wenig oder keine gibt.
Ich denke, das ist nicht wirklich eine Frage, sondern eher ein Nachdenken. Ich sollte es zu einer Frage machen - Was tun andere, um zu helfen, den Code anderer Leute zu verstehen, das Gute und das Schlechte?
Ich empfehle BOUML . Es ist ein kostenloses UML-Modellierungstool, welches:
Also: Importieren Sie Ihren Code in BOUML und sehen Sie ihn dort an, oder exportieren Sie ihn in SVG und sehen Sie ihn in Firefox an.
Hmm, das ist ein schweres, so viel zu sagen, so wenig Zeit ...
1) Wenn Sie den Code ausführen können, macht es das Leben so viel einfacher, Breakpoints (vor allem bedingte) Breakpoints sind Sie Freund.
2) Der Ansatz eines Puristen wäre, einige Komponententests für bekannte Funktionen zu schreiben, dann zu refaktorieren, um Code und Verständnis zu verbessern, und dann erneut zu testen. Wenn etwas kaputt geht, erstellen Sie weitere Komponententests - wiederholen Sie, bis Sie gelangweilt / alt / in ein neues Projekt verschoben wurden.
3) ReSharper ist gut darin zu zeigen, wo Dinge verwendet werden, was zum Beispiel eine Methode nennt, es ist statisch, aber ein guter Anfang, und es hilft beim Refactoring.
4) Viele .net-Ereignisse werden als öffentlich codiert, und Ereignisse können bei der Fehlersuche zu einem Problem werden. Rekodiere sie als privat und benutze eine Eigenschaft mit add / remove. Sie können dann den Haltepunkt verwenden, um zu sehen, was an einem Ereignis abgehört wird.
Übrigens: Ich spiele im .Net-Bereich und würde ein Tool lieben, mit dem ich diese Art von Sachen machen kann, wie Joel irgendjemand da draußen kennt, der ein gutes dynamisches Codeüberprüfungswerkzeug kennt?
Ich wurde gebeten, in der Vergangenheit den Besitz eines NASTY-Codes zu übernehmen - beide arbeiten und "spielen".
Die meisten Amateure, für die ich den Code übernommen habe, haben den Code so entwickelt, dass sie das machen, was sie über mehrere Iterationen benötigen. Es war immer ein riesiges inzestuöses Durcheinander von Bibliothek A, die B anrief, in A zurückrief, C anrief, B anrief, usw. Oft benutzten sie Threads und nicht einen kritischen Abschnitt, den man sehen konnte.
Ich fand den besten / einzigen Weg, um den Code in den Griff zu bekommen, war der Startpunkt des Betriebssystems [main ()] und erstelle mein eigenes Call-Stack-Diagramm, das den Aufrufbaum zeigt. Sie müssen nicht wirklich einen vollständigen Baum am Anfang bauen. Verfolgen Sie einfach die Abschnitte, an denen Sie in jeder Phase arbeiten, und Sie erhalten einen guten Überblick über die Dinge, damit Sie damit arbeiten können.
Um das Ganze abzurunden, benutze das größte Stück toten Baum, das du finden kannst und einen Stift. Wenn Sie alles vor sich hinlegen, damit Sie nicht auf Bildschirmen oder Seiten vor- und zurückspringen müssen, wird das Leben so viel einfacher.
EDIT: Es wird viel über Kodierungsstandards geredet ... sie werden nur dazu führen, dass schlechter Code mit gutem Code konsistent aussieht (und normalerweise schwerer zu erkennen ist). Codierungsstandards erleichtern nicht immer die Pflege von Code.
Ich mache das regelmäßig. Und haben einige Werkzeuge und Tricks entwickelt.
Das Problem dabei ist, dass Sie bei den meisten Unternehmen vom Ergebnis geschätzt werden. Aus diesem Grund schreiben manche Programmierer schlechten Code schnell und gehen zu einem anderen Projekt über. So bleibt dir der Müll und dein Chef vergleicht deinen trägen Fortschritt mit dem schnellen und schmutzigen Typen. (Zum Glück ist mein jetziger Arbeitgeber anders).
Im Allgemeinen verwende ich UML-Sequenzdiagramme verschiedener Schlüsselarten, auf denen die Komponente verwendet wird. Ich kenne keine Werkzeuge, die sie automatisch erzeugen können, aber viele UML-Werkzeuge wie BoUML und EA Sparx können Klassen / Operationen aus Quellcode erstellen, was ein wenig Tipparbeit erspart.
Der definitive Text zu dieser Situation ist die effektive Arbeit von Michael Feathers mit Legacy Code. Als S. Lott sagt, dass einige Unit-Tests durchgeführt werden, um das Verhalten des Lagacy-Codes festzustellen. Sobald Sie die in Ihnen haben, können Sie beginnen zu refactor. Es scheint ein Beispielkapitel auf der Object Mentor-Website verfügbar zu sein.
Siehe Unit Testing Legacy ASP.NET Webforms-Anwendungen , um Ratschläge zu erhalten auf älteren Apps über Komponententests.
Es gibt viele ähnliche Fragen und Antworten. Hier ist die Suche Ссылка
Der Punkt ist, dass es am einfachsten ist, sich mit Legacy vertraut zu machen, wenn Sie Komponententests für dieses Vermächtnis schreiben.
Ich hatte kein Glück mit Tools zur Automatisierung der Überprüfung von schlecht dokumentiertem / ausgeführtem Code, weil ein verwirrendes / schlecht entworfenes Programm im Allgemeinen zu einem weniger nützlichen Modell führt. Es ist nicht aufregend oder unmittelbar belohnend, aber ich hatte die besten Ergebnisse mit der Auswahl eines Spots und der Ausführung des Programms Zeile für Zeile, Dokumentieren und Hinzufügen von Kommentaren, während ich gehe, und Refactoring, wo anwendbar.
Eine gute IDE (EMACS oder Eclipse) könnte in vielen Fällen helfen. Auch auf einer UNIX-Plattform gibt es einige Tools für Cross-Referenzierung (Etags, Ctags) oder Überprüfung (Lint) oder GCC mit vielen vielen Warnoptionen eingeschaltet.
Erstens, bevor ich versuche, eine Funktion / Methode zu verstehen, würde ich sie ein wenig umgestalten, um sie an Ihre Kodierungskonventionen (Leerzeichen, Klammern, Einrückung) anzupassen und die meisten Kommentare zu entfernen, wenn sie falsch scheinen.
Dann würde ich die Teile, die Sie verstanden haben, umgestalten und kommentieren und versuchen, diese Teile über den gesamten Quellbaum zu finden und zu refaktorieren, auch dort.
Mit der Zeit bekommst du einen schöneren Code, mit dem du gerne arbeiten würdest.
Ich persönlich zeichne viel von Diagrammen und finde die Knochen der Struktur heraus.
Die Modeerscheinung (und möglicherweise zu Recht) hat mich Schreibgeräte-Tests, um meine Behauptungen zu testen, und bauen ein Sicherheitsnetz für Änderungen, die ich an das System mache.
Sobald ich an einem Punkt angelangt bin, an dem ich mich wohl genug fühle, um zu wissen, was das System macht, werde ich einen Fehler machen, um Fehler so heilsam wie möglich zu beheben, und hoffe, dass meine Sicherheitsnetze bald abgeschlossen sind.
Das bin nur ich. ;)
Ich habe tatsächlich die Refactoring-Funktionen von ReSharper verwendet, um eine Reihe von Projekten, die ich kürzlich geerbt habe, in den Griff zu bekommen. Um den sehr schlecht strukturierten undokumentierten Code eines anderen Programmierers herauszufinden, fange ich damit an, ihn zu refaktorisieren.
Wenn Sie den Code bereinigen, Methoden, Klassen und Namespaces richtig umbenennen, sind Extraktionsmethoden strukturelle Veränderungen, die Aufschluss darüber geben, was ein Code tun soll. Es klingt vielleicht widersinnig, Code zu refaktorisieren, den Sie nicht "kennen", aber trut mir, ReSharper erlaubt Ihnen wirklich, dies zu tun. Nehmen Sie zum Beispiel das Problem des Codes für roten Hering. Sie sehen eine Methode in einer Klasse oder vielleicht eine merkwürdig benannte Variable. Sie können damit beginnen, nach Verwendungen zu suchen oder, unggh, eine Textsuche durchführen, aber ReSharper wird toten Code tatsächlich erkennen und grau einfärben. Sobald Sie eine Datei öffnen, sehen Sie in grauer Farbe und mit Scroll-Bar-Flags, was in der Vergangenheit rote Heringe verwirren würde.
Es gibt Dutzende von anderen Tricks und wahrscheinlich eine Reihe von anderen Tools, die ähnliche Dinge tun können, aber ich bin ein ReSharper junky.
Prost.
Lernen Sie die Software aus der Sicht eines Benutzers genau kennen. Über die zugrundeliegende Struktur kann viel gelernt werden, indem man die Benutzeroberfläche (n) studiert und mit ihnen interagiert.
Über das arme Ding schreiben zu können, ist die nützlichste Methode für mich. Normalerweise stelle ich viel "huh, das ist lustig ..." auf, während ich versuche, grundlegende Code-Struktur-Diagramme zu erstellen, die sich am Ende als nützlicher erweisen als die Diagramme selbst. Automatisierte Tools sind wahrscheinlich hilfreicher, als ich ihnen zuschreibe, aber der Wert, diese witzigen Bits zu finden, übersteigt den Wert von schnell erzeugten Diagrammen für mich.
Bei Diagrammen suche ich meistens, wohin die Daten gehen. Wo kommt es her, wo endet es und was passiert auf dem Weg? Im Allgemeinen scheint das, was mit den Daten passiert, einen guten Eindruck vom Gesamtlayout zu geben, und einige Knochen, auf die ich zurückkommen werde, wenn ich umschreibe.
Wenn ich an altem Code arbeite, versuche ich nicht, das gesamte System zu verstehen. Das würde zu einer Überlastung der Komplexität und einer anschließenden Explosion des Gehirns führen.
Vielmehr nehme ich ein einzelnes Merkmal des Systems und versuche, von Ende zu Ende vollständig zu verstehen, wie es funktioniert. Ich werde im Allgemeinen in den Code debuggen, beginnend mit dem Punkt im UI-Code, wo ich die spezifische Funktionalität finde (da dies normalerweise das einzige ist, was ich zuerst finden kann). Dann führe ich einige Aktionen in der GUI aus und drehe den Code bis hinunter in die Datenbank und dann wieder hoch. Dies führt normalerweise zu einem vollständigen Verständnis von mindestens einem Merkmal des Systems und gibt manchmal auch Einblick in andere Teile des Systems.
Sobald ich verstanden habe, welche Funktionen aufgerufen werden und welche gespeicherten Prozeduren, Tabellen und Ansichten involviert sind, durchsuche ich den Code, um herauszufinden, welche anderen Teile der Anwendung auf dieselben Funktionen / Procs angewiesen sind. So finde ich heraus, ob eine Änderung, die ich vornehmen werde, irgendetwas anderes im System zerstören wird.
Es kann manchmal auch nützlich sein, Diagramme der Datenbank- und / oder Codestruktur zu erstellen, aber manchmal ist es nur so schlecht oder so wahnsinnig komplex, dass es besser ist, das System als Ganzes zu ignorieren und sich nur auf den Teil zu konzentrieren Sie müssen sich ändern.
Mein großes Problem ist, dass ich (momentan) sehr große Systeme in relativ kurzer Zeit zu verstehen habe (ich bedauere Vertragsentwickler in diesem Punkt) und habe nicht viel Erfahrung dabei (nachdem ich vorher Glück gehabt hatte) genug, um derjenige zu sein, der von Grund auf entwirft.)
Eine Methode, die ich benutze, ist zu versuchen, die Bedeutung der Benennung von Variablen, Methoden, Klassen usw. zu verstehen. Dies ist nützlich, weil sie (hoffentlich zunehmend) eine hochrangige Sicht auf einen Gedankengang von einer atomaren Ebene einbettet .
Ich sage das, weil Entwickler in der Regel ihre Elemente (mit dem, was sie glauben) nennenswert benennen und einen Einblick in ihre beabsichtigte Funktion geben. Dies ist allerdings fehlerhaft, wenn der Entwickler ein mangelhaftes Verständnis ihres Programms hat, versucht die Terminologie oder (oft der Fall, imho) clever zu klingen. Wie viele Entwickler haben Schlüsselwörter oder Klassennamen gesehen und erst dann den Begriff im Wörterbuch zum ersten Mal nachgeschlagen?
Es geht um die Standards und Codierungsregeln, die Ihr Unternehmen verwendet.
Wenn jeder Code anders codiert, dann ist es schwierig, anderen Programmcode usw. zu verwalten, wenn Sie sich entscheiden, welchen Standard Sie benutzen wollen, haben Sie einige Regeln. Alles wird gut. Anmerkung: Das müssen Sie nicht machen eine Menge Regeln, weil Leute die Möglichkeit haben sollten, im Stil zu schreiben, den sie mögen, sonst kann man sehr überrascht sein.
Tags und Links legacy visualization legacy-code