Wie man zufällige Komplexität in Softwareprojekten handhabt

Als Murray Gell-Mann gefragt wurde, wie Richard Feynman so viele schwierige Probleme lösen konnte, antwortete Gell-Mann, dass Feynman einen Algorithmus hatte:

1. Notieren Sie das Problem.
2. Denken Sie wirklich gut nach.
3. Notieren Sie die Lösung.

Gell-Mann versuchte zu erklären, dass Feynman eine andere Art von Problemlöser war und es keine Erkenntnisse gab, die durch das Studium seiner Methoden gewonnen werden konnten. Ich sehe die Komplexität in mittleren und großen Softwareprojekten ähnlich. Die Leute, die gut sind, sind einfach von Natur aus gut darin und schaffen es irgendwie, verschiedene Abstraktionen zu überlagern und zu stapeln, um das Ganze handhabbar zu machen, ohne irgendwelche fremden Dinge einzuführen.

Ist der Feynman-Algorithmus also die einzige Möglichkeit, die zufällige Komplexität zu verwalten, oder gibt es tatsächliche Methoden, die Software-Ingenieure konsequent anwenden können, um die zufällige Komplexität zu zähmen?

Wenn Sie einen guten Zug sehen, suchen Sie nach einem besseren.
- Emmanuel Lasker, 27-jähriger Schachweltmeister

Nach meiner Erfahrung ist der größte Faktor für die zufällige Komplexität, dass Programmierer am ersten Entwurf festhalten, nur weil er zufällig funktioniert. Das können wir aus unseren Englisch-Kompositionskursen lernen. Sie bauen rechtzeitig auf, um mehrere Entwürfe in ihren Aufträgen durchzugehen und das Feedback der Lehrer zu berücksichtigen. Programmierunterricht aus irgendeinem Grund nicht.

Es gibt Bücher voller konkreter und objektiver Methoden, um suboptimalen Code zu erkennen, zu artikulieren und zu korrigieren: Bereinigen von Code , Effizientes Arbeiten mit Legacy-Code und viele andere. Viele Programmierer sind mit diesen Techniken vertraut, nehmen sich jedoch nicht immer die Zeit, sie anzuwenden. Sie sind perfekt in der Lage, die zufällige Komplexität zu reduzieren. Sie haben es sich einfach nicht zur Gewohnheit gemacht, es zu versuchen .

Ein Teil des Problems ist, dass wir die Komplexität des Codes anderer nicht oft bemerken, es sei denn, er wurde in einem frühen Stadium einer Peer Review unterzogen. Sauberer Code scheint einfach zu schreiben zu sein, obwohl es sich in der Regel um mehrere Entwürfe handelt. Sie schreiben den besten Weg, der Ihnen zuerst einfällt, bemerken unnötige Komplexitäten, die sich daraus ergeben, suchen dann nach einem "besseren Schachzug" und überarbeiten, um diese Komplexitäten zu beseitigen. Dann suchen Sie so lange nach einem besseren Zug, bis Sie keinen mehr finden.

Sie geben den Code jedoch erst nach all der Abwanderung zur Überprüfung aus, sodass es äußerlich so aussieht, als ob es sich ebenfalls um einen Feynman-ähnlichen Prozess handeln könnte. Sie neigen dazu zu glauben, dass Sie nicht alles auf diese Weise schaffen können, und versuchen es nicht, aber die Wahrheit ist, dass der Autor dieses wunderbar einfachen Codes, den Sie gerade gelesen haben, normalerweise nicht alles in einem Stück schreiben kann Entweder so oder, wenn sie können, nur, weil sie bereits viele Male Erfahrung mit dem Schreiben von ähnlichem Code haben und jetzt das Muster ohne Zwischenschritte sehen können. So oder so können Sie die Zugluft nicht vermeiden.

"Software-Architektur-Kenntnisse können nicht vermittelt werden" ist ein weit verbreiteter Irrtum.

Es ist leicht zu verstehen, warum viele Leute es glauben (diejenigen, die es gut können, wollen glauben, dass sie mystisch besonders sind, und diejenigen, die nicht glauben wollen, dass es nicht ihre Schuld ist, dass sie es nicht sind) ist doch falsch; Die Fertigkeit ist nur etwas praxisintensiver als andere Software-Fertigkeiten (z. B. Schleifen verstehen, mit Zeigern umgehen usw.)

Ich bin der festen Überzeugung, dass der Bau großer Systeme wiederholtem Üben und Lernen aus Erfahrung unterworfen ist, so wie es ein guter Musiker oder Redner ist: Ein Minimum an Talent ist eine Voraussetzung, aber es ist kein bedrückend großes Minimum Reichweite der meisten Praktizierenden.

Der Umgang mit Komplexität ist eine Fähigkeit, die Sie sich größtenteils aneignen, wenn Sie ein paar Mal versuchen und nicht bestehen. Es ist nur so, dass die vielen allgemeinen Richtlinien, die die Community für das Programmieren im Großen entdeckt hat (Ebenen verwenden, Duplizierung bekämpfen, wo immer sie den Kopf hebt, religiös an 0/1 / unendlich festhalten ...), nicht so offensichtlich richtig und notwendig sind für a Anfänger, bis sie tatsächlich etwas programmieren, das groß ist. Solange Sie nicht erst Monate später von einer Vervielfältigung gebissen wurden, die zu Problemen führte, können Sie die Wichtigkeit solcher Prinzipien einfach nicht „verstehen“.

Pragmatisches Denken von Andy Hunt spricht dieses Problem an. Es bezieht sich auf das Dreyfus-Modell, nach dem es 5 Stufen von Kenntnissen in verschiedenen Fertigkeiten gibt. Die Anfänger (Stufe 1) benötigen genaue Anweisungen, um etwas richtig machen zu können. Experten (Stufe 5) können dagegen allgemeine Muster auf ein bestimmtes Problem anwenden. Unter Berufung auf das Buch,

Für Experten ist es oft schwierig, ihre Handlungen bis ins kleinste Detail zu erklären. Viele ihrer Reaktionen sind so gut geübt, dass sie zu vorbewussten Handlungen werden. Ihre große Erfahrung wird von nonverbalen, vorbewussten Bereichen des Gehirns abgebaut, was es uns schwer macht, sie zu beobachten und zu artikulieren.

Wenn Experten ihr Ding machen, erscheint es uns allen beinahe magisch - seltsame Beschwörungsformeln, Einsichten, die aus dem Nichts zu kommen scheinen, und die scheinbar unheimliche Fähigkeit, die richtige Antwort zu kennen, wenn der Rest von uns nicht einmal so sicher ist über die Frage. Das ist natürlich keine Zauberei, aber die Art und Weise, wie Experten die Welt wahrnehmen, wie sie Probleme lösen, welche mentalen Modelle sie verwenden usw. unterscheiden sich deutlich von denen anderer Experten.

Diese allgemeine Regel des Sehens (und des Vermeidens) verschiedener Probleme kann speziell auf das Problem der zufälligen Komplexität angewendet werden. Es reicht nicht aus, einen bestimmten Satz von Regeln zu haben, um dieses Problem zu vermeiden. Es wird immer eine Situation geben, die von diesen Regeln nicht abgedeckt wird. Wir müssen Erfahrung sammeln, um Probleme vorhersehen oder Lösungen finden zu können. Erfahrung ist etwas, was nicht gelehrt werden kann. Sie kann nur durch ständiges Versuchen, Scheitern oder Erfolg und Lernen aus Fehlern gewonnen werden.

Diese Frage vom Arbeitsplatz ist relevant und IMHO wäre in diesem Zusammenhang interessant zu lesen.

Sie formulieren es nicht aus, aber „zufällige Komplexität“ ist definiert als Komplexität, die dem Problem nicht inhärent ist, im Vergleich zu „wesentlicher“ Komplexität. Welche Techniken für "Zähmen" erforderlich sind, hängt davon ab, von wo Sie ausgehen. Das Folgende bezieht sich hauptsächlich auf Systeme, die bereits unnötige Komplexität erlangt haben.

Ich habe Erfahrung in einer Reihe von großen mehrjährigen Projekten, bei denen die „zufällige“ Komponente den „wesentlichen“ Aspekt deutlich überwog, und auch diejenigen, bei denen dies nicht der Fall war.

Tatsächlich gilt der Feynman-Algorithmus in gewissem Maße, aber das bedeutet nicht, dass „wirklich hart denken“ nur Magie bedeutet, die nicht kodifiziert werden kann.

Ich finde, es gibt zwei Ansätze, die verfolgt werden müssen. Nehmen Sie sie beide - sie sind keine Alternativen. Zum einen geht es Stück für Stück darum, und zum anderen geht es um eine größere Überarbeitung. Also schreiben Sie das Problem auf. Dies kann in Form eines Audits des Systems erfolgen - der Codemodule, ihres Zustands (Geruch, Grad des automatisierten Testens, wie viele Mitarbeiter behaupten, dies zu verstehen), der Gesamtarchitektur (es gibt eine, auch wenn sie „Probleme“ hat). ), Anforderungsstatus usw. usw.

Es liegt in der Natur der „zufälligen“ Komplexität, dass es kein einziges Problem gibt, das nur angesprochen werden muss. Sie müssen also eine Triage durchführen. Wo tut es weh - in Bezug auf die Fähigkeit, das System zu warten und seine Entwicklung voranzutreiben? Möglicherweise riecht etwas Code wirklich, hat aber nicht die höchste Priorität, und es ist möglich, das Problem zu beheben. Andererseits kann es Code geben, der die für die Umgestaltung aufgewendete Zeit schnell zurückgibt.

Definieren Sie einen Plan für eine bessere Architektur und stellen Sie sicher, dass neue Arbeiten diesem Plan entsprechen - dies ist der schrittweise Ansatz.

Formulieren Sie auch die Kosten der Probleme und verwenden Sie diese, um einen Geschäftsfall zu erstellen, der einen Refaktor rechtfertigt. Das Entscheidende dabei ist, dass ein gut aufgebautes System viel robuster und testbarer sein kann, was zu einer viel kürzeren Zeit (Kosten und Zeitplan) für die Implementierung von Änderungen führt - dies hat einen echten Wert.

In der Kategorie „Denken Sie wirklich hart“ gibt es eine große Überarbeitung - Sie müssen es richtig machen. Hier zahlt sich ein "Feynman" (na ja, ein kleiner Bruchteil davon wäre in Ordnung) enorm aus. Eine größere Überarbeitung, die nicht zu einer besseren Architektur führt, kann eine Katastrophe sein. Vollständige Systemumschreibungen sind dafür berüchtigt.

Bei jedem Ansatz muss man wissen, wie man „zufällige“ von „wesentlichen“ unterscheidet - das heißt, man muss einen großartigen Architekten (oder ein Team von Architekten) haben, der das System und seinen Zweck wirklich versteht.

Trotzdem ist für mich das automatisierte Testen der Schlüssel . Wenn Sie genug davon haben, ist Ihr System unter Kontrolle. Wenn nicht. . .

" Alles sollte so einfach wie möglich gemacht werden, aber nicht einfacher. "
- Albert Einstein zugeschrieben

Lassen Sie mich meinen persönlichen Algorithmus für den Umgang mit zufälliger Komplexität skizzieren.

1. Schreiben Sie eine User Story oder einen Use Case. Bewertung mit dem Produktbesitzer.
2. Schreiben Sie einen Integrationstest, der fehlschlägt, weil die Funktion nicht vorhanden ist. Überprüfen Sie mit der Qualitätssicherung oder dem leitenden Ingenieur, ob es in Ihrem Team so etwas gibt.
3. Schreiben Sie Komponententests für einige Klassen, die den Integrationstest bestehen könnten.
4. Schreiben Sie die minimale Implementierung für die Klassen, die die Komponententests bestehen.
5. Überprüfen Sie Unit-Tests und die Implementierung mit einem anderen Entwickler. Weiter mit Schritt 3.

Die ganze Design-Magie steckt in Schritt 3: Wie richten Sie diese Klassen ein? Dies stellt sich die gleiche Frage wie: Wie stellen Sie sich vor, dass Sie eine Lösung für Ihr Problem haben, bevor Sie eine Lösung für Ihr Problem haben?

Bemerkenswerterweise scheint die bloße Vorstellung, Sie hätten die Lösung , eine der Hauptempfehlungen von Leuten zu sein, die über Problemlösung schreiben (von Abelson und Sussman "Wunschdenken" in Struktur und Interpretation von Computerprogrammen und "Rückwärtsarbeiten" in Polyas How to Löse es )

Auf der anderen Seite hat nicht jeder den gleichen " Geschmack für imaginäre Lösungen ": Es gibt Lösungen, die nur Sie elegant finden, und es gibt andere, die für ein breiteres Publikum verständlicher sind. Aus diesem Grund müssen Sie Ihren Code gemeinsam mit anderen Entwicklern einer Peer-Review unterziehen: nicht so sehr, um die Leistung zu optimieren, sondern um verständliche Lösungen zu finden. Normalerweise führt dies zu einer Neugestaltung und nach einigen Iterationen zu einem viel besseren Code.

Wenn Sie nur minimale Implementierungen schreiben , um Ihre Tests zu bestehen, und Tests schreiben, die von vielen Menschen verstanden werden, sollten Sie mit einer Codebasis enden, bei der nur noch nicht reduzierbare Komplexität übrig bleibt.

Zufällige Komplexität

Die ursprüngliche Frage (umschrieben) lautete:

Wie gehen Architekten mit der zufälligen Komplexität von Softwareprojekten um?

Eine zufällige Komplexität entsteht, wenn diejenigen, die über ein Projekt verfügen, einzelne Technologien hinzufügen und die Gesamtstrategie der ursprünglichen Architekten des Projekts nicht beabsichtigte, diese in das Projekt einzubeziehen. Aus diesem Grund ist es wichtig, die Gründe für die Wahl der Strategie festzuhalten.

Unvorhergesehene Komplexität kann durch Führung verhindert werden, die an ihrer ursprünglichen Strategie festhält, bis eine bewusste Abweichung von dieser Strategie offensichtlich erforderlich wird.

Unnötige Komplexität vermeiden

Basierend auf dem Hauptteil der Frage würde ich sie folgendermaßen umformulieren:

Wie managen Architekten Komplexität in Softwareprojekten?

Diese Neuformulierung entspricht eher dem Kern der Frage, in dem der Feynman-Algorithmus eingeführt wurde, und bietet einen Kontext, der vorschlägt, dass die besten Architekten, wenn sie mit einem Problem konfrontiert werden, eine Gestalt haben, aus der sie gekonnt eine Lösung konstruieren, und dass der Rest von uns nicht hoffen kann, dies zu lernen. Die Fähigkeit zum Verständnis hängt von der Intelligenz des Fachs und seiner Bereitschaft ab, die Merkmale der architektonischen Optionen zu kennen, die in ihren Anwendungsbereich fallen könnten.

Der Planungsprozess für das Projekt verwendet das Lernen der Organisation, um eine Liste der Anforderungen des Projekts zu erstellen. Anschließend wird versucht, eine Liste aller möglichen Optionen zu erstellen und die Optionen mit den Anforderungen abzustimmen. Die Gestalt des Experten ermöglicht es ihm, dies schnell und vielleicht mit wenig offensichtlicher Arbeit zu tun, so dass es so aussieht, als würde es ihm leicht fallen.

Ich sage Ihnen, dass es wegen seiner Vorbereitung zu ihm kommt. Um die Kompetenz des Experten zu erlangen, müssen Sie mit all Ihren Optionen vertraut sein und vorausschauend eine einfache Lösung finden, die die geplanten zukünftigen Anforderungen berücksichtigt, die das Projekt vorsehen sollte, sowie die Flexibilität, sich an die sich ändernden Anforderungen von anzupassen das Projekt. Feynmans Vorbereitung war, dass er ein tiefes Verständnis für verschiedene Ansätze sowohl in der theoretischen als auch in der angewandten Mathematik und Physik hatte. Er war von Natur aus neugierig und hell genug, um die Dinge zu verstehen, die er über die natürliche Welt um ihn herum entdeckte.

Der erfahrene Technologiearchitekt wird eine ähnliche Neugier haben, die sich auf ein tiefes Verständnis der Grundlagen sowie eine breite Exposition gegenüber einer großen Vielfalt von Technologien stützt. Er (oder sie) wird die Weisheit haben, auf die Strategien zurückzugreifen, die in verschiedenen Bereichen erfolgreich waren (wie z. B. Prinzipien der Unix-Programmierung ), und auf diejenigen, die für bestimmte Bereiche gelten (wie z. B. Entwurfsmuster und Stilrichtlinien ). Er ist möglicherweise nicht mit jeder Ressource bestens vertraut, weiß jedoch, wo sich die Ressource befindet.

Die Lösung erstellen

Diese Ebene des Wissens, Verstehens und der Weisheit kann aus Erfahrung und Bildung gewonnen werden, erfordert jedoch Intelligenz und geistige Aktivität, um eine strategische Lösung zusammenzustellen, die so zusammenarbeitet, dass zufällige und unnötige Komplexität vermieden wird. Der Experte muss diese Grundlagen zusammenstellen. Dies waren die Wissensarbeiter, die Drucker vorausgesehen hatte, als er den Begriff zum ersten Mal prägte.

Zurück zu den spezifischen letzten Fragen:

Spezifische Methoden zur Beherrschung der zufälligen Komplexität finden Sie in den folgenden Quellen.

• Prinzipien der Unix-Programmierung
• Designmuster
• und Styleguides ( zB Pythons PEP 8 )

Wenn Sie den Prinzipien der Unix-Programmierung folgen, können Sie einfache modulare Programme erstellen, die gut funktionieren und robust sind und über gemeinsame Schnittstellen verfügen. Das Befolgen von Entwurfsmustern hilft Ihnen dabei, komplexe Algorithmen zu erstellen, die nicht komplexer als nötig sind. Durch das Befolgen der Style Guides wird sichergestellt, dass Ihr Code lesbar, wartbar und für die Sprache, in der Ihr Code geschrieben ist, optimal ist. Experten werden viele der in diesen Ressourcen enthaltenen Prinzipien verinnerlicht haben und in der Lage sein, sie nahtlos zusammenzufügen.

Dies mag vor einigen Jahren eine schwierige Frage gewesen sein, aber es ist heutzutage nicht mehr schwierig, die zufällige Komplexität zu beseitigen.

Was Kent Becksaid irgendwann über sich selbst sagte: "Ich bin kein großartiger Programmierer, ich bin nur ein guter Programmierer mit großartigen Gewohnheiten."

Zwei Dinge sind es wert, hervorgehoben zu werden, IMO: Er sieht sich als Programmierer , nicht als Architekt, und sein Fokus liegt auf Gewohnheiten, nicht auf Wissen.

Feynmans Art, schwierige Probleme zu lösen, ist der einzige Weg, dies zu tun. Die Beschreibung ist nicht unbedingt leicht zu verstehen, deshalb werde ich sie analysieren. Feynmans Kopf war nicht nur voller Wissen, sondern auch voller Fähigkeit, dieses Wissen anzuwenden. Wenn Sie sowohl über das Wissen als auch die Fähigkeiten verfügen, um es anzuwenden, ist die Lösung eines schwierigen Problems weder schwierig noch einfach. Es ist das einzig mögliche Ergebnis.

Es gibt eine völlig unmagische Art, sauberen Code zu schreiben, der keine zufällige Komplexität enthält, und sie ähnelt größtenteils der Vorgehensweise von Feynman: Erwerben Sie alle erforderlichen Kenntnisse, trainieren Sie, um sich daran zu gewöhnen, ihn in die Praxis umzusetzen, anstatt ihn einfach verstauen zu lassen Schreiben Sie in einer Ecke Ihres Gehirns sauberen Code.

Viele Programmierer sind sich nicht einmal des Wissens bewusst, das zum Schreiben sauberen Codes erforderlich ist. Jüngere Programmierer neigen dazu, Wissen über Algorithmen und Datenstrukturen zu verwerfen, und die meisten älteren Programmierer neigen dazu, es zu vergessen. Oder große O-Notation und Komplexitätsanalyse. Ältere Programmierer neigen dazu, Muster oder Codegerüche zu verwerfen - oder gar nicht zu wissen, dass sie existieren. Die meisten Programmierer jeder Generation, auch wenn sie sich mit Mustern auskennen, erinnern sich nie an den genauen Verwendungszeitpunkt und die Treiberteile. Nur wenige Programmierer jeder Generation bewerten ihren Code ständig anhand der SOLID-Prinzipien. Viele Programmierer mischen überall alle möglichen Abstraktionsebenen. Ich kenne vorerst keinen Programmierkollegen, der seinen Code ständig anhand der von Fowler in seinem Refactoring-Buch beschriebenen Stenches bewertet. Obwohl einige Projekte ein Metrik-Tool verwenden, ist die am häufigsten verwendete Metrik die Komplexität der einen oder anderen Art, während zwei andere Metriken - Kopplung und Kohäsion - weitgehend ignoriert werden, auch wenn sie für sauberen Code sehr wichtig sind. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten später Probleme verursachen können. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Die am häufigsten verwendete Metrik ist die Komplexität der einen oder anderen Art, während zwei andere Metriken - Kopplung und Kohäsion - weitgehend ignoriert werden, auch wenn sie für sauberen Code sehr wichtig sind. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten zwangsläufig später zu Problemen führen. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Die am häufigsten verwendete Metrik ist die Komplexität der einen oder anderen Art, während zwei andere Metriken - Kopplung und Kohäsion - weitgehend ignoriert werden, auch wenn sie für sauberen Code sehr wichtig sind. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten später Probleme verursachen können. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Zwei andere Metriken - Kopplung und Kohäsion - werden weitgehend ignoriert, auch wenn sie für sauberen Code sehr wichtig sind. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten zwangsläufig später zu Problemen führen. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Zwei andere Metriken - Kopplung und Kohäsion - werden weitgehend ignoriert, auch wenn sie für sauberen Code sehr wichtig sind. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten später Probleme verursachen können. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten später Probleme verursachen können. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. Ein weiterer Aspekt, den fast jeder ignoriert, ist die kognitive Belastung. Nur wenige Programmierer betrachten Komponententests als Dokumentation, und noch weniger sind sich bewusst, dass schwer zu schreibende oder zu benennende Komponententests ein weiterer Code-Gestank sind, der in der Regel auf schlechtes Factoring hinweist. Eine winzige Minderheit ist sich des Mantras des domänengetriebenen Designs bewusst, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten später Probleme verursachen können. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. s Mantra, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten zwangsläufig später zu Problemen führen. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann. s Mantra, um das Codemodell und das Geschäftsdomänenmodell so nah wie möglich beieinander zu halten, da Unstimmigkeiten zwangsläufig später zu Problemen führen. All dies muss immer berücksichtigt werden, wenn Sie Ihren Code bereinigen möchten. Und viele mehr, an die ich mich momentan nicht erinnern kann.

Sie möchten sauberen Code schreiben? Es ist keine Magie erforderlich. Lernen Sie einfach alles, was erforderlich ist, und verwenden Sie es, um die Sauberkeit Ihres Codes zu beurteilen und zu überarbeiten, bis Sie zufrieden sind. Und lernen Sie weiter - Software ist noch ein junges Gebiet, und neue Erkenntnisse und Kenntnisse werden schnell gewonnen.