Wie verfolgen Sie große Projekte?

Bei einem Projekt mit vielen verschiedenen Dateien habe ich immer den Überblick darüber, wie die Teile miteinander interagieren. Ich hatte nie wirklich große Probleme, kleinere Komponenten isoliert zu verstehen, aber mit zunehmender Komplexität des Projekts kann ich mir nicht vorstellen, was vor sich geht. Ich bemerke dies besonders bei OOP-Projekten, da die Anzahl der Methoden und Quelldateien zunimmt.

Mein Hintergrund: Ich bin ein autodidaktischer Webprogrammierer. Ich habe mich hauptsächlich mit Python für schnelle und schmutzige Skripte beschäftigt, aber ich habe auch ein paar grundlegende Django- Projekte gemacht. Ich mag Web-Frameworks wie flask , weil ich durch die Einfachheit eines Layouts mit nur einer Datei (meistens) leicht verfolgen kann, was gerade vor sich geht.

Ich befinde mich jetzt in einer Situation, in der ich mit einem großen Zend Framework PHP-Projekt interagieren muss, das von einer anderen Person entwickelt wurde, und ich bin überwältigt von dem Versuch, den Code zu verstehen, der auf zahlreiche Dateien verteilt ist.

Welche Techniken und Prozesse haben Sie nützlich gefunden, um eine große Codebasis zu verstehen, die jemand anderes entwickelt hat? Gibt es ein bestimmtes Diagramm, das Ihnen hilft, das Gesamtbild zu erfassen?

Der Trick zum Verstehen einer großen Codebasis besteht darin, nicht zu versuchen, alles zu verstehen. Ab einer bestimmten Größe kann man kein mentales Modell mehr im Kopf haben. Sie beginnen mit einem Ankerpunkt, der für jede Aufgabe Sinn macht, an der Sie zuerst arbeiten müssen, verzweigen dann von dort, lernen nur die Teile, die Sie benötigen, und vertrauen darauf, dass der Rest wie angegeben funktioniert. Es ist so, als würde man Rekursion verstehen. Wenn Sie versuchen, den gesamten Stapel in Ihrem Kopf zu halten, explodiert Ihr Gehirn.

Grep, Debugger und Intellisense sind deine Freunde hier. Wenn Sie nicht wissen, wie eine Funktion aufgerufen wird, setzen Sie einen Haltepunkt darauf und arbeiten Sie sich durch den Stack-Trace.

Das andere, was zu beachten ist, ist, dass große Code-Basen nicht aus dem Nichts entstehen. Je größer es ist, desto mehr Programmierer haben Erfahrung damit. Fragen Sie sie also, wo sie anfangen sollen, aber seien Sie genau. Stellen Sie Fragen wie "Ich muss einen neuen Zahlungsanbieter hinzufügen. Wo im Code soll ich suchen?" Konzentrieren Sie sich auf genau diese Aufgabe, anstatt zu versuchen, die gesamte Codebasis zu verstehen, und Stück für Stück wird Ihre Bekanntheit zunehmen.

Es gibt keine Abkürzung. Man muss nur leiden.

Um Ihre Frage zu beantworten, wie man Diagramme erhält, ist Sauerstoff das, was Sie wollen. AFAIK funktioniert mit PHP.

Im Allgemeinen gehe ich die folgenden Phasen durch, wenn ich auf eine neue Codebasis stoße:

1. Verstehen Sie, was es aus Anwendersicht tut. Sie können die Anwendung tatsächlich selbst als Power-User verwenden. Verstehen Sie, wie die echten Endbenutzer damit arbeiten. Dies kann erfordern, dass Sie sich mit ihnen zusammensetzen, bis Sie ein solides Verständnis dafür haben, was sie tun.

2. Kommunizieren Sie nach Möglichkeit mit den ursprünglichen Entwicklern. Zuerst werden Sie architektonische Fragen haben, die durch die Endbenutzererfahrung stimuliert werden. Später haben Sie Implementierungsfragen zu Edge-Cases und Details. Die Möglichkeit, Antworten von den Entwicklern zu erhalten, hilft weitaus mehr als alle Kommentare oder Dokumentationen (die bestenfalls unvollständig und oft irreführend sind oder gänzlich fehlen).

3. Erfahren Sie, welches Framework Sie verwenden. Zumindest sollten Sie in der Lage sein, eine "Hallo Welt" oder eine andere einfache Anwendung mit diesem Framework zu erstellen, bevor Sie in die Produktionsanwendung eintauchen.

4. Behalten Sie den gesamten Bereitstellungsprozess im Griff (am besten, während die ursprünglichen Entwickler Ihre Hand halten). Wenn Sie die aktuelle Codebasis nicht verwenden können, um sie zu erstellen und über eine Test- / Validierungs- / Produktumgebung bereitzustellen, sind Sie auf dem Laufenden. Selbst die kleinste Änderung erfordert einen Sprung durch alle Bereiche des Einsatzes. Warum also nicht gleich diesen Teil runterholen? Auf diese Weise lernen Sie all die tollen Server, Datenbanken, Dienste und Skripte kennen, die von der App verwendet werden - Sie werden wissen, wo sie sich befindet.

5. Verschaffen Sie sich einen Überblick über die Funktionsprüfungen (falls vorhanden). Woher weißt du, ob das Ding richtig läuft? Was müssen die Mitarbeiter für die Pflege und Fütterung der Anwendung tun?

6. Verstehen Sie die Protokolle der App. Obwohl ich noch nie mit PHP gearbeitet habe, gehe ich davon aus, dass jede ernsthafte PHP-Anwendung eine Art Protokollierung hat. Wenn Sie die Protokolle verstehen, haben Sie einen guten Ausgangspunkt, wenn die Zeit für das Debuggen von Problemen kommt.

---- Beachten Sie, dass ich bis jetzt noch nicht einmal erwähnt habe, dass ich mir die Codebasis genau angesehen habe. Es gibt VIELES, was Sie über ein großes Projekt lernen können, ohne sich den Code anzusehen. Irgendwann muss man sich natürlich mit dem Code vertraut machen. Folgendes hilft mir:

7. Für Diagramme ist doxygen ein hervorragendes Tool , mit dem Sie Anrufdiagramme und andere Beziehungen erstellen können . Es ist zufällig PHP-fähig! Wenn Sie nicht versucht haben, Sauerstoff, müssen Sie es unbedingt ausprobieren. Ich kann zwar nicht dafür bürgen, wie verständlich es für Code innerhalb eines Frameworks sein wird, aber es könnte helfen. Ursprüngliche Entwickler sind oft schockiert über das, was sie sehen, wenn sie mit Doxygen-generierten Dokumenten ihres Codes präsentiert werden. Die gute Nachricht ist, dass es wirklich hilft, ihr Gedächtnis aufzurütteln und dir besser zu helfen.

8. Wenn Sie eine Reihe von Komponententests haben, sollten Sie sich diese genauer ansehen, um einen Einblick in das Innenleben der Anwendung zu erhalten. Dies ist auch der erste Ort, an dem Sie nach Fehlern suchen, die Sie möglicherweise beim Vornehmen von Änderungen verursacht haben.

9. IDE-Lesezeichen sind von unschätzbarem Wert, um Hotspots in der Codebasis zu markieren. In der Lage zu sein, schnell zwischen ihnen umzuschalten, fördert das Verständnis.

10. Das Lesen der neuesten Fehlerberichte und ihrer Lösungen ist auch für das Verständnis von Hotspots hilfreich und hilft Ihnen dabei, die wichtigsten Teile der Codebasis auf den neuesten Stand zu bringen.

Wie gewünscht, hier ist mein Kommentar als Antwort.

Wenn ich mit dem Code anderer Leute arbeite, neige ich dazu, UML-Klassendiagramme zu erstellen oder wenn möglich zu generieren, um mir einen Überblick über die statische Struktur zu geben. Das visuelle Diagramm hilft mir besonders, wenn ich später zurückgehen muss und den Kontext einer Klasse bereits vergessen habe. Ich mache es manchmal für dynamische Verhalten sowie die Wechselwirkungen zwischen collaborateurs auszukleiden, aber ich tue nicht , dass diese oft.

Wenn die Codebasis Tests (Integration oder Unit) enthält, sind diese manchmal auch einen Blick wert.

Ich werde dies tatsächlich im Laufe dieser Woche tun, wo ein neuer Kunde Verbesserungen für ein Produkt benötigt, das von einem anderen Entwickler zurückgelassen wurde. Nachfolgend sind die folgenden Schritte aufgeführt:

a) Identifizieren Sie das verwendete Programmierframework, um zu wissen, wie die Anwendung abläuft.

b) Identifizieren Sie gemeinsame Dienste - Protokollierung, Ausnahmebehandlung, MVC, Datenbankverbindung, Überwachung, Ansicht (Seitengenerierung), da dies die Teile sind, in denen wir am häufigsten verwenden werden.

c) Durchlaufen Sie allgemeine Benutzerabläufe (in der Anwendung) und versuchen Sie dann, sie an der Anordnung des Codes auszurichten

d) Versuchen Sie, einige Änderungen vorzunehmen und festzustellen, wie sie herauskommen. Dies ist der größte Schritt, denn bis Sie anfangen, Änderungen vorzunehmen, ist der Code immer noch eine Blackbox.

Ich werde Sie wissen lassen, welche anderen Ideen ich im Laufe der nächsten zwei Wochen bekomme

Mein Gedanke ist, dass Sie die Dokumentation lesen sollten. Ich weiß, dass Hacker es lieben, Ihnen zu sagen, "der Code ist die Dokumentation" und dies als Entschuldigung dafür zu benutzen, keine Dokumentation zu schreiben, aber sie sind falsch. Schauen Sie sich den Linux-Kernel an, ein riesiges Softwareprojekt mit vielen Millionen Codezeilen: Ich glaube, niemand könnte wirklich frisch reinkommen, ohne ein Buch gelesen zu haben und es einfach in die Hand zu nehmen. Wenn der Code, mit dem Sie arbeiten, nicht dokumentiert ist (oder bei kleineren Projekten gut kommentiert ist), ist er wahrscheinlich kein guter Code.

Wenn Sie mit etwas wirklich Großem ohne Dokumentation arbeiten (ich war auch dabei, es ist grob!), Ist es hilfreich, den Teil, an dem Sie arbeiten, zu isolieren. Finden Sie in diesem Teil des Codes heraus, wie Daten / Ereignisse / Nachrichten / Interaktionen in diese Einheit und aus dieser Einheit heraus gelangen. Mit anderen Worten, konstruieren Sie die Schnittstelle zurück. Schreib es auf. Wenn Sie das nächste Mal an einer anderen Einheit arbeiten (Bonus, wenn diese mit der ersten spricht), tun Sie dasselbe. Bewahren Sie alle Unterlagen auf. Nach ein paar Monaten haben Sie ein schönes Bild davon, wie das Ding fließt.

Finden Sie die Schnittstelle einer kleinen Einheit heraus, an der Sie arbeiten, und notieren Sie sie zum späteren Nachschlagen. Mit der Zeit werden Sie das meiste zusammennähen, wie es funktioniert. Finden Sie heraus, was Ihr Programm tut, und verfolgen Sie den Nachrichtenfluss. Wenn Ihr System beispielsweise eine Netzwerk-Eingangsnachricht empfängt und eine Ausgangsnachricht sendet, verfolgen Sie, wie diese Nachricht durch das System fließt, ohne sich um alle Details zu kümmern.

Ich erstelle ein einzelnes UML-Modell aus allen Dateien, die von Java zu UML umgekehrt wurden. Dieser Ansatz bedeutet, dass das Modell nicht mehr nur eine abstrakte Ansicht des Projekts ist, sondern das Projekt selbst vollständig auf MOF und damit auf UML abgebildet wird.

Was ich bekomme, ist ein großes einzelnes Modell, das aus mehreren Untermodellen besteht, die jeweils aus Paketen bestehen, die aus Klassifizierern usw. bestehen. Wenn ich auf mehreren Projektebenen arbeite, kann ich auch die einzelnen Klassifizierer und Methodenaufrufe auf mehreren Projektebenen verfolgen. Ich meine, dass dieselbe Methode einen Klassifizierer in Projekt A und einen anderen Klassifizierer in Projekt B aufrufen kann. Die einzige Möglichkeit, die vollständige Struktur des Projekts zu sehen, besteht darin, beide gleichzeitig umzukehren. Ich habe keine Zeit, Komponentendiagramme zu erstellen, und die Informationen sind nicht richtig. Ich möchte lieber den Computer bitten, das gesamte Projekt für mich rückgängig zu machen. Ich mache bei jeder Iteration mit dem Team einen umgekehrten Vorgang und alle meine Diagramme werden sofort aktualisiert. Das Reverse Engineering ist inkrementell und verwendet die Zuordnung von Java zu UML-IDs. Ich meine, dass jedes Java-Element einem einzelnen und einzigartigen MOF-Element zugeordnet ist, das während der gesamten Projektlaufzeit unverändert bleibt, auch wenn es überarbeitet wird. Dadurch sind der UML-Modellierung keine Grenzen mehr gesetzt und es ist eine sehr umfangreiche und komplexe Projektmodellierung möglich. Zu Ihrer Information, ich arbeite mit einem Projekt mit mehr als 5 000 000 Zeilen OOP-Code. Alle meine Projekte werden korrekt rückgängig gemacht und grafische Navigation ist möglich

Ich verwende nur Klassendiagramme, weil ich aus meinem UML-Modell beliebig viele Ansichten erstellen kann, die immer auf dem neuesten Stand sind. Ich kann auch sehr komplexe Projekte modellieren.