Erhalten Sie Ihren Kopf um andere Leute Code

StackOverflow https://stackoverflow.com/questions/479479

Frage

Ich bin gelegentlich unglücklich genug, um Änderungen vorzunehmen, um sehr alter, schlecht nicht dokumentiert und schlecht nicht entworfen Code.

Es dauert oft eine lange Zeit, um eine einfache Änderung zu machen, weil es nicht viel Struktur an dem vorhandenen Code ist, und ich habe wirklich eine Menge Code zu lesen, bevor ich ein Gefühl dafür haben, wo die Dinge wäre.

Was ich denke, eine Menge in Fällen helfen würde, wie dies ein Werkzeug, das man einen Überblick über den Code, und dann vielleicht sogar einen Drilldown für weitere Einzelheiten erlauben würde, zu visualisieren. Ich vermute, dass ein solches Werkzeug wäre sehr schwer richtig zu machen, da versucht Struktur zu finden, wo es wenig oder gar keine ist.

Ich denke, das ist nicht wirklich eine Frage ist, sondern ein musing. Ich sollte es in eine Frage stellen? - Was andere tun in immer ihren Kopf um andere Völker Code zu helfen, die guten und die schlechten

War es hilfreich?

Lösung

Ich empfehle BOUML . Es ist ein freies UML-Modellierungstool, das:

  • ist extrem schnell (schnellste UML-Tool aller Zeiten Besuche Benchmarks )
  • hat rock solid C ++ Import-Unterstützung,
  • hat große SVG-Export-Unterstützung, was wichtig ist, da sieht große Graphen im Vektor-Format, die schnell in z.B. skaliert Firefox, ist sehr bequem (man kann schnell zwischen „Vogelperspektive“ -Ansicht und Klassendetailansicht),
  • ist voll funktionsfähige, intensiv entwickelt (siehe Entwicklungsgeschichte , ist es schwer zu glauben, dass so schnell Fortschritte möglich).

So: Ihr Code in BOUML importieren und dort sehen, oder den Export nach SVG und sieht es in Firefox

.

Andere Tipps

Hmm, das ist ein harter, so viel so wenig Zeit zu sagen ...

1) Wenn Sie den Code ausführen kann es das Leben viel einfacher soooo macht, Haltepunkte (vor allem bedingt) Sollbruchstellen sind Sie Freund.

2) Ansatz A Puristen wäre ein paar Unit-Tests zu schreiben, für die bekannte Funktionalität, dann Refactoring Code und das Verständnis zu verbessern, dann erneut zu testen. Wenn die Dinge zu brechen, dann mehr Unit-Tests schaffen - wiederholen, bis bored / alte / neue Projekt verschoben

3) ReSharper zu zeigen, gut ist, wo die Dinge verwendet werden, was ein Verfahren zum Beispiel ruft, es ist statisch, sondern ein guter Anfang, und es hilft bei der Refactoring.

4) Viele .net Ereignisse werden als öffentliche codiert und Ereignisse können am besten Zeiten ein Schmerz zu debuggen sein. Recode sie privat sein und eine Eigenschaft mit Hinzufügen / Entfernen verwenden. Sie können dann Bruchstelle verwenden, um zu sehen, was auf ein Ereignis zu hören.

BTW - ich bin in dem .Net Raum zu spielen, und würde ein Werkzeug, um diese Art von Sachen zu tun lieben, wie Joel hat jemand da draußen weiß von einem guten dynamischem Code Überprüfung Werkzeug

?

Ich habe das Eigentum an irgendwelchen fiesen Code in der Vergangenheit nehmen gefragt - beide arbeiten und „spielen“.

Die meisten der Amateure ich über Code gedauert hat war einfach irgendwie den Code entwickelt zu tun, was sie mehrere Iterationen benötigt über. Es war immer ein Riese inzestuös Sie von Bibliothek A calling B, zurück in A rief, C Anrufe, Anrufe B usw. Einen großen Teil der Zeit sie Threads verwenden würde und nicht ein kritischer Abschnitt sehen war.

finde ich den besten / einzigen Weg, einen Griff auf dem Code erhalten wurde in dem O Einstiegspunkt beginnen [main ()] und meine eigen Call-Stack Diagramm, das die Aufrufstruktur zeigt bauen. Sie brauchen nicht wirklich einen vollständigen Baum am Anfang zu bauen. Spuren nur durch den Abschnitt (en) Sie arbeiten in jeder Phase auf und Sie werden eine gut genug Griff auf die Dinge in der Lage sein zu laufen mit ihm.

Zu allem aus, verwenden Sie das größte Stück von totem Baum Sie und einen Stift finden. Legen sie alle aus vor Ihnen, damit Sie müssen nicht vor und zurück springen auf Bildschirmen oder Seiten macht das Leben so viel einfacher.

EDIT: Es gibt eine Menge Gerede über Standards Codierung ... sie werden nur schlechter Code aussieht im Einklang mit gutem Code (und in der Regel schwieriger zu erkennen). Coding Standards nicht immer Code einfacher zu halten.

Ich tue dies in regelmäßigen Abständen. Und haben einige Werkzeuge und Tricks entwickelt.

  • Versuchen Sie, eine allgemeine Übersicht (Objekt Diagramm oder andere) zu erhalten.
  • Dokumentieren Sie Ihre Ergebnisse.
  • Testen Sie Ihre Annahmen (vor allem für vageen Code).

Das Problem dabei ist, dass bei den meisten Firmen, die Sie von Ergebnis geschätzt werden. Deshalb einige Programmierer schnell schlechten Code zu schreiben und zu einem anderen Projekt bewegen. So sind Sie mit dem Müll links, und Ihr Chef vergleicht Ihre träge Fortschritte mit dem schnellen und dirtu Kerl. (Zum Glück ist mein derzeitiger Arbeitgeber ist anders).

Ich verwende im allgemeinen UML-Sequenzdiagramme verschiedener Schlüssel Möglichkeiten, die die Komponente verwendet wird. Ich weiß nicht, von Werkzeugen, die sie automatisch generieren können, aber viele UML-Tools wie BOUML und EA Sparx können Klassen / Operationen aus dem Quellcode erstellen, die weniger tippen müssen.

Der endgültige Text auf dieser Situation ist Michael Feathers' Effektives Arbeiten mit Legacy-Code. Wie S. Lott sagt einige Unit-Tests erhalten im Verhalten des lagacy Code zu etablieren. Sobald Sie die in Sie können Refactoring beginnen. Es scheint ein Beispielkapitel verfügbar auf der Object Mentor Website.

Siehe Unit Testing Vermächtnis ASP.NET Webforms Anwendungen für Beratung den Griff bekommen auf Legacy-Anwendungen über Unit-Tests.

Es gibt viele ähnliche Fragen und Antworten. Hier ist die Suche https://stackoverflow.com/search?q=unit+test+legacy

Der Punkt ist, dass Sie Ihren Kopf um Vermächtnis bekommen ist wahrscheinlich am einfachsten, wenn Sie Unit-Tests schreiben, für das Erbe.

Ich habe nicht viel Glück mit Werkzeugen hat die Überprüfung von schlecht dokumentiert / ausgeführten Codes zu automatisieren, verursacht ein verwirrendes / schlecht konzipiertes Programm im Allgemeinen auf einen weniger übersetzt als nützliches Modell. Es ist nicht spannend oder sofort lohnend, aber ich habe die besten Ergebnisse hat mit einem Punkt Kommissionierung und im Anschluss an die Programmausführung Zeile für Zeile, zu dokumentieren und das Hinzufügen von Kommentaren, wie 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 Werkzeuge für crossreferencing (etags, ctags) oder Kontrolle (lint) oder gcc mit vielen vielen Warnung Optionen aktiviert.

Zuerst, bevor Sie eine Funktion / Methode zu verstehen versuchen, würde ich es ein wenig Refactoring Ihre Codierungskonventionen (Leerzeichen, Klammern, Vertiefung), und entfernen Sie die meisten Kommentare zu passen, wenn sie falsch zu sein scheinen.

Dann würde ich Refactoring und die Teile kommentieren Sie verstanden, und versuchen, die Teile über den gesamten Quellbaum zu finden / grep und Refactoring sie dort auch.

Im Laufe der Zeit Sie ein schöneres Code erhalten Sie gerne arbeiten.

Ich persönlich viel Zeichnung von Diagrammen und die Knochen der Struktur herauszufinden.

Der fad de jour (und möglicherweise zu Recht ganz) hat mich Unit-Tests zu schreiben meine Behauptungen zu testen und baut ein Sicherheitsnetz für Änderungen bis ich an dem System zu machen.

Wenn ich zu einem Punkt, wo ich mich wohl genug bin zu wissen, was das System tut, ich werde einen Stich nehme auf Fehler in der vernünftigste Art und Weise möglich Fixierung und hoffe, dass meine Sicherheitsnetze Vollendung näherten.

Das ist nur ich, aber. ;)

Ich habe actuaally die Refactoring-Funktionen von ReSharper wurde mit helfen m einen Griff auf einer Reihe von Projekten zu erhalten, die ich vor kurzem geerbt. Also, um ganz anderer Programmierer herauszufinden, schlecht strukturiert, nicht dokumentierte Code, beginne ich eigentlich durch Refactoring.

den Code Aufräumen, Umbenennen Methoden, Klassen und Namespaces richtig sind Extrahieren Methoden alle strukturellen Veränderungen, die Licht auf das, was ein Stück Code vergießen tun soll. Es könnte nicht eingängig klingen Code Refactoring, dass Sie nicht „wissen“, aber trut mich, ReSharper können Sie wirklich, dies zu tun. Nehmen Sie zum Beispiel der Frage des Ablenkungsmanöver toten Code. Sie sehen eine Methode in einer Klasse oder vielleicht ein seltsam benannten Variablen. Sie können versuchen, Nachschlag Nutzungen oder ungh, führen Sie eine Textsuche starten, aber ReSharper tatsächlich tot Code erkennen und graue Farbe. Sobald Sie eine Datei, die Sie in grau sehen öffnen und mit Bildlaufleiste Fahnen, was in der Vergangenheit war verwirrend falsche Fährten haben.

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.

Holen Sie sich das Software vertraut aus Anwender Sicht kennen zu lernen. Viele können die zugrunde liegende Struktur durch das Studium und die Interaktion mit der Benutzeroberfläche (s).

erlernbar
  • Ausdrucke
  • Whiteboards
  • Lots of Briefpapier
  • Lots of Starbucks

Die Möglichkeit, alle über die schlechte Sache kritzeln ist die nützlichste Methode für mich. Normalerweise aufdrehen ich eine Menge „huh, das ist lustig ...“ bei dem Versuch, Grundcodestrukturdiagramme zu machen, die mehr nützlich erweisen als die Diagramme selbst am Ende. Automatisierte Tools sind wahrscheinlich hilfreicher als ich ihnen Kredit für, aber der Wert dieser lustigen Bits zu finden, übersteigt den Wert schnell erzeugt Diagramme für mich.

Für Diagramme, suche ich meistens, wo die Daten gehen. Wo es in kommt, wo hört sie auf, und was es auf dem Weg nicht gehen. Im Allgemeinen, was geschieht mit den Daten, die einen guten Eindruck von der Gesamt-Layout zu geben scheint, und einige Knochen wieder zu kommen, wenn ich neu zu schreiben.

Wenn ich auf Legacy-Code bin arbeiten, versuche ich nicht das gesamte System zu verstehen. Dass die Komplexität Überlastung führen würde und die anschließende Gehirn Explosion.

Rather, ich nehme ein einziges Merkmal des Systems und versuchen, vollständig zu verstehen, wie es funktioniert, von einem Ende zum anderen. Ich werde im Allgemeinen den Code debuggen in, von dem Punkt, in dem UI-Code beginnen, wo ich die spezifische Funktionalität finden können (da dies in der Regel das einzige, was ich in der Lage sein werde zunächst zu finden). Dann werde ich eine Aktion in der GUI durchführen, und Drill-Down im Code den ganzen Weg hinunter in die Datenbank und dann sichern. Dies führt in der Regel in ein vollständiges Verständnis von mindestens einem Merkmal des Systems, und manchmal Einblick in andere Teile des Systems gibt auch.

Wenn ich verstehe, was Funktionen aufgerufen werden und welche gespeicherten Prozeduren, Tabellen und Ansichten beteiligt sind, kann ich dann eine Suche durch den Code, um herauszufinden, was andere Teile der Anwendung verlassen sich auf diese gleichen Funktionen / Procs. Dies ist, wie ich, ich werde, wenn eine Änderung erfahren, um irgendetwas anderes im System brechen machen.

Es kann manchmal auch nützlich sein, um zu versuchen, Diagramme der Datenbank und / oder Code-Struktur zu machen, aber es ist manchmal nur so schlecht oder so irrsinnig komplex, dass es besser ist, das System als Ganzes zu ignorieren und konzentrieren sich nur auf den Teil, der Sie müssen sich ändern.

Mein großes Problem ist, dass ich (derzeit) haben sehr große Systeme in einer ziemlich kurzen Zeit (ich bedaure Vertrag Entwickler in diesem Punkt) und haben nicht viel Erfahrung dies zu tun (nachdem zuvor hatte das Glück, zu verstehen, genug, um die eine von Grund auf neu entwerfen zu sein.)

Eine Methode, die ich nutze, um zu versuchen, die Bedeutung der Benennung von Variablen zu verstehen, Methoden, Klassen, etc. Dies ist nützlich, weil es (hoffentlich immer) eine hochrangige Ansicht eines Gedankengang von atomarer Ebene einbettet .

Ich sage dies, weil in der Regel werden die Entwickler ihre Elemente benennen (mit dem, was sie glauben) sind sinnvoll und Einblick in ihre bestimmungsgemäße Funktion bereitstellt. Dies ist fehlerhaft, zugegebenermaßen, wenn der Entwickler ein defektes Verständnis ihres Programms hat, die Terminologie oder (oft der Fall, imho) versucht, schlau zu klingen. Wie viele Entwickler haben Schlüsselwörter oder Klassennamen gesehen und erst dann nachgeschlagen den Begriff im Wörterbuch, zum ersten Mal?

Es ist alles über die Standards und Codierungsregeln Ihres Unternehmens verwendet.

Wenn alle Codes in verschiedenen Stil, dann ist es schwer, andere Programmierer den Code zu erhalten und usw., wenn Sie entscheiden, welche Faktoren man einige Regeln verwenden werden müssen, wird alles gut :) Hinweis sein: dass Sie müssen nicht machen viele Regeln, weil die Menschen die Möglichkeit in Stil, den sie mögen, andernfalls können Sie sehr überrascht sein.

zu codieren haben sollte
Lizenziert unter: CC-BY-SA mit Zuschreibung
Nicht verbunden mit StackOverflow
scroll top