Wann ist ein BIG Rewrite die Antwort?

Lies einfach die Frage über die Big Rewrites und ich erinnere mich an eine Frage, die ich selbst beantwortet haben wollte.

Ich habe ein schreckliches Projekt überliefert, das in altem Java geschrieben wurde und Struts 1.0, Tabellen mit inkonsistenten Beziehungen oder überhaupt keine Beziehungen verwendet, und sogar Tabellen ohne Primärschlüssel oder Felder, die als Primärschlüssel gedacht sind, aber überhaupt nicht eindeutig sind. Irgendwie "funktioniert" der Großteil der App. Die meisten Seiten werden wiederverwendet (kopieren Sie den eingefügten Code) und sind fest codiert. Jeder, der jemals an dem Projekt gearbeitet hat, hat es in der einen oder anderen Form verflucht.

Nun hatte ich lange überlegt, dem oberen Management eine vollständige Neufassung dieser horrenden Anwendung vorzuschlagen. Ich versuche langsam, meine persönliche Zeit zu nutzen, aber ich habe wirklich das Gefühl, dass dies einige engagierte Ressourcen verdient, um dies zu ermöglichen. Nachdem ich die Artikel über große Umschreibungen gelesen habe, habe ich Bedenken. Und das ist nicht gut, wenn ich meine Vorgesetzten davon überzeugen möchte, mein Umschreiben zu unterstützen. (Ich arbeite in einer relativ kleinen Firma, daher besteht die Möglichkeit, dass der Vorschlag genehmigt wird.)

TL; DR Wann gibt es eine große Umschreibung der Antwort und mit welchen Argumenten können Sie sie unterstützen?

Entschuldigung, das wird lange dauern, aber es basiert auf persönlicher Erfahrung als Architekt und Entwickler bei mehreren Umschreibprojekten.

Die folgenden Bedingungen sollten Sie veranlassen, eine Art von Umschreiben in Betracht zu ziehen. Ich werde darüber sprechen, wie ich entscheiden soll, was ich danach tun soll.

• Die Hochlaufzeit für Entwickler ist sehr hoch. Wenn es (je nach Erfahrung) länger dauert, bis ein neuer Entwickler hochgefahren ist, muss das System neu gestaltet werden. Unter Hochlaufzeit verstehe ich die Zeitspanne, bis der neue Entwickler bereit ist, sein erstes Commit durchzuführen (bei einem kleinen Feature).
  • Frisch vom College - 1,5 Monate
  • Immer noch grün, habe aber schon an anderen Projekten gearbeitet - 1 Monat
  • Mittelstufe - 2 Wochen
  • Erfahren - 1 Woche
  • Senior Level - 1 Tag
• Die Bereitstellung kann aufgrund der Komplexität der vorhandenen Architektur nicht automatisiert werden
• Selbst einfache Fehlerbehebungen dauern aufgrund der Komplexität des vorhandenen Codes zu lange
• Neue Features dauern zu lange und kosten zu viel, da die Codebasis voneinander abhängt. (Neue Features können nicht isoliert werden und wirken sich daher auf vorhandene Features aus.)
• Der formale Testzyklus dauert aufgrund der gegenseitigen Abhängigkeit der vorhandenen Codebasis zu lange.
• Zu viele Anwendungsfälle werden auf zu wenigen Bildschirmen ausgeführt. Dies führt zu Schulungsproblemen für Benutzer und Entwickler.
• Die Technologie, in der sich das derzeitige System befindet, verlangt dies
  • Qualitätsentwickler mit Erfahrung in der Technologie sind zu schwer zu finden
  • Es ist veraltet (es kann nicht aktualisiert werden, um neuere Plattformen / Funktionen zu unterstützen)
  • Es steht einfach eine viel ausdrucksstärkere Technologie auf höherer Ebene zur Verfügung
  • Die Kosten für die Aufrechterhaltung der Infrastruktur der älteren Technologie sind zu hoch

Diese Dinge sind ziemlich selbstverständlich. Die Entscheidung für eine vollständige Neufassung im Vergleich zu einer inkrementellen Neufassung ist subjektiver und daher politischer. Was ich mit Überzeugung sagen kann, ist, dass es falsch ist, kategorisch zu behaupten, dass es nie eine gute Idee ist.

Wenn ein System schrittweise umgestaltet werden kann und Sie die volle Unterstützung des Projektsponsorings für so etwas haben, sollten Sie dies tun. Hier ist jedoch das Problem. Viele Systeme können nicht inkrementell umgestaltet werden. Hier sind einige der Gründe, auf die ich gestoßen bin, die dies verhindern (sowohl technisch als auch politisch).

• Technisch
  • Die Kopplung von Komponenten ist so hoch, dass Änderungen an einer einzelnen Komponente nicht von anderen Komponenten isoliert werden können. Eine Neugestaltung einer einzelnen Komponente führt zu einer Kaskade von Änderungen nicht nur an benachbarten Komponenten, sondern indirekt an allen Komponenten.
  • Der Technologie-Stack ist so kompliziert, dass das zukünftige Zustandsdesign mehrere Infrastrukturänderungen erfordert. Dies wäre auch bei einer vollständigen Neuschreibung erforderlich. Wenn dies jedoch bei einer inkrementellen Neugestaltung erforderlich ist, verlieren Sie diesen Vorteil.
  • Das Neugestalten einer Komponente führt ohnehin zu einem vollständigen Umschreiben dieser Komponente, da das vorhandene Design so fubar ist, dass es nichts wert ist, gespeichert zu werden. Auch hier verlieren Sie den Vorteil, wenn dies der Fall ist.
• Politisch
  • Die Sponsoren können nicht verstehen, dass eine inkrementelle Neugestaltung ein langfristiges Engagement für das Projekt erfordert. Die meisten Unternehmen verlieren unweigerlich den Appetit auf den anhaltenden Budgetverlust, der durch eine schrittweise Neugestaltung entsteht. Dieser Appetitverlust ist auch für ein Umschreiben unvermeidlich, aber die Sponsoren werden eher dazu neigen, fortzufahren, weil sie nicht zwischen einem teilweise vollständigen neuen System und einem teilweise veralteten alten System aufgeteilt werden möchten.
  • Die Benutzer des Systems sind zu stark mit ihren "aktuellen Bildschirmen" verbunden. In diesem Fall verfügen Sie nicht über die Lizenz, um einen wichtigen Teil des Systems (das Front-End) zu verbessern. Mit einer Neugestaltung können Sie dieses Problem umgehen, da sie mit etwas Neuem beginnen. Sie werden immer noch darauf bestehen, "die gleichen Bildschirme" zu bekommen, aber Sie müssen etwas mehr Munition zurückschieben.

Denken Sie daran, dass die Gesamtkosten für die schrittweise Neugestaltung immer höher sind als für eine vollständige Neugestaltung, die Auswirkungen auf das Unternehmen jedoch in der Regel geringer sind. Meiner Meinung nach, wenn Sie ein Umschreiben rechtfertigen können und Superstar-Entwickler haben, dann tun Sie es.

Tun Sie es nur, wenn Sie sicher sein können, dass der politische Wille vorhanden ist, es zu Ende zu führen. Dies bedeutet sowohl das Buy-In für Führungskräfte als auch für Endbenutzer. Ohne es werden Sie scheitern. Ich gehe davon aus, dass Joel das für eine schlechte Idee hält. Das Buy-in von Führungskräften und Endbenutzern sieht für viele Architekten aus wie ein Einhorn mit zwei Köpfen. Sie müssen es aggressiv verkaufen und kontinuierlich für seine Fortführung werben, bis es vollständig ist. Das ist schwierig, und Sie sprechen davon, Ihren Ruf auf etwas zu setzen, das manche nicht für erfolgreich halten wollen.

Einige Erfolgsstrategien:

• Versuchen Sie in diesem Fall jedoch nicht, vorhandenen Code zu konvertieren. Entwerfen Sie das System von Grund auf neu. Sonst verschwenden Sie Ihre Zeit. Ich habe noch nie ein "Umbau" -Projekt gesehen oder gehört, das nicht kläglich endete.
• Migrieren Sie die Benutzer teamweise auf das neue System. Identifizieren Sie die Teams, die die größten Probleme mit dem vorhandenen System haben, und migrieren Sie sie zuerst. Lassen Sie sie die guten Nachrichten durch Mundpropaganda verbreiten. Auf diese Weise wird Ihr neues System von innen verkauft.
• Entwerfen Sie Ihr Framework so, wie Sie es benötigen. Beginnen Sie nicht damit, ein Framework zu erstellen, für das ich 6 Monate gebraucht habe.
• Halten Sie Ihren Technologiestapel so klein wie möglich. Überplanen Sie nicht. Sie können Technologien nach Bedarf hinzufügen, das Herausnehmen ist jedoch schwierig. Je mehr Ebenen Sie haben, desto mehr Arbeit ist für Entwickler erforderlich. Machen Sie es sich von Anfang an nicht schwer.
• Beziehen Sie die Benutzer direkt in den Entwurfsprozess ein, aber lassen Sie sie nicht vorschreiben, wie dies geschehen soll . Verdienen Sie ihr Vertrauen, indem Sie ihnen zeigen, dass Sie ihnen das geben können, was sie besser wollen, wenn Sie guten Designprinzipien folgen.

Ich habe an zwei großen Umschreibungen teilgenommen. Zunächst war ein kleines Projekt. Das zweite war das Hauptprodukt eines Softwareunternehmens.

Es gibt mehrere Fallstricke:

• Das Umschreiben dauert immer länger als erwartet.
• Umschreibungen haben keine direkten Auswirkungen / Vorteile für den Kunden.
• Umschreibungskapazität wird nicht verwendet, um den Kunden zu unterstützen.
• Wenn Sie nicht zu 100% über Dokumentation verfügen, verlieren Sie die Funktionalität beim Umschreiben.

Rewrites sind selten die wirkliche Antwort. Sie können einen Großteil des Codes umgestalten, ohne etwas zu verlieren und ohne viel Risiko.

Rewrites können die Antwort sein, wenn:

• Sie wechseln zu einer anderen Sprache oder Plattform.
• Sie wechseln Frameworks / externe Komponenten.
• Die vorhandene Codebasis ist nicht mehr wartbar.

Ich rate jedoch dringend zu einem langsamen Ansatz beim Refactoring. Es ist weniger riskant und Sie sorgen dafür, dass Ihre Kunden zufrieden sind.

Es ist Zeit für ein Umschreiben, wenn:

Die Kosten für das Umschreiben der Anwendung und die Wartung der umgeschriebenen Anwendung sind geringer als die Kosten für die Wartung des aktuellen Systems im Laufe der Zeit.

Einige Faktoren, die die Aufrechterhaltung der aktuellen Version verteuern:

• Die Sprache ist so alt, dass man Leuten, die sie kennen, viel Geld zahlen muss, um darin zu programmieren (COBOL).
• (aus Erfahrung leider) Das System basiert auf einer Hardware-Architektur, die so alt ist, dass sie Ebay- und COLLECT-Teile durchsuchen müssen, um der Maschine, auf der es ausgeführt wird, etwas hinzuzufügen, da sie nicht mehr hergestellt werden. Dies wird als "Hardware-Lebenserhaltung" bezeichnet und ist teuer, da Teile mit zunehmender Knappheit (möglicherweise) teurer werden oder (absolut) irgendwann zur Neige gehen.
• Es ist so komplex geworden, dass sich der //Here be dragons.Kommentar über Ihren gesamten Code erstreckt.
• Sie können keine anderen Projekte schreiben und dem Unternehmen neuen Wert hinzufügen, weil Sie dieses hässliche Biest immer patchen.

Wenn Sie eine grundlegende Änderung in der Architektur des Projekts benötigen, ist es möglicherweise an der Zeit, erneut zu beginnen.

Trotzdem wird es möglicherweise große Mengen an Code geben, die es wert sind, in Ihrem neuen Projekt wiederverwendet zu werden.

Beachten Sie jedoch die faire Warnung. Bei einem aktuellen Projekt wurden die Geschäftsregeln in unzähligen Arbeitsstunden getestet und verfeinert, was bei einem von vorne begonnenen Projekt nicht der Fall sein wird.

Ich bezweifle, dass ein Zeitrahmen oder ein Bauchgefühl ein angemessenes Maß für solch ein drastisches Maß ist. Sie müssen klare , vertretbare und gut verstandene Gründe haben, um an dieser Vorgehensweise teilzunehmen.

Obwohl ich mit Kramis Antwort und Joels Meinung einverstanden bin, gibt es Zeiten, in denen ein Umschreiben angebracht ist. Bei langlebigen Anwendungen (ich spreche von 10 bis 20 Jahren oder mehr) wird die Wartung mit der Zeit immer teurer. Dies ist darauf zurückzuführen, dass der Code immer spaghettiartiger wird, da die ursprüngliche Architektur für schnelle Wartungspatches geopfert wird. Außerdem werden Entwickler für ältere Technologien seltener und teurer. Schließlich wird die Hardware immer älter und es wird immer schwieriger, neue Hardware, Betriebssysteme, Frameworks usw. zu finden, auf denen die alte Anwendung ausgeführt werden kann. Außerdem entwickeln sich Unternehmen weiter, und höchstwahrscheinlich wird ein älteres System die Geschäftsanforderungen der Organisation nicht erfüllen, so wie es ein brandneues System könnte.

Sie müssen also alle laufenden Wartungskosten sowie die potenziellen Vorteile eines neuen Systems für das Unternehmen gegen die Kosten für das erneute Schreiben der Sache von Grund auf abwägen. Seien Sie sehr pessimistisch in Ihren Schätzungen über die Kosten eines Umschreibens. Es kostet fast immer mehr und dauert länger als man denkt.

Halt! Umschreiben ist fast nie die Antwort. Meistens ist Refactoring die bessere Wahl.

Natürlich gibt es Zeiten, in denen ein Umschreiben gerechtfertigt ist:

• Sie wechseln zu einer neuen Plattform, auf der es keine Migrationstools gibt (oder die nicht billig genug geschrieben werden können).
• Die umzuschreibende Anwendung ist trivial.
• Der Quellcode für die ursprüngliche Anwendung geht verloren und die Wiederherstellung ist teurer als das Neuschreiben.
• Die überwiegende Mehrheit der Geschäftsregeln, die in der vorhandenen Anwendung enthalten sind, gilt nicht mehr.
• Es gibt nur wenige aktive Benutzer des vorhandenen Codes.
• Sie haben die Ressource (Zeit, Talent und Werkzeuge), um das Neuschreiben vorzunehmen.
• Die vorhandene Anwendung kann aus rechtlichen oder praktischen Gründen nicht in einer Produktionsumgebung ausgeführt werden.

Um zu verstehen, warum ich das Umgestalten über das Umschreiben empfehle, sollten Sie überlegen, was mit einem Umschreiben verbunden ist. Sie müssen:

1. Verstehen Sie die Nuancen der vorhandenen Anwendung. Dies ist in der Regel nicht einfach, wenn Sie alle darin enthaltenen subtilen Geschäftsregeln berücksichtigen, die Umgebung (sowohl menschlich als auch technisch), in der sie betrieben wird, sowie die Vor- und Nachteile der aktuellen Lösung. In den meisten Fällen befindet sich diese Information (falls vorhanden) nur im Quellcode der vorhandenen Anwendung. Es ist bedauerlich, dass einer der Hauptgründe für das Ausführen eines Neuschreibens darin besteht, dass vorhandener Code schwer zu verstehen und zu warten ist.

2. Reproduzieren Sie diese Funktionalität (oder eine aktualisierte Version davon) in einer neuen Anwendung, die getestet und zuverlässig ist. Bestehender Code wird von Entwicklern möglicherweise nicht verstanden, wird jedoch von den Benutzern normalerweise gut verstanden. Es entspricht möglicherweise nicht ihren aktuellen Geschäftsanforderungen, aber sie können Ihnen zumindest mitteilen, was die Anwendung unter verschiedenen Umständen tut.

Die großen Vorteile des Refactorings sind:

• Sie können die Dinge einzeln nehmen.
• Änderungen können im Kontext der vorhandenen, funktionierenden Anwendung getestet werden.
• Hypothesen über die Funktionsweise des vorhandenen Codes können getestet werden, indem kleine Änderungen vorgenommen und beobachtet werden, was passiert.
• Änderungen können Benutzern häufig in mehreren Phasen und nicht auf einmal übermittelt werden.
• Lernen aus frühen Stadien des Refactorings kann spätere Stadien des Refactorings informieren.
• Wenn Sie den Prozess im Laufe der Zeit abbrechen, ergeben sich dennoch Vorteile in Bezug auf eine sauberere Codebasis (im Gegensatz zu einem Umschreiben, das abgeschlossen werden muss , um dem Benutzer oder den Entwicklern Vorteile zu bieten).

Denken Sie auch daran, dass Sie beim Umschreiben garantiert viele neue Fehler in die neue Codebasis einschleusen werden.

Diese Grafik könnte helfen, es ist eine Funktion der Codebasisqualität und des Geschäftswerts der Anwendung:

Das Diagramm gibt vor, ein Anhaltspunkt dafür zu sein, wann eine Neugestaltung älterer Software gerechtfertigt ist und wann nicht. Wenn zum Beispiel die Software einen hohen geschäftlichen Wert hat und die Qualität des Codes schlecht ist, ist ein Re-Engineering gerechtfertigt.

Ich denke, ich bin in der einzigen Situation in meiner Karriere, in der das große Umschreiben die Antwort ist:

Unternehmenszusammenschluss, enorme Überschneidung in der Systemfunktionalität. Viele, viele Systeme wurden zusammengeführt und in den Ruhestand versetzt, andere sind noch in Arbeit.

Ich habe ein System von der anderen Firma geerbt, das noch weiterlebt. Es verfügt über eine riesige Codebasis, die früher mehrere Abteilungen unterstützt hat, die unseren sehr ähnlich waren, aber ein völlig anderes Design und Framework haben. Es gibt nur noch einen Wirtschaftszweig, der genug Geld verdient, um dieses Ding in einem Zombie-Staat am Leben zu erhalten. All das alte Fachwissen ist weg, es gibt keine Dokumentation. Die Unterstützungslast ist hoch und es kommt jede Woche zu Ausfällen. Es wurde nicht in die Systeme unseres Unternehmens integriert, da unser Unternehmen diesen bestimmten Geschäftsbereich nie unterstützt hat. Daher verfügen wir nicht über die Funktionalität oder das Fachwissen.

Anscheinend ist dies der einzige Fall, in dem ein Umschreiben erforderlich ist. Es sieht so aus, als müsste ich dieses Ungetüm herausfinden, die für dieses Geschäft bestimmten Funktionalitäten herausholen und die Teile neu schreiben, die zu unseren bestehenden Systemen hinzugefügt werden müssen. Sobald dies erledigt ist, können unsere vorhandenen Systeme diesen neuen Sektor unterstützen, und dieses Biest kann aus seinem Elend befreit werden. Sonst verliere ich den Verstand.

Ich habe für eine kleine Softwarefirma gearbeitet, die einige DOS-Anwendungen hatte, die für Y2K aktualisiert, als Windows-16-Bit-App umgeschrieben und dann als 32-Bit-App mit einer zusätzlichen 'kleinen' Funktion (die letztendlich nur von verwendet wird) vollständig umgeschrieben wurden ein Kunde), der die gesamte Struktur betraf.

Das Verschieben des 16-Bit-Codes auf 32 hätte in einem Monat von einer Person durchgeführt werden können, aber NOOOOOOOOO, wir mussten es umschreiben, um Soooooooooo viel besser zu machen. Dieses Ding könnte für andere Industrien angepasst werden, hätte vollständige Spezifikationen und Pseudocode, bevor sie überhaupt angefangen haben. Die Spezifikationen wurden erstellt, aber es dauerte so lange, bis der eigentliche Code geschrieben war. Es wurde spät veröffentlicht, mit mehr Bugs als die 16-Bit-Version (es war in Version 3.0 und schließlich bis zu dem Punkt, an dem wir es fast eine Woche lang geschafft haben, ohne dass jemand einen neuen Bug gemeldet hat).

Sie würden denken, dass das 3-4-fache Umschreiben derselben Anwendung einige Verbesserungen bringen würde, aber ich glaube nicht, dass ein GUI-Front-End so gerechtfertigt sein kann.

Dies war mein erster IT-Job als Leiter des technischen Supports. Ich sollte ein Buch darüber schreiben, wie man keine Software für den Vertrieb entwickelt. Natürlich haben wir viele Fehler gemacht, aber die Tatsache, dass wir weiterhin Anwendungen neu geschrieben haben, hat die Inkompetenz noch verstärkt.

Ich hatte einen ähnlichen Fall wie Sie, nur dass der Code nicht einmal Struts verwendete. Was ich stattdessen tat, waren Zielgebiete, die besonders beschissen waren UND eine Menge Probleme verursachten. Dieser gezielte Ansatz hat uns inkrementell verbessert.

Über einen Zeitraum von 2 Jahren haben wir neben der Verbesserung auch an der Überarbeitung von Kleinteilen gearbeitet. Wir haben immer eine Härtungsaufgabe in einen Projektplan eingearbeitet. Indem wir uns auf die Bereiche konzentrierten, die nicht gut funktionierten, konnten wir das Beste für unser Geld herausholen. Das Zeug, das funktionierte, ließen wir allein. Ebenfalls kritisch ist, dass diese Arbeit im Rahmen der normalen Entwicklung durchgeführt und freigegeben wurde. Das Problem mit einer großen Umschreibung ist, dass Sie ein Jahr oder länger warten und dann, wenn Sie zurückkommen, sich ohnehin alles ändert und einige der bösen Fehler behoben wurden und Sie Ihren ROI verloren haben.

Wir haben das Ganze nie neu geschrieben. Wir haben jedoch aufgehört, diese Plattform für neue Arbeiten zu nutzen, und eine neue Plattform für ein großes neues Projekt auf den Weg gebracht. Das wurde genehmigt und wir haben ein großartiges Produkt in angemessener Zeit geliefert.

Also sitze ich hier an meinem Schreibtisch und beginne, den Code für dieses absolute Durcheinander einer großen ASPX-Datei, der Datenbank dahinter, neu zu schreiben und die MS Access-Schnittstelle zu MsSQL zu ersetzen.

Dieses Asp-Programm ist übersät mit Dingen wie

• include(close.aspx) Das Innere hat eine Codezeile, die die letzte offene Datenbankverbindung schließt.
• Legacy-Code wurde nur zufällig auskommentiert
• Keine Rücksicht auf Sicherheit
• Spaghetti-Code, tausende Zeilen davon. Alles in einer Datei.
• Funktionen und Variablen ohne eindeutige Bedeutung hinter ihren Namen

Wenn wir jemals etwas ändern müssen, ist es, als würden wir im Albtraum-Modus fünf Kal-toh-Spiele gleichzeitig spielen.

Ich wurde beauftragt, die Funktionalität zu replizieren und ein Produkt herzustellen, das an andere in der Branche angepasst und verkauft werden kann. Das Problem ist, dass dieses Ding in den letzten 10 Jahren geschrieben wurde, um jedes einzelne Geschäftsbedürfnis zu befriedigen (naja, ich würde sowieso ungefähr fünf oder sechs Sigma von ihnen sagen).

Wenn wir das Produkt nicht verkaufen wollten, hätten sie wahrscheinlich kein Umschreiben nötig gehabt, da es das meiste von dem macht, was sie wollen - vielleicht nicht elegant, aber es war nicht ratsam, das Geld für das Erstellen von nettem Code auszugeben 'mach das selbe.'

Joel Spolsky hat einen ausgezeichneten Artikel dazu: Dinge, die Sie niemals tun sollten, Teil I

Aus dem Titel geht hervor, dass er irgendwie einseitig ist (er spricht darüber, warum man niemals Code werfen sollte). IMO, es steckt viel Wahres dahinter. Ich habe kürzlich ein Channel9-Video zum 25-jährigen Jubiläum von Excel gesehen, in dem einige Entwickler sagten, wie Selbst heute würden Sie, wenn Sie in die Quelle schauen, die Revision überprüfen und am Ende auf den Code zurückgreifen, der vor 20 Jahren für Excel geschrieben wurde.

Man kann sich nicht hundertprozentig sicher sein (selbst wenn Netscape Fehler macht (aus Joels Artikel)), ich hatte das Gefühl, der Artikel von Joel sei von Gott geschickt worden, weil ich pessimistisch sein und gerne Code wegwerfen kann, weil ich denke, ich kann ihn immer eine Sekunde besser schreiben Zeit, aber ich habe erst jetzt gemerkt, dass dies nur eine Menge kostet .

Um eine konkrete Antwort zu geben, würde ich nur sagen , dass Sie eine gründliche Kosten-Nutzen- Analyse durchführen müssen.

My Real world: Eine Silverlight-App, die ich bis jetzt für v0.6 entwickle, hat ein Durcheinander von asynchronen Aufrufen, die den Code so verworren machen. Seitdem ich diese Woche Reactive Extensions entdeckt habe, möchte ich den größten Teil des Codes wirklich neu schreiben, aber was sage ich jetzt meinen Kunden? Das Programm funktioniert einwandfrei (mit einigen Speicherlecks), aber es interessiert sie nicht? Ich kann ihnen unmöglich sagen, dass ich noch 2-3 Wochen brauche, weil ich etwas wiederholen möchte. Ich werde jedoch den Code verzweigen und in meiner Freizeit damit neu schreiben / spielen .

Nur meine 2 Cent ok?

Die vorhandene Lösung ist nicht skalierbar.

Ich sehe Sie an, MS Access.

Laut Joel sind große Umschreibungen der schlimmste strategische Fehler, den ein Unternehmen machen kann:

Dinge, die Sie niemals tun sollten, Teil I

... Es ist wichtig, sich daran zu erinnern, dass es absolut keinen Grund gibt, zu glauben, dass Sie einen besseren Job machen werden als beim ersten Mal. Zuallererst haben Sie wahrscheinlich nicht einmal das gleiche Programmierteam, das an Version 1 gearbeitet hat, also haben Sie nicht wirklich "mehr Erfahrung". Sie werden einfach wieder die meisten alten Fehler machen und einige neue Probleme einführen, die nicht in der Originalversion enthalten waren.

Das alte Mantra , das man wegwerfen kann, ist gefährlich, wenn es in kommerziellen Großanwendungen angewendet wird. Wenn Sie Code experimentell schreiben, können Sie die Funktion, die Sie letzte Woche geschrieben haben, erweitern, wenn Sie an einen besseren Algorithmus denken. Das ist gut. Möglicherweise möchten Sie eine Klasse umgestalten, um die Verwendung zu vereinfachen. Das ist auch gut so. Aber das ganze Programm wegzuwerfen ist eine gefährliche Torheit, und wenn Netscape tatsächlich eine erwachsene Aufsichtsperson mit Erfahrung in der Softwareindustrie hätte, hätten sie sich möglicherweise nicht so schlimm in den Fuß geschossen.

Niemals, immer umgestalten - die Wahrheit ist, wenn der Code von Ihnen geschrieben wurde - Sie werden es nicht besser machen können.

Sofern Sie die Technologie nicht ändern möchten, fehlt dem Code eine Struktur (ich habe sie vor sehr langer Zeit auf einer PHP-Website gesehen, der Autor hat nur Spahgetti anstelle von include / class / function kopiert / eingefügt) oder Sie haben etwas von einer anderen Person übernommen, die es ist sehr schlecht geschrieben.

Alles sollte als Blackbox ausgelegt sein. Modulare, einfache API, was drin ist ... das ist weniger wichtig :) Wenn Sie Spaghetti haben, können Sie diese möglicherweise in einer Blackbox verschließen, damit kein guter Code verunreinigt wird.

Ich denke, der Hauptgrund, der das Umschreiben rechtfertigt, sind Plattformänderungen. Wenn Sie beispielsweise eine Windows-Desktop-GUI-Anwendung haben und der Firmeninhaber entscheidet, dass die nächste Version eine webbasierte Anwendung sein soll. Obwohl dies nach meiner Erfahrung nicht immer der Fall ist, ist meistens ein Umschreiben erforderlich, es sei denn, die ursprünglichen Entwickler haben sehr modularen und wiederverwendbaren Code geschrieben (kommt kaum vor).

Es gibt den klassischen Witz über "Wenn ich zu XI gehen würde, würde ich nicht von hier aus anfangen".

Ich habe einmal eine Stelle angetreten, bei der es die Hauptmotivation des Arbeitgebers war, Talente an Bord zu bringen, um eine überfällige Überarbeitung einer geschäftskritischen App zu starten. Die Frage, die ich nicht gestellt habe, war, warum Sie überhaupt in diese Situation geraten sind. Es hätte eine rote Fahne sein sollen, ob die Ursache war

• zu viel Druck, um Funktionen hinzuzufügen, um das Biest zu erhalten und inkrementell umzugestalten,

• zu wenig Fähigkeit in der Abteilung,

• zu wenig Buy-in von Kunden oder Management für inkrementelle Arbeit,

oder was auch immer, und diese Ursache verebbt, bis das Problem ein unerträgliches Maß erreicht hat.

Ich stimme Joel darin zu, dass ein massives Umschreiben wahrscheinlich eine sehr schlechte Idee ist - es sei denn, Sie haben eindeutige Beweise dafür, dass alle zugrunde liegenden Gründe, warum ein umfangreiches Umschreiben so notwendig zu sein scheint, geklärt wurden werde das Problem zu gegebener Zeit wiederholen.

Dies ist die Antwort, wenn das Unternehmen durch das Umschreiben eine Strategie verfolgen kann, die einen Wettbewerbsvorteil bietet, oder die es ihm ermöglicht, seine Kunden auf eine Weise besser zu bedienen, die die aktuelle Architektur nicht bietet.

Stattdessen treten häufig Umschreibungen auf, um die Probleme des Managements zu lindern:

• alles sollte in .NET sein,
• Unsere Entwickler sagen, unser Code ist zum Kotzen,
• wir fallen technisch zurück,
• Wir werden keine Ressourcen finden können, um unser System zu unterstützen, oder sehr oft
• Es ist zehn Jahre her, also ist es Zeit.

Die meisten dieser Sorgen werden sich nicht einstellen, und wenn doch, könnten sie behandelt werden. Das letzte ist jedoch das Schlimmste. Es ist im Wesentlichen: Wir haben keinen Grund.

Ja, ein System weist wie ein Auto erste Abnutzungserscheinungen auf. Dies kann durch routinemäßige Wartung behoben werden. Sie wissen, was sie darüber sagen, wie weit eine kleine vorbeugende Wartung reicht. Als Investition ist die routinemäßige Wartung (dh Umgestaltung und Standardisierung) fast immer mit geringeren Kosten verbunden als eine Umschreibung.

Wir müssen jedoch damit rechnen, dass irgendwann ein Umschreiben notwendig wird. Legen Sie Termine fest und planen Sie diese vorläufig, aber sobald sich der Termin der Verzögerung zugunsten der Verwirklichung anderer strategischer Ziele nähert, haben Sie einen zwingenden Grund wie ...

In den letzten Jahren haben wir die Möglichkeit, große Kunden zu gewinnen, verpasst, weil wir ihre Anforderungen nicht rechtzeitig oder kostspielig erfüllen konnten. Unser System wird mit einer erweiterbaren Architektur umgeschrieben, mit der Anpassungen vorgenommen werden können (und nicht wie bisher fest codiert). Dies wird den Zeit- und Kostenaufwand für die Unterbringung von Kunden mit besonderen Bedürfnissen drastisch verringern. Wir werden mehr Kunden gewinnen und besser auf die Bedürfnisse unserer derzeitigen Kunden eingehen.

Beim Umstieg auf eine völlig neue Technologie ist es erforderlich, die gewünschte Funktionalität bereitzustellen.

"Völlig neu": Wenn Sie neu schreiben möchten, aber dieselbe Plattform verwenden, ist Refactoring und eine umsichtige Umstrukturierung mit ziemlicher Sicherheit die bessere Lösung. "Plattform", wie hier verwendet, ist etwas vage - betrachten Sie es als Sprache und vielleicht als Betriebssystem (das sich von Linux auf Windows erstreckt oder umgekehrt), aber wahrscheinlich nicht als Framework (z. B. das Ersetzen von Struts durch Spring).

"Erforderlich, um die gewünschte Funktionalität bereitzustellen": Ungefähr im Jahr 2000 initiierte ich ein Projekt zum Umschreiben einer wichtigen Serverkomponente in Java aus C ++, um sofort ein Threading, einen Objektcache und clientgesteuerte Transaktionen zu ermöglichen. Zu dieser Zeit gab es mehrere Threading-Bibliotheken für C ++, die wir hätten unterstützen müssen, und das Aktivieren eines Großteils unseres Datenbankcodes durch Threads hätte ein fast vollständiges Umschreiben erforderlich gemacht. Was clientgesteuerte Transaktionen betrifft, wird dies mit der alten Architektur nicht passieren.

Selbst dann bin ich mir nicht sicher, ob ich das Neuschreiben durchgeführt hätte, außer dass ich das Verhalten des aktuellen Systems genau kannte und es sich um relativ sauberen Code handelte, der in seinen elf Lebensjahren nicht sehr viele Warzen entwickelt hatte.

Um den Punkt zu bestimmen, an dem Sie neu beginnen sollten, müssen Sie herausfinden, wo der Wert für die Fortsetzung Ihres aktuellen Projekts unter dem Wert für den Neustart liegt.

Der Grund dafür ist, dass Sie die Entwicklungsgeschwindigkeit des Teams für das neue Projekt genau einschätzen, bis Sie es tatsächlich starten. Unter Zugrundelegung einer SEHR konservativen Schätzung Ihrer Entwicklungsgeschwindigkeit für das neue Projekt ergibt sich jedoch eine lohnende Kapitalrendite, und Sie haben ein Geschäftsmodell für einen Neuanfang.

Mit meiner Metrik müssen Sie zwei Bedingungen erfüllen, um ein Umschreiben zu rechtfertigen:

1. Nach dem Umschreiben werden neue Funktionen einfacher / schneller / weniger fehlerhaft zu schreiben sein
2. Das Neuschreiben dauert weniger oder genauso lange wie das Hinzufügen der aktuellen neuen Funktion.

Selbst dann möchten Sie den Umfang Ihres Umschreibens einschränken. Zum Beispiel hatten wir eine Legacy-Software in einem Unternehmen, das in C ++ mit der Einstellung eines C-Programmierers geschrieben war, der nichts über Modularität wusste. Das Endergebnis war Speghetti-Code in Form einer Finite-State-Maschine, die sich über mehrere Klassen und DLLs erstreckte. Wir hatten eine neue Anforderung, die sich stark von den im Code enthaltenen Annahmen unterschied und Teil des patentierten Mehrwerts des Unternehmens für seine Kunden sein sollte.

Nachdem ich einige Zeit mit der Implementierung anderer Funktionen verbracht hatte, hatte ich eine gute Vorstellung davon, wie lange es dauern würde, um herauszufinden, welche der verschiedenen switch-Anweisungen ich ändern müsste usw. Mein Vorschlag war, den Code-Abschnitt neu zu schreiben die riesige endliche Zustandsmaschine - es sollte weniger Zeit in Anspruch nehmen, als den vorhandenen Code zu erweitern. Ich war in der Lage, eine DLL zu konsolidieren, die früher drei war, und eine viel objektorientiertere Struktur bereitzustellen, die es viel einfacher machen würde, die wichtigen neuen Funktionen zu erledigen und das Hinzufügen neuer Funktionen zu vereinfachen.

Es gab drei andere Anwendungen, die die Bibliotheken verwendeten und die neu geschrieben werden mussten, sodass ich diese Programme nicht komplett neu schreiben musste. Der Umfang beschränkte sich auf die Bibliothek und darauf, was erforderlich war, um die Bibliothek an die vorhandene Software zu binden. Meine Schätzungen waren bei weitem nicht falsch, und die Arbeit hat sich gelohnt. Kurz nach der Neugestaltung wurde ich beauftragt, ein neues Feature hinzuzufügen. Was mit der alten Struktur eine Woche gedauert hätte, hat mit der neuen Struktur nur einen Tag gedauert.

Das OP gibt keinen Hinweis auf den Umfang des Projekts, aber der wichtigste Hinweis, den ich erhielt, war "geschrieben in alt [Sprache / Dialekt] unter Verwendung von alt [Bibliotheken]", die für mich die Haupttreiber eines Neuschreibens sind. Tatsächlich haben die meisten Projekte, an denen ich mit einer signifikanten Marktlebensdauer gearbeitet habe, irgendwann erkannt, dass das Unterbringen von Updates für Compiler / Interpreter / Betriebssysteme eine wichtige Aufgabe bei der Aufrechterhaltung der Codebasis ist.

Kurz gesagt, ich würde das Neuschreiben in Phasen planen und zuerst das Update in libs priorisieren. Es kann sein, dass Sie auf dem Weg dorthin weitere Optimierungen vornehmen können, aber die Tatsache, dass Sie einige Änderungen auf eine spätere Phase verschieben möchten, kann eine gute Möglichkeit sein, um den Zeitplan einzuhalten und ein "Festfahren" zu vermeiden.

Nun, ich kann mir hypothetische Szenarien vorstellen, in denen ich einfach die vorhandene Codebasis verwerfen könnte (hypothetische Situationen, in denen die Bucky Balls kein Gewicht und Volumen haben, und bei denen es niemanden interessiert, ob wir Wochen oder Monate an Produktivität verlieren, während wir uns bemühen, übersehene Funktionen und Fehler hinzuzufügen Eingliederung in das System, und wo das System von einer Organisation so banal und gehasst ist, dass ich das gesamte Ding und die ganze Armee von Servern in zehn Minuten durch Notizblock ++ und ein Netbook ersetzen und die Produktivität und Moral aller auf der ganzen Linie steigern kann.)

Für fast jedes reale Szenario würde ich jedoch nur empfehlen, das Refactoring vor Ort durchzuführen. ^ _ ^. Es gibt in der Regel zu viele versteckte, unvorhergesehene Kosten, um sie neu zu schreiben, wenn undokumentierte rechtliche und geschäftliche Anforderungen auftauchen und die letzte Minute beginnt, Dinge in letzter Minute zu hacken.

== Refactoring in Place für mehr Wohl und so weiter ==

Refactoring von Legacy-Code mit dem regulären alten inkrementellen Ansatz,

1. Wenn Sie die Chance haben, in UML zu konvertieren und zu dokumentieren, welche knorrige Architektur es gibt.
2. Wenn Sie sich in der Versionskontrolle befinden, sollten Sie einige Berichte zur Codeabwanderung generieren und herausfinden, welche Dateien und Dateibereiche am häufigsten geändert wurden. Notieren Sie sich diese, da dies wahrscheinlich die Bereiche sind, mit denen Sie sich zuerst befassen möchten.
3. Bevor Sie einen Code ändern, versuchen Sie immer, eine Testabdeckung hinzuzufügen (selbst hässliche Full-Stack-Funktionstests reichen aus). Wenn Sie mit einer großen, unübersichtlichen Prozedurcode-Extraktionslogik zu tun haben, möchten Sie eine Methode oder Funktion mit einem vernünftigen Namen verwenden und nach Möglichkeit einige Testfälle hinzufügen, die Ihre neue Methode verifizieren. Machen Sie alles, was Sie fürchterlich hacken müssen, und parametrisieren Sie die Änderung, wenn es etwas ist, das häufig geändert wird, wie Randbreite oder Titel, damit es beim nächsten Mal einfacher ist, es zu aktualisieren.
4. Verwenden Sie das Adaptermuster und verstecken Sie die knorrigen Teile des Legacy-Codes unter einem Teppich logisch benannter Klassen und Methoden, sodass Sie sich bei den häufigsten Aufgaben, die Sie und die anderen Entwickler ausführen, keine Sorgen mehr über die unheimlichen Teile machen müssen, die dahinterstehen Sie stehen hinter diesen netten, sauberen Methoden und Klassen, hinter denen Sie diesen alten Code versteckt haben - wie jene netten Familien, die verformte, mörderische, ehemalige Zombiefamilienmitglieder in Scheunen halten, damit sie nicht den Alltag der Zombies verderben Bauernhof. . . normalerweise.
5. Während Sie fortfahren, die Teile des Codes zu entfernen und zu bereinigen, steigern Sie weiterhin Ihre Testabdeckung. Jetzt können Sie noch tiefer graben und noch mehr Code "umschreiben", wenn er benötigt / gewünscht wird, mit immer größerem Vertrauen.
6. Wiederholen oder wenden Sie zusätzliche Refactoring-Ansätze an, um die Codebasis weiter zu verbessern.

Verzweigung durch Abstraktion

1. Definieren Sie die Problemstelle in dem Code, den Sie entfernen möchten (die Persistenzschicht, den PDF-Generator, den Rechnungszählungsmechanismus, den Widget-Generator usw.).
2. Führen Sie einige Funktionstestfälle (automatisiert oder manuell, aber Sie wissen, dass sie automatisiert sind) für die Codebasis aus (schreiben Sie sie gegebenenfalls), die diese Funktionalität zusammen mit dem allgemeinen Verhalten zum Ziel hat.
3. Extrahieren Sie die mit dieser Komponente verbundene Logik aus der vorhandenen Quelldatenbank in eine Klasse mit einer angemessenen Schnittstelle.
4. Vergewissern Sie sich, dass der gesamte Code jetzt die neue Schnittstelle verwendet, um Aktivität X auszuführen, die zuvor zufällig über den Code verteilt war (Überprüfen Sie die Codebasis, fügen Sie der neuen Klasse eine Ablaufverfolgung hinzu, und überprüfen Sie, ob Seiten aufgerufen werden sollen usw.) Sie können steuern, welche Implementierung verwendet wird, indem Sie eine einzelne Datei ändern (Objektregistrierung, Factory-Klasse, unabhängig davon, ob IActivityXClass = Settings.AcitivtyXImplementer ();)
5. Führen Sie funktionale Testfälle erneut aus, um sicherzustellen, dass alles noch funktioniert, und werfen Sie alle Aktivitäten von Activity X in Ihre neue Klasse.
6. Schreiben Sie nach Möglichkeit Komponententests um die neue Wrapperklasse für Aktivität X herum.
7. Implementieren Sie eine neue Klasse mit weniger verrückter Spaghetti-Logik als die Legacy-Implementierung, die dieselbe Schnittstelle wie die Legacy-Klasse verwendet.
8. Stellen Sie sicher, dass die neue Klasse die Komponententests besteht, die Sie für die Vorgängerklasse geschrieben haben.
9. Aktualisieren Sie Ihren Code, indem Sie die Registrierung / factorymethod / whatever ändern, um die neue Klasse anstelle der alten Klasse zu verwenden.
10. Stellen Sie sicher, dass Ihre Funktionstests weiterhin bestehen.

Offenes geschlossenes Prinzip und eine gemeinsame Geschäftslogik- / Persistenzschicht

Bis zu einem gewissen Grad können Sie möglicherweise Ihre Präsentations-, Geschäfts- und Beständigkeitsebene aufteilen und eine neue App schreiben, die vollständig abwärtskompatibel mit der Legacy-Lösung ist, oder zumindest noch Daten verarbeiten, die von der Legacy-Lösung eingegeben wurden. Ich würde diesen Ansatz wahrscheinlich nicht empfehlen, aber manchmal ist es ein vernünftiger Kompromiss zwischen Zeit / Zeitplan / Ressourcen / erforderlicher neuer Funktionalität.

• Trennen Sie die Präsentationsschicht mindestens von der Geschäfts- und der Persistenzschicht.
• Implementieren Sie eine neue Benutzeroberfläche und eine bessere Präsentationsschicht, die dieselbe gemeinsame Geschäfts- und Persistenzschicht verwendet.
• Stellen Sie sicher, dass mit der neuen Benutzeroberfläche erstellte Daten die alte Benutzeroberfläche nicht beschädigen. (Sie werden in heißem Wasser sein, wenn Benutzer des neuen Tools Benutzer des alten Tools unterbrechen). Wenn Sie vollständige Abwärtskompatibilität anstreben, sollten Sie alles auf denselben Persistenz-Ebenen speichern. Wenn Sie nur die Vorwärtskompatibilität mit dem neuen Tool wünschen, verwenden Sie eine neue Datenbank und neue Tabellen oder Erweiterungstabellen, um Daten zu verfolgen, die sich nicht in einem älteren System befinden.
• Um neue Funktionen und Anforderungen für die Persistenzschicht zu erfüllen, fügen Sie keine neuen Tabellen hinzu, und Methoden ändern weder die vorhandene Legacy-Logik noch fügen Sie Spalten und Einschränkungen zu vorhandenen Tabellen hinzu. Wenn Sie beispielsweise den Notfallkontakt des Arbeitgebers nachverfolgen müssen und einige andere Felder die vorhandene Mitarbeitertabelle nicht ändern (wir haben keine Ahnung, welche Annahmen die alten Daten zu dieser Tabelle machen), fügen Sie eine Erweiterungstabelle mit der ID employee_ext, employee_id, emergency_contact_id usw._id hinzu.
• Migrieren Sie Benutzer langsam auf ein neues System. Versetzen Sie das Altsystem nach Möglichkeit in den schreibgeschützten Modus, oder fügen Sie nur einige Warnungen hinzu, die darauf hinweisen, dass es nach Datum X nicht mehr verfügbar ist.
• Implementieren Sie alle fehlenden Funktionen oder Geschäftsanforderungen mit hoher Priorität in der neuen Benutzeroberfläche
• Roll über die Benutzerbasis.
• Bereinigen Sie weiterhin die Benutzer der Geschäftslogik und der Persistenzschicht mit anderen Refactoring-Methoden.

Ich würde sagen, es gibt eine dritte Kategorie im Refactor-vs-Rewrite-Bereich ... Und das heißt, Sie aktualisieren Ihre Sprachversionen, Compiler und Bibliotheken ... Manchmal hat es einen großen Vorteil, wenn Sie nur moderne Codiertechniken anwenden.

Nehmen wir zum Beispiel C #. V7-Code schreibt viel sauberer, sicherer und prägnanter als V2. Dinge wie Elvis und der Null-Koaleszenz-Operator helfen dabei.

Das Wechseln von Compilern kann auch älteren Codes neues Leben einhauchen. Vielleicht auch neue Bibliotheken, die das Arbeiten und Implementieren vereinfachen ... Networking ist ein großartiges Beispiel für ein Spektrum von Implementierungsschwierigkeiten.

Auch eingebettete Linux-Systeme ... Denken Sie darüber nach, neue Tools zu installieren - wechseln Sie von svn zu git. oder füge Vi zu deinem System hinzu usw. usw.

Es muss nicht immer ein Refactor oder ein Rewrite sein. Ihre Architektur ist wahrscheinlich verbesserungsbedürftig, aber es funktioniert. Vielleicht müssen Sie nur darüber nachdenken, wie Ihr Code geschrieben ist.

Ich glaube nicht, dass ich jemals Leute gesehen habe , die eine Legacy-App neu geschrieben haben.

Was passiert, ist, dass Leute völlig neue Apps mit einer anderen Architektur, Technologie usw. schreiben, die einige Funktionen gemeinsam mit der vorherigen Generation haben. Und es heißt App 2.0, hat aber in der Tat nur sehr wenige Gemeinsamkeiten mit dem Original.

Dies ist jedoch nicht wirklich ein "Umschreiben" des Originals in dem Sinne, dass Sie versuchen, eine Feature-Parität zu erreichen.