Als Softwareentwickler ist es eine meiner Hauptaufgaben, die Komplexität unter Kontrolle zu halten.
In einigen Projekten gibt es jedoch einen Moment, in dem der Komplexitätsgrad so hoch wird, dass er eine Art "No Return" -Punkt erreicht. Ab diesem Zeitpunkt können Sie das Projekt niemals in kürzerer Zeit auf ein akzeptables Maß an Komplexität zurückführen, als es erforderlich wäre, alles von Grund auf neu zu schreiben.
Hat dieser besondere Moment einen Namen im Dialekt des Programmierers (ähnlich dem Godwinschen Gesetz für Trolle)?
--bearbeiten--
Entschuldigung, wenn ich nicht klar bin. Ich denke nicht, dass dieser "Moment" einen offiziellen Namen hat oder eine ernsthafte Metrik ist. Ich dachte an etwas im Geiste des "Ballmer Peak" in xkcd .
terminology
Thibault J
quelle
quelle
Antworten:
Es geht eher um Wartbarkeit als um Komplexität.
Das Phänomen wird als "technische Verschuldung" bezeichnet, und sobald es ein kritisches Niveau erreicht, ist das Projekt auf dem Weg zum Bankrott.
Ist es das, was du meintest?
quelle
Der "Punkt der übermäßigen Komplexität" wird im Englischen bezeichnet als:
OH MEIN GOTT, WAS IST DIESER MIST.
Das Problem ist, dass dies auf etwas zutreffen kann, das eigentlich einfach ist, aber so schrecklich umgesetzt wird, dass Sie dieselbe Reaktion haben.
Es kann schwierig sein, etwas sehr Komplexes von etwas sehr Schrecklichem zu unterscheiden.
JEDOCH: Was eigentlich mit jeder Software passiert, ist ein Prozess wie dieser:
Schritt 1: Haben Sie eine schöne Spezifikation, machen Sie ein schönes Design, implementieren Sie schöne Sachen. Alle glücklich.
Am Ende von Schritt 1: Die Entwickler beglückwünschen sich zu der wunderbaren Eleganz ihres Designs und denken glücklich: "Ich habe hier ein wunderbares Vermächtnis, das andere in Zukunft ergänzen können. Es wird wunderbar sein und die Welt wird ein besserer Ort."
Schritt 2: Es werden einige Änderungen vorgenommen, Dinge hinzugefügt und neue Funktionen hinzugefügt. Die Architektur und Struktur von Schritt 1 machten dies zu einem ziemlich schmerzlosen Prozess. [Aber hoppla, der "Cruft-Faktor" hat sich nur ein bisschen erhöht.]
Am Ende von Schritt 2: Die Entwickler beglückwünschen sich zu der wunderbaren Eleganz ihres Designs und denken glücklich: "Ich bin so schlau, all diese Dinge in Schritt 1 berücksichtigt zu haben. Das ist so gut gelaufen. Ich habe ein wunderbares Erbe hier, damit andere in Zukunft etwas hinzufügen können, wird es wunderbar sein und die Welt wird ein besserer Ort sein. "
Schritt 3: Es werden mehr Änderungen vorgenommen, es werden mehr Dinge hinzugefügt, es werden mehr neue Funktionen hinzugefügt, eine Menge Dinge werden geändert, das Feedback der Benutzer wird tatsächlich angehört.
Am Ende von Schritt 3: Die Entwickler beglückwünschen sich zu der wunderbaren Eleganz ihres Designs und gehen ziemlich fröhlich davon über X und Y und Z. Sie könnten jetzt ein bisschen aufgeräumt werden. Aber !!! Ahhh !!! Ich bin so schlau, all diese Rücksichten in Schritt 1 gemacht zu haben. Das lief so gut. Ich habe ein wundervolles Vermächtnis hier für andere Dinge in Zukunft hinzuzufügen, wird es wunderbar sein und die Welt wird ein besserer Ort sein. "
Schritt 4: Genau wie Schritt 3. Außer:
Am Ende von Schritt 4: Die Entwickler denken: "Dieses Zeug, das so gut war, wird immer hässlicher. Es braucht wirklich einige gravierende Änderungen. Ich mag es nicht wirklich, daran zu arbeiten. Es muss umgestaltet werden. Ich frage mich, was der Chef ist werde sagen, wenn ich ihm sage, dass es 6 Wochen dauert und am Ende nichts für die Benutzer zu sehen sein wird ... aber ich werde weitere 5 Jahre leckeren zukünftigen Änderungsumfang haben, indem ich dies tue ... hmmm ... Zeit, in die Kneipe zu gehen und ein Bier zu trinken. "
Schritt 5: Es müssen einige Änderungen vorgenommen werden.
Und WÄHREND Schritt 5 sagen die Entwickler zueinander: "Dieser Code ist zum Kotzen. Wer hat das geschrieben? Sie sollten erschossen werden. Es ist schrecklich. Wir MÜSSEN ES NEU SCHREIBEN."
Schritt 5 ist tödlich. Dies ist der Punkt, an dem der Cruft-Faktor so schlecht geworden ist, dass der Code nicht nur ein paar weitere Änderungen aufweisen kann, sondern auch einige BIG-Änderungen erforderlich sind.
Das Problem bei Schritt 5 ist das Verlangen, es wegzuwerfen und von vorne zu beginnen. Der Grund dafür ist "The Netscape Factor". Go google es. Unternehmen sterben an diesem Punkt, denn wenn man wieder anfängt, beginnt man mit ungefähr 50% Annahmen anstelle von Fakten, 150% Enthusiasmus anstelle von Wissen, 200% Arroganz anstelle von Demut ("Diese Leute waren so doof!"). Und Sie führen eine ganze Reihe neuer Fehler ein.
Am besten umgestalten. Ändern Sie ein wenig nach dem anderen. Wenn die Architektur etwas müde wird, beheben Sie sie. Hinzufügen, erweitern, verbessern. Allmählich. Testen, testen und testen Sie bei jedem Schritt auf dem Weg etwas mehr. Inkrementelle Änderungen wie diese bedeuten, dass der aktuelle und ursprüngliche Code 10 Jahre später wie die Axt des Großvaters ist ("es hatte 10 neue Köpfe und 3 neue Griffe, aber es ist immer noch die Axt des Großvaters"). Mit anderen Worten, es gibt nicht mehr viel Gemeinsamkeiten. Aber Sie sind allmählich und vorsichtig vom Alten zum Neuen übergegangen. Dies reduziert das Risiko und für die Kunden den Verärgerungsfaktor.
quelle
Ich stimme zu, dass der Moment schwer zu erkennen ist und durch geeignete Prozesse vermieden werden kann. Die Frage war jedoch, wie man es nennt. In der Realwirtschaft gibt es das Konzept der "sinkenden Rendite": Der Punkt, an dem die Erhöhung des Inputs für eine Ressource in einem Prozess Ihren Gesamtgewinn pro Einheit senkt. Dies gilt mit Sicherheit für die Codierung, und selbst gute Dinge wie Abstraktion, Wiederverwendung usw. haben einen solchen Punkt, dass die Rendite sinkt. Der allgemeine programmspezifische Begriff lautet "Überentwicklung". Für jemanden, der dazu neigt, mag ich Joels Begriff " Architektur-Astronaut ".
quelle
Zu oft wird guter Code unter dem falschen Eindruck verworfen, dass das neue Team mit neuen Tools es billiger, schneller und zuverlässiger machen kann, nur um das zu finden
Möglicherweise kommt die von Ihnen beschriebene Zeit mit einigen Codebasen (ich dachte es früher). Ich habe noch nie persönlich einen Fall erlebt, in dem alter Code dazu führte, dass ein Projekt nicht mehr funktionierte, oder dass Code neu geschrieben wurde, um ein Projekt zu speichern.
In diesen Fällen, in denen Metriken verwendet wurden, um bestimmte problematische Module oder Designs zu identifizieren, die dann ausgesondert und ersetzt wurden, schließe ich diese nicht ein.
quelle
Das eigentliche Problem mit diesem theoretischen "Moment" ist, dass es erst nachträglich erkannt wird. Sofern Ihre Kollegen keine Psychopathen sind, wird jedes einzelne Commit in die Codebasis mit der Überzeugung ausgeführt, dass es eine Verbesserung dieser Codebasis darstellt. Wenn Sie nur auf das folgende Durcheinander zurückblicken, können Sie feststellen, dass Sie diesen "Moment" vergangen haben.
Aber ich mag es, dass wir ihm einen Namen geben können. "Gents", könnte man sagen, während sich Ihre Mitentwickler um Sie scharten, "wir haben den Hellespont für Wartbarkeit überschritten. Schreiben Sie Ihrer Frau eine SMS und lassen Sie sie wissen, dass Sie sie eine Weile nicht sehen werden."
quelle
Ich weiß nicht, ob es einen Namen gibt, aber wenn es keinen gibt, würde ich vorschlagen, ihn "Schmelzpunkt" zu nennen.
quelle
Dies ist keine sehr interessante Frage.
In der Tat ist es trivial.
Es ist so trivial, dass wir zahlreiche Möglichkeiten entwickelt haben, um damit umzugehen.
Wasserfall-Methoden. Viele Leute verbringen viel Zeit damit, Anforderungen und Designdokumente zu überprüfen, um sicherzustellen, dass die Komplexität verwaltet wird.
Agile Methoden. Weniger Leute verbringen weniger Zeit damit, darüber zu diskutieren, was unmittelbar anwendbar ist, um das Problem einer Person zu lösen und Software für sie freizugeben. Komplexität wird gemanagt, weil jeder darauf bedacht ist, etwas herauszubringen.
Das einzige Mal, dass jemand mit "Komplexität" ringt, ist, dass er die Methodik nicht befolgt und seine Zeit nicht richtig verwaltet.
Keine detaillierte Überwachung in einer Wasserfallmethode. Sie sind nicht gezwungen, Zwischenprodukte auf Anforderungen, Architektur, High-Level-Design oder detaillierte Designprüfungen zu überprüfen.
Keine Sprint-Frist oder richtige Prioritäten für Anwendungsfälle in einer agilen Methodik. Sie konzentrieren sich nicht darauf, dem Benutzer so schnell wie möglich etwas freizugeben.
Die Komplexität sollte durch die Festlegung von Zielen begrenzt werden.
Ringen mit Komplexität bedeutet, dass Ziele nicht richtig gesetzt oder belohnt werden.
Es gibt keinen "Wendepunkt". Wenn Komplexitätsmanagement ein Problem darstellt, stimmt organisatorisch bereits etwas nicht.
quelle
Es gibt Methoden, um das Risiko einer zunehmenden Komplexität von (großen) Projekten und Code zu visualisieren und zu überwachen. Wenn sie vernünftigerweise angewendet werden, wird hoffentlich kein neuer Name für den Punkt ohne Rückkehr benötigt. (Es gibt ein ähnliches MOOC bei openHPI: https://open.hpi.de/courses/softwareanalytics2015/ )
Strukturelle Komplexität ist ein allgemeines Designproblem - nicht nur für das Software-Design in großen Teams. Die Visualisierung ist der erste Schritt im strukturellen Komplexitätsmanagement. Zu diesem Zweck können auch Matrizen und gerichtete Graphen verwendet werden.
Einige Methoden zur Reduzierung der strukturellen Komplexität sind http://www.buch.de/shop/home/suche/?fq=3540878890 :
Darüber hinaus gibt es das Konzept des axiomatischen Designs: https://en.wikipedia.org/wiki/Axiomatic_design Mit diesem Konzept können Zuverlässigkeitsprobleme aufgrund unnötiger Komplexität vermieden werden.
Somit stehen eine Reihe von Methoden zur Verfügung. Am Ende geht es immer um die Entscheidung, darüber nachzudenken, weil ein Projekt groß genug wird.
quelle