Wie kann man Tausende von Codezeilen ohne Dokumentation lesen? [geschlossen]

Zuvor suchte ich nach einem guten TimeLine-Steuerelement für ein WPF-Projekt. Ich habe in Here eine Antwort gefunden, die mich zu diesem CodePlex-Projekt führt .

Jetzt möchte ich den Code ändern, um meine kulturellen Bedürfnisse zu befriedigen. Aber es gibt einige Unstimmigkeiten!

Meine Frage ist:

Wie interagieren Sie mit so Tausenden von Codezeilen?

BEARBEITEN:

Jede Verknüpfung wird großartig sein!

Sie fügen dem Quellcode Kommentare hinzu, wenn Sie ihn ausreichend verstanden haben, um dies zu tun. Überarbeiten Sie diese Kommentare mit Nachdruck, wenn Sie mehr und mehr verstehen.

1. Schritt durch den Code
2. Benennen Sie nach Bedarf um
3. Refactor nach Bedarf
4. Wiederholen, bis Sie vollständig verstanden haben

... und der Code wird es Ihnen danken. ;-)

Führen Sie eine einzelne Aktion aus und debuggen Sie den Code (immer wieder), um herauszufinden, wie diese Aktion ausgeführt wird. Schreiben Sie dasselbe in einfacher Sprache auf, um ein besseres Verständnis zu erhalten!

Etwas, das Joel Spolsky vor langer Zeit in seinem Blog geschrieben hat (ich kann den Artikel jetzt nicht finden), ist mir in dieser Hinsicht sehr aufgefallen:

Er sagte, Code sei keine natürliche menschliche Sprache, aber als Programmierer würden wir leicht einlullen, wenn wir dachten, er sei es und wir sollten ihn als solchen lesen können. Folglich schauen sich viele von uns neuen Code an und erwarten, dass sie ihn nur "lesen" und sofort verstehen können, als ob es sich um einen Textblock in englischer Sprache handeln würde.

Ich denke also, der Schlüssel ist, einfach langsam, methodisch und wissenschaftlich zu sein. Und wie andere gesagt haben - kommentieren Sie es (und überarbeiten Sie es sogar), während Sie gehen. Fallen Sie nicht in die Denkweise von "Ich sollte es nur ansehen und sofort verstehen".

Oh, und ja, manchmal tappe ich immer noch selbst in diese Falle. "Tu was ich sage, nicht wie ich" und das alles. :)

SE-Radio hat Dave Thomas zu diesem Thema interviewt

Diese Podcast-Folge enthält viele Tipps und Techniken, um in die „Kultur“ des Projekts einzutreten und zu verstehen, wie die Ureinwohner lebten.

Ich musste dies kürzlich mit einem Projekt von über 100.000 LOC tun. Meine erste Idee war, dass es einfacher ist, Muster aus Diagrammen mit 100 oder sogar 1000 Knotenpunkten zu erkennen, als aus 100.000 Textzeilen.

Also habe ich 45 Minuten damit verbracht, ein kurzes (<100LOC) Python-Programm zu schreiben, um das zu analysieren, was ich brauchte, und die Objektbeziehungen zu zeichnen. Ich habe Graphviz Source generiert , eine sehr einfach zu generierende Sprache. (An Python ist nichts Besonderes zu bemerken: Ruby oder C # oder Common Lisp oder was auch immer könnte es auch tun.)

In anderen Projekten haben Leute Graphviz für Modulabhängigkeiten, Aufrufdiagramme, Versionshistorie und vieles mehr verwendet. Das beste Programmvisualisierungs-Meta-Tool aller Zeiten.

(Vielleicht liegt es daran, dass ich Compiler genommen habe , aber ich finde es seltsam, dass wenn ein Programmierer mit einem Problem konfrontiert ist, die Antwort immer "Programm schreiben!" Zu sein scheint, außer wenn das Problem den Quellcode eines Programms betrifft.: - )

Machen Sie im laufenden Debugger einen Schritt durch das Programm. Nur so können Sie eine neue, große Codebasis verstehen.

Verstehe, dass es wirklich keine Abkürzungen gibt, um in Fülle zu grillen. (Und wenn Sie Probleme mit dieser Phrase haben, wurde Ihre Ausbildung SCHMERZLICH vernachlässigt. Sie stammt aus "Fremder in einem seltsamen Land" von Robert A. Heinlein.)

Lesen Sie es, eine Seite nach der anderen, eine Routine nach der anderen. Füge Kommentare hinzu. Zeichnen Sie Bilder der wichtigsten Datenstrukturen. Algorithmen erkennen. Rückgriff auf Vorkenntnisse.

Widerstehen Sie der Versuchung, den Debugger zu starten. Das Debugger-Ansichtsfenster ist zu klein: Sie sehen jeweils eine Zeile, aber Sie sehen wirklich nicht, wo Sie waren oder wohin Sie gehen.

Was auch immer Sie tun, schreiben Sie so viel wie möglich auf, damit niemand in der gleichen Position landet wie Sie.

Sie müssen Hinweise verwenden. Machen Sie sich ein Bild davon, wonach Sie suchen müssen, und nutzen Sie die Suchfunktionen Ihrer Umgebung oder IDE ausgiebig, um zum gewünschten Codeabschnitt zu gelangen, an dem Sie Änderungen vornehmen müssen.

das lesen von 14 tausend zeilen java code macht keinen sinn. Die Suchfunktion ist Ihr Lebensretter

Unterschiedliche Menschen haben unterschiedliche Lernstile, so YMMV. Das erste, was ich in dieser Situation mache, ist, die gesamte Codebasis mindestens einmal durchzulesen. Das gibt mir eine allgemeine Vorstellung davon, wo sich alles befindet. Dann wähle ich einen Abschnitt aus, um ihn genauer zu untersuchen. Datenstrukturen wären ein guter Anfang. Sobald ich eine allgemeine Vorstellung davon habe, was los ist, mache ich dasselbe mit einem anderen Teil des Codes, der mit dem ersten interagiert. Nach genügend Iterationen habe ich ein gutes Gefühl dafür, wie der Code funktioniert.

Wie bei jeder Programmierung, bei der es sich nicht nur um große unkommentierte Codestücke handelt, ist es am besten, sie in Teile zu zerlegen. Dies sollten Sie sowohl im Kopf als auch im Code visuell tun. Dies kann bedeuten, dass große, fette Kommentare oder mehrere Zeilenumbrüche hinzugefügt werden. Dies hilft beim Scrollen, um die Teile zu sehen. Versuchen Sie, die logischen Codestücke zu finden.

Wenn Sie Bits verstehen, kommentieren Sie sie natürlich für das, was Sie zu dieser Zeit wussten, und notieren Sie sich möglicherweise etwas, das Sie nicht verstehen.

Ich würde auch empfehlen, nicht von Anfang an zu versuchen, das ganze Stück zu verstehen. Versuchen Sie stattdessen, die Teile zu verstehen, die Sie jetzt wissen müssen, und arbeiten Sie später an den anderen.

Ich würde damit beginnen, den Leo-Editor im @shadow-Modus mit aktiver Verwendung geklonter Knoten zu verwenden . Auf diese Weise können Sie Notizen und Kommentare für jeden zu untersuchenden Codeabschnitt hinzufügen, ohne den Code zu ändern , und die Anmerkungen stehen immer im Kontext neben dem Code, von dem sie sprechen. Hier ist ein Beispiel-Workflow für die Dokumentation:

Wenn ich beispielsweise einen Fehler in Leo behebe, erstelle ich einen normalen Knoten, um den Fehler darzustellen. Dieser Bugknoten ist meine Ansicht aller Daten in Leos Quellcode, die sich auf den Bug beziehen. Wenn ich Code in Bezug auf den Fehler entdecke, klone ich deren Knoten und verschiebe sie unter den Fehlerknoten. Ich werde auch normale Knoten als untergeordnete Knoten des Bug-Knotens hinzufügen. Diese Knoten enthalten den ursprünglichen Fehlerbericht, Beschreibungen, wie ich den Fehler behoben habe, Testdaten oder andere Hinweise, die ich möglicherweise behalten möchte.

Sobald ich den Bugknoten erstellt habe, konzentriere ich mich nur auf diesen Knoten und seine untergeordneten Knoten. Ich kann den Bugknoten und seine Kinder untersuchen, ohne um den Umriss herum springen zu müssen. Alles was ich brauche ist an einem Ort. Wenn ich herumkomme, um den Fehler tatsächlich zu beheben, kann ich dies tun, indem ich die Klone ändere. Auch hier muss ich nicht um den Umriss herum springen. Es ist egal, wie groß oder komplex die gesamte Gliederung ist: Ich beschäftige mich nur mit dem Bugknoten und seinen Kindern. Dieser extrem enge Fokus erleichtert das Beheben von Fehlern erheblich.

Zeichnen Sie Diagramme der Quelle: die Datenbeziehungen, die funktionalen Beziehungen, die Objektbeziehungen. Bestimmen Sie die Aggregation, den Datenfluss und den Codefluss. Bilder sind weitaus besser als Kommentare und können vom Code getrennt gehalten werden.

Bevor Sie etwas umgestalten, schreiben Sie Tests. Viele Tests. Sehr spezifische Tests für kleine Codeblöcke, die zumindest aufrufbar sind, da dies davon abhängt, wie Ihr ererbtes Durcheinander geschrieben wird.

Das Schreiben von Tests hat zunächst den Vorteil, dass Sie eine gewisse Kenntnis des Codes haben müssen, bevor Sie ihn testen können. Daher wird jeder Test, den Sie schreiben, hoffentlich ein wenig Wissen enthalten. Sie können die Tests neben den Behauptungen auch stark mit Ihren Annahmen kommentieren.

Wenn Sie es zuerst testen, riskieren Sie nicht, etwas im Code zu ändern, von dem Sie nichts wissen. Sie haben auch ein Sicherheitsnetz, wenn Sie kommen, um den Code umzugestalten.

Ich benutze Werkzeuge wie doxygen, um ein Gesamtklassendiagramm zu erstellen, und füge dann mein Verständnis der einzelnen Klassen hinzu.

Dann nehme ich einen einfachen Fehler aus der Fehlerwarteschlange (bevor mein Manager mir einen schweren Fehler zuweist: P), führe diese Funktion in den Debugger aus und versuche, einen groben Datenfluss oder ein Code-Fluss-Modell zu generieren.

Zum Beispiel Exportfunktionen in einer Software: Ich versuche zu verstehen, wie die Quelldaten gelesen werden, von wo im Code (Basisschnittstelle) ich die Daten richtig lesen kann, indem ich meine Klassen- und Code-Flussdiagramme verwende, für welche Klassen verantwortlich sind welche Art von Export usw. Ich denke, die Hälfte des Verständnisses ist getan, sobald Sie die Klassendiagramme und Flussdiagramme haben.

Nähern Sie sich einem unbedeutenden Fehler, z. B. einer NullPointerException. Vermeiden Sie zunächst alles, was mit Nebenläufigkeit zu tun hat, und alles, was naturgemäß das sofortige Verstehen eines Großteils des Codes erfordert.

Wenn Sie ein paar Fehler behoben haben, haben Sie wahrscheinlich eine ziemlich gute Idee. Funktioniert jedenfalls für mich.

Grundsätzlich sollte die Aktion zum Schreiben eines sauberen Codes direkt beim Design beginnen. Wenn wir in OOP-Sprache codieren, lassen Sie sich eine UML einfallen, teilen Sie sie mit Kollegen und lassen Sie sich davon überzeugen, dass Design nicht ambivalent ist. In jedem Fall sollten wir Entwickler davon überzeugt sein, dass Design das Problem löst und keine Mehrdeutigkeiten.

Wenn es um das Codieren geht, müssen wir sicherstellen, dass das Design in Code konvertiert wird, dh eine Entität zu einer Klasse oder Struktur, eine Operation, um zu funktionieren usw.

Und ich habe ein Whitepaper durchgearbeitet: http://queue.acm.org/detail.cfm?id=2063168. Dort geht es um den Codierungsstil oder darum, wie wir Leerzeichen, Einrückungen und Schriftartvariationen verwenden können, wie die meisten IDEs, mit denen wir VIEL schreiben können CLEANER-Code, mit dem wir Menschen so viel verstehen können wie Maschinen. Es wird mehr Wert darauf gelegt, kommentarfreien Code zu schreiben, sodass unser Code selbst als Absätze angezeigt wird.