Gibt es eine Möglichkeit, Spaghetti-Code im Laufe der Jahre zu vermeiden?[geschlossen]

https://stackoverflow.com/questions/369683

21-08-2019
|

Frage

Ich hatte mehrere Programmierjobs.Jeder mit 20–50 Entwicklern, Projektlaufzeit 3–5 Jahre.

Jedes Mal ist es das Gleiche.Manche Programmierer sind klug, andere sind durchschnittlich.Jeder hat seinen CS-Abschluss, jeder liest Designmuster.Die Absichten sind gut, die Leute geben sich große Mühe, guten Code zu schreiben, aber nach ein paar Jahren verwandelt sich der Code immer noch in Spaghetti.Änderungen in Modul A machen Modul B plötzlich kaputt.Es gibt immer Teile des Codes, die niemand außer der Person verstehen kann, die ihn geschrieben hat.Eine Änderung der Infrastruktur ist unmöglich und Probleme mit der Abwärtskompatibilität verhindern die Nutzung guter Funktionen.In der Hälfte der Fälle möchten Sie einfach alles von Grund auf neu schreiben.

Und Leute, die erfahrener sind als ich, betrachten das als normal.Ist es?Muss es sein?Was kann ich tun, um dies zu vermeiden, oder sollte ich es als eine Tatsache des Lebens akzeptieren?

Bearbeiten:Leute, ich bin beeindruckt von der Menge und Qualität der Antworten hier.Diese Seite und ihre Community rocken!

Lösung

Ruthless Sorgfalt kombiniert mit konstanten Unit-Tests ist der einzige Weg, Spaghetti-Code zu verhindern. Selbst dann ist es nur eine Band-Aid-Lösung. Sobald Sie die Aufmerksamkeit stoppen Auszahlung kommt die Pasta.

Sehr oft finde ich, dass Spaghetti-Code eingeführt wird, weil jemand einfach nur an diesem Tag faul. Sie wissen, dass es einen besseren Weg, es zu tun und haben einfach nicht die Zeit. Wenn Sie sehen, dass passiert es nur eine Sache zu tun.

Rufen Sie sie auf sie und sie bitten, es zu ändern

Ich finde, dass in der Regel genug, um während eines Code-Review den besseren Weges unter Hinweis darauf ist, die Menschen in Gang zu bringen. Wenn sie es nicht in Anspruch und ich fühle mich stark, ich werde es selbst umgestalten.

Komme ich aus gelegentlich als etwas exzentrisch? Ich bin sicher, dass ich es tue. Ehrlich gesagt, obwohl ich nichts dagegen. Ich bin kein Ruck darüber und nähern sich dies auf die bestmögliche Art und Weise soziale. Allerdings schlechten Code zu lassen bekommt in so ziemlich versichert überprüft, dass ich es irgendwann in der Zukunft haben werde zu debuggen. Ich würde lieber ein wenig Flakfeuer nehmen jetzt und erhalten Sie den richtigen Code in.

Ich glaube auch, dass eine Kultur der Unit-Tests hilft auch Spaghetti-Code zu verhindern. Es ist viel schwieriger zu Unit-Test-Spaghetti-Code, der gut Code berücksichtigt. Im Laufe der Zeit zwingt diese Menschen ihren Code zu halten etwas faktorisierter.

Andere Tipps

ich glaube, die Schlüssel-Code rot zu vermeiden Klang unten nach oben Design und Implementierungsmethoden liegt (Ich glaube es so stark, dass ich mein Geschäft genannt - Think Bottom Up - danach). Die Werkzeuge der Wahl sind hier:

Programmierung durch Vertrag
Layered Design
Fokus auf die Entkopplung
baut immer mit Wiederverwendung im Auge, sucht generische Lösungen
Halten Frameworks leicht, einfach und konzentriert

Wie schon in anderen Befragten vorgeschlagen, müssen Sie Probleme frühzeitig fangen. Mit grünen Entwickler bedeutet dies, Mentoring (Paar-Programmierung ist hier gut) und Bewertungen (Code und Design-Reviews). Mit mehr Senior-Entwickler bedeutet dies, Wachsamkeit.

Vor allem keine Angst, von Refactoring. Wenn Refactoring Sie schreckt, sind Sie bereits gesunken. Wenn Refactoring wird als „schlecht“ zu sehen ist, dann ist es etwas falsch mit Ihrem Geschäft.

Wenn Sie etwas zu beheben, repariert es richtig. Ich verwende den Begriff „Fux“, um eine Lösung zu beschreiben, die in die falsche Richtung getan wurde. Es nur „Fux“ Ihre Code-Basis

Cheers,

Dan

20 bis 50 Entwickler ist wahrscheinlich das Problem. Das ist ziemlich hoch und würde eine Menge Management und Ressourcen braucht, um alles unter Kontrolle zu halten.

Ich würde das Projekt Aufspaltung in kleinere wiederverwendbare Segmente auf. Zusammenfassung bestimmte Schichten vom Kernsystem.

Erstellen „Firewalls“ zwischen den verschiedenen Bereichen des Codes. Sie tun dies, indem verschiedene Bereiche oder Schichten von Code zu definieren, und eine einzelne API definieren (in Java, dies in der Regel mit einer Schnittstelle durchgeführt wird), dass jede Schicht reagiert. Es sollte nackte Knochen intefaces oder Klassen sein, dass der API verwendet, die aber „wissen“ nichts über die Interna dieser Schichten. Zum Beispiel sollte die gui nicht wissen, oder egal, wie Sie Daten speichern, und Ihre Datenbank sollte nicht wissen, oder kümmern, wie die Daten an den Endbenutzer präsentiert wird.

Diese APIs müssen nicht in Stein gemeißelt sein - Sie sollten die Dinge können hinzufügen, wie notwendig, solange Sie sicherstellen, dass Sie den Firewalls nicht verschmutzen

Ich denke, der Hauptpunkt ist, wenn Sie sagen

Sie möchten einfach alles von Grund auf neu schreiben

Umarme es einfach.
Verwenden Sie so viele Unit-Tests wie möglich und lassen Sie dann Refactoring zu einer gängigen Praxis werden.
Automatisierte und Unit-Tests stellen sicher, dass Änderungen keine Regressionen nach sich ziehen;Einen bestimmten Prozentsatz Ihrer Zeit dem Refactoring von altem Code widmen (und das bedeutet, weniger neue Funktionen!) Stellen Sie sicher, dass die vorhandene Codebasis nicht oder zumindest nicht so schnell veraltet.

Code-Reviews, Coding-Standards und feste Richtlinien.

Hier finden Sie die für unser Geschäft - da ich nicht weiß, welche Art von Geschäft Sie haben, können Sie Ihre Laufleistung variieren. Während zu Team Foundation Server zu bewegen, war ein großer Teil unseres Fokus Codequalität auf der Erhaltung - oder zumindest helfen, Qualität in irgendeiner Weise zu halten. Einige Beispiele von dem, was wir hinzufügen:

Code-Review-Workflow - Erzwingt Codeüberprüfung als Teil des Prozesses. Enthält eine Politik, dass die Check-In geschieht verhindern wird, wenn der Code nicht überprüft wurde.
TeamReview - macht Code Bewertungen weniger schmerzhaft durch einen kompletten "innerhalb der IDE" Erfahrung in der Bereitstellung
Richtlinien Check-in (im Allgemeinen) - viele coole Goodies für die Steuerung der Strömung des Codes. Dinge wie dafür zu sorgen, dass die Öffentlichen und geschützte Methoden vor dem Check-in zu machen, dass dokumentiert werden, dass keine Arbeit ohne entsprechenden Workitem eingecheckt werden kann.

Wie ich schon sagte, wenn Sie eine andere Plattform verwenden, vielleicht die Werkzeuge zur Verfügung, und was Sie tun können, ist anders. Aber regieren Werkzeuge nicht aus möglich in irgendeiner Weise zu helfen. Wenn Sie es verwenden können, zu verbessern, zu kontrollieren und prüfen Sie Ihren Workflow und die Elemente, die sich darin bewegen, sollte es zumindest eine Überlegung wert.

Denken Sie daran, alle Änderungen in Prozess Push-Back einzubeziehen werden. Die Art und Weise, dass wir dazu beigetragen haben, diese Leichtigkeit ist die Politik in die Ausbildung für den Übergang von unserem alten Versionskontrolle / Defect Tracking-System zu bauen.

Es klingt wie viele sind nicht einige grundlegende Lehren des encapsualtion und gutes Design folgen.

Keeping Dinge isoliert und unreliant auf anderen Teilen ist wichtig, das Problem, das Sie beschreiben, zu vermeiden. Sie könnten etwas höher Level-Designer oder Architekten benötigen. Dies ist ein typisches Szenario, in dem Menschen einige drakonische Prozesse und Change Management gerechtfertigt haben. (Ich weiß, dass nicht befürworten)

Sie müssen Abhängigkeiten und Zusammenhänge vermeiden und definieren und öffentliche Schnittstellen verwenden nur. Dies ist natürlich eine grobe Vereinfachung ist, aber Sie werden wahrscheinlich eine Menge von einigen Metriken auf Ihrem Code lernen - Komplexität von Klassen, öffentlicher Methoden, UML-Diagramme von Reverse Engineering den Code usw.

gebaut

Ich denke, die lose Kopplung Sie mit ausgewachsenen Verwendung von Dependency Injection bekommen kann ein technisches Merkmal ist, die viel helfen kann. Wenn Sie die Teile der Anwendung brechen auseinander sind Sie weniger wahrscheinlich, Spaghetti aus „interessant“ Wieder Tragen zu erhalten.

Sie können stattdessen für übermäßige Fragmentierung geleitet, aber das ist ein anderes Thema und weniger globalen Strukturproblems.

Sie Code nicht zulassen, dass bis mindestens zwei Augenpaare begangen werden haben es gesehen.

Refactoring

Strive das Design so sauber wie möglich halten. Das ist nicht einfach, aber es ist die Mühe wert.

Ich glaube nicht, es ist normal. Es ist wirklich schwer, diese Sache zu kämpfen, wenn es dort für ein paar Jahre.

Der einzige Weg, es zu vermeiden, ist die Haltung zu ändern:

„Die Einstellung, dass agile Entwickler zu dem Design der Software haben, ist die gleiche Haltung, die Chirurgen zu sterilen Verfahren haben. Sterile Verfahren ist, was macht Chirurgie möglich . Ohne sie würde das Risiko einer Infektion viel zu hoch zu tolerieren sein. Agile Entwickler fühlen die gleiche Weise über ihre Entwürfe. Das Risiko der Vermietung auch die kleinst bisschen rot beginnen zu hoch zu tolerieren.“ Martin C. Robert „Agile Prinzipien, Patterns und Practices in C #“

Wir empfehlen dringend für Ratschläge dieses Buches zu suchen. Es Namen alles „Design riecht“, die Gründe für ihre Existenz und die Folgen davon zu verlassen. Kann dies werden Ihnen helfen, Ihr Management davon zu überzeugen, dass die derzeitige Situation nicht angemessen ist.

Viel Glück!

Das größte Problem in der Software-Industrie ist, dass die Qualität des Programmcode wird als subjektives Problem angesehen. Ohne eine gut definierte Metrik, nur sauber und ordentlich zu sein, und die Konventionen finden nicht genug, um sicherzustellen, dass die Qualität akzeptabel ist.

Es gibt Versuche, dieses , aber sie es ist unwahrscheinlich, ausreichendes Interesse hat oder die Annahme in erster Linie, weil die seit langem etablierte Kultur der Programmierer weg, die Technik ähnelt von allem zu bleiben, sehr hart versucht zu bekommen. Die „reine Kunst“ Philosophie der Programmierung bedeutet, dass Ihre 20-50 Entwickler alle in ihrer eigenen einzigartigen Art und Weise auf dem Code dreschen werden, so dass, egal wie gut die einzelnen Codierer, wobei die Summe der Bemühungen der Gruppe immer geht zu sein „ein großer Ball von Schlamm“.

Um dies zu vermeiden, entweder bekommen alle der Programmierer auf der gleichen ‚Seite‘, normalisierte Code Teil Ihrer Konvention machen, oder jagen nach Jobs die Entwicklungsteams kleiner sind waren (1-3 Personen) und du bist der große kahuna. Eines Tages die großen Teams finden einen Weg, eine bessere Sachen zu bauen, aber bis dahin auch die besten von ihnen sind sehr glücklich, wenn sie nur knapp 6 bekommen kann von 10. Wir minderwertige Software bauen, weil das ist, was wir aufgebaut haben unsere Branche zu tun ...

Paul.

Sie haben die Software-Entwicklung Praktiken aufmerksam zu verfolgen. Dort hat Code-Reviews sein, und Unit-Test, die constastantly sicherstellen, dass der Updates andere Dinge im System zu beeinflussen ist. 20-50 Devs ist eine Menge, aber es getan werden kann. gute Prozesse der Umsetzung ist das einzige, was man in dieser Umgebung zu retten. Erzwungene Coding-Standards sind auch der Schlüssel.

Defekte und Leistung der verschiedenen Teile des Systems Tracking ermöglicht es Ihnen, Probleme zu identifizieren. Da die Systeme sind schlecht Funktionen oder Modulen, geändert oder geschrieben werden, eine höhere Rate von Fehlstellen aufweisen. Wenn ein „Problem“ Modul eine Entscheidung identifiziert wird, kann das Modul (die Anwendung) neu zu schreiben vorgenommen werden.

Kontinuierliche Refactoring. Sie wurde Refactoring, wie Sie gehen, vor allem auf der Design-Ebene. Wenn Sie gebrochenen Code oder Design zu sehen, darauf vorbereitet sein, es zu beheben. Dies ist oft ein Fall von etwas Fixierung, die nicht gebrochen ist, per se. Abgesehen davon, dass es ... es ist einfach nicht manifestiert Gebrochen es ist ... noch.

Nein

Shore und Warden Die Kunst der agilen Entwicklung ist ein großes Buch, mit einem Abschnitt über „Anwenden von XP auf ein vorhandenes Projekt“ (in Kapitel 4). Projekte noch schlimmer im Laufe der Zeit, wenn Sie hart kämpfen: die Überwindung dieser technischen Schulden ist hart und wird es immer schwieriger macht akzeptabel Mitteilungen zu versenden. Die einzige Lösung ist, um die Geschwindigkeit zu verringern, mit der Sie neue Funktionen liefern, und verbringt die Zeit der Testabdeckung und Refactoring gespeichert zu verbessern.

Normalerweise Projekte haben nicht viel Testabdeckung, und haben nicht die Möglichkeit, eine 10 Minuten automatisiertes Skript laufen, die Ihren Code ziemlich gründlich bauen und trainieren. Stattdessen wird die meisten Code so strukturiert, dass es schwer zu testen ist. Die beste Option, dann ist einfach Testabdeckung hinzuzufügen, wo Sie können, während mit Blick auf die Refactoring beginnen zu machen Sie den Code so abstrahiert, dass es einfacher ist, zu testen.

Obwohl das Team Zeit zu verbessern, den Code verbringen muss es sauber und prüfbar Sie wahrscheinlich in der Lage, nicht zu machen für die Zeit zu stoppen liefert es dauern würde „beenden“, um die Bereinigung. Also müssen Sie es Schritt für Schritt tun, während auch das Hinzufügen neuer Features. Das ist in Ordnung, wählen Sie die am stärksten betroffenen Gebiete zuerst, und erwarten Sie nicht offensichtlichen Vorteil sofort. Halten Sie es, denn schließlich werden Sie dort ankommen. Sie nicht auf die Stimmen hören, die alle großen Projekte sagen sind schlecht.

Kurz gesagt, verbringen Sie eine wenig Zeit jede Woche Aufräumen, und stellen Sie sicher, dass der Code ist besser nächste Woche, als es in dieser Woche ist.

Weiterer Code-Reviews und vielleicht Code Eigentum.

Wenn Sie nur einige zufällige Code-Hack dann kümmern Sie nicht so viel wie für den Code, den Sie „besitzen“. Wenn es in Ihrer Verantwortung ist ein Modul des Projekts zu erhalten, möchten Sie glänzen.

Und Code-Reviews ist eine Zeit, wenn Sie Ihren Code zeigen.

Starten Sie Unit-Tests erstellen, dies wird Ihnen helfen, Ihren Code zu entkoppeln und vermeiden Fehler auf Fehlerkorrekturen folgen zu lassen. Es Sie eine gute Abdeckung haben wird es einfacher für Sie, als auch nicht verwendeten Code zu entfernen.

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow