Woher wissen Quick & Dirty-Programmierer, dass sie es richtig verstanden haben?

Wenn Sie Programmierer fragen, warum sie sauberen Code schreiben sollen, lautet die Antwort Nummer eins: Wartbarkeit. Während das auf meiner Liste steht, ist mein Hauptgrund unmittelbarer und weniger uneigennützig: Ich kann nicht sagen, ob mein neuer Code korrekt ist, wenn er zu schmutzig ist. Ich stelle fest, dass ich mich so sehr auf einzelne Funktionen und Codezeilen konzentriert habe, dass es manchmal nicht sehr gut zusammenpasst, wenn ich meinen ersten Entwurf beende und zurücktrete, um das Gesamtbild noch einmal zu betrachten. Ein oder zwei Stunden Refactoring zur Verbesserung der Sauberkeit decken häufig Kopier- / Einfügefehler oder Randbedingungen auf, die im rauen Luftzug nur schwer zu erkennen waren.

Einige Leute halten es jedoch gelegentlich für in Ordnung, absichtlich schmutzigen Code im Interesse der Versandsoftware einzuchecken, mit dem Plan, "später aufzuräumen". Gibt es eine praktikable Technik, die ihnen Vertrauen in die Richtigkeit ihres Codes gibt, wenn die Lesbarkeit nicht optimal ist? Lohnt es sich, diese Fähigkeit zu entwickeln? Oder ist ein Mangel an Vertrauen in den Code für manche einfach leichter zu akzeptieren?

Der Code ist wahrscheinlich nicht richtig.

Möglicherweise spielt es jedoch keine Rolle.

Schnell und schmutzig kann der richtige Weg sein, wenn:

• Der Code hat eine kurze Lebensdauer . Beispielsweise wandeln Sie eine Reihe von Daten mit einem Ad-hoc-Programm in ein Standardformat um.
• Die negativen Auswirkungen von Fehlern sind gering :
  • Die Daten, die Sie transformieren, sind unkritisch und Fehler können leicht korrigiert werden
  • Der Endbenutzer ist ein sympathischer Programmierer, der über Fehlermeldungen nachdenkt und sie umgeht, indem er beispielsweise die Eingabe massiert.

Manchmal ist es nicht wichtig, dass Code robust ist und alle denkbaren Eingaben verarbeitet. Manchmal muss es nur die bekannten Daten verarbeiten, die Sie zur Hand haben.

In dieser Situation, wenn Unit-Tests Ihnen helfen, den Code schneller zu schreiben (das ist bei mir der Fall), dann verwenden Sie sie. Ansonsten Code schnell und schmutzig, erledigen Sie die Arbeit. Fehler, die nicht auslösen, spielen keine Rolle. Fehler, die Sie im laufenden Betrieb beheben oder umgehen, spielen keine Rolle.

Entscheidend ist, dass Sie diese Situationen nicht falsch diagnostizieren. Wenn Sie schnell und schmutzig codieren, weil der Code nur einmal verwendet wird, dann beschließt jemand, den Code in einem Projekt wiederzuverwenden, das besseren Code verdient. Dieser Code verdient mehr Sorgfalt.

Sie tun es nicht. Ich arbeite derzeit an einer Codebasis, die von "schnellen und schmutzigen" Programmierern erstellt wurde, die "später aufräumen" würden. Sie sind schon lange nicht mehr da und der Code lebt weiter und knarrt in Vergessenheit. Cowboy- Programmierer verstehen im Allgemeinen einfach nicht alle potenziellen Fehlermodi ihrer Software und nicht die Risiken, denen sie das Unternehmen (und die Kunden) aussetzen.

Okay, ich werde die gegnerische Ansicht "verteidigen", da ich das Risiko habe, ein kompletter Downvote-Köder zu sein.

Ich schlage vor, dass wir Entwickler die Tendenz haben, uns übermäßig Gedanken über Dinge wie ordnungsgemäße Vorgehensweise und Code-Sauberkeit zu machen. Ich schlage vor, dass, obwohl diese Dinge wichtig sind, nichts davon zählt, wenn Sie niemals versenden .

Jeder, der schon eine Weile in diesem Geschäft ist, würde wahrscheinlich zustimmen, dass es möglich wäre, mit einem Stück Software mehr oder weniger auf unbestimmte Zeit zu fummeln. Duke Nukem Forever, meine Freunde. Es kommt eine Zeit, in der dieses nette Feature oder diese ach so dringende Umgestaltungsarbeit einfach beiseite gelegt werden sollte und die Sache als FERTIG bezeichnet werden sollte.

Ich habe mich schon oft mit meinen Kollegen gestritten. Es gibt IMMER noch eine Verbesserung, etwas, das "getan" werden sollte, damit es "richtig" ist. Sie können das IMMER finden. Irgendwann in der realen Welt muss gut genug gut genug sein. Keine echte Versand-Software ist perfekt. Keiner. Bestenfalls ist es gut genug.

Solche Programmierer wissen fast nie, dass sie es richtig verstanden haben, glauben es nur . Und der Unterschied ist möglicherweise nicht leicht zu erkennen.

Ich erinnere mich, wie ich programmiert habe, bevor ich das Testen von Einheiten gelernt habe. Und ich erinnere mich an dieses Gefühl des Vertrauens und der Zuversicht auf einer ganz anderen Ebene, nachdem ich meine erste Reihe anständiger Unit-Tests durchgeführt hatte. Ich hatte vorher nicht gewusst, dass es ein solches Maß an Vertrauen in meinen Code gibt.

Für jemanden, dem diese Erfahrung fehlt, ist es unmöglich, den Unterschied zu erklären. Vielleicht entwickeln sie sich sogar ihr ganzes Leben lang im Code-and-Pret-Modus weiter, wohlwollend (und unwissend) im Glauben, dass sie angesichts der Umstände ihr Bestes geben.

Das heißt, es kann in der Tat großartige Programmierer und Ausnahmefälle geben, wenn es einem wirklich gelingt, den gesamten Problemraum in seinem Kopf in einem Zustand des Flusses zu halten. Ich habe seltene Momente wie diesen erlebt, in denen ich genau wusste, was ich schreiben sollte, der Code mühelos aus mir herausflog, ich alle Sonderfälle und Randbedingungen vorhersehen konnte und der resultierende Code einfach funktionierte . Ich bezweifle nicht, dass es Programmgenies gibt, die für längere Zeit oder sogar die meiste Zeit in einem solchen Zustand des Flusses bleiben können, und was sie produzieren, ist schöner Code, scheinbar ohne Anstrengung. Ich vermute, dass solche Personen möglicherweise keine mickrigen Unit-Tests schreiben müssen, um zu überprüfen, was sie bereits wissen. Und wenn Sie wirklich so ein Genie sind, ist es vielleicht in Ordnung (obwohl Sie auch dann nicht für immer an diesem Projekt teilnehmen und über Ihre Nachfolger nachdenken sollten ...). Aber wenn nicht...

Und seien wir ehrlich, wahrscheinlich bist du es nicht. Ich selbst weiß, dass ich es nicht bin. Ich hatte einige seltene Momente des Flusses - und unzählige Stunden der Trauer und des Leidens, die normalerweise durch meine eigenen Fehler verursacht wurden. Es ist besser, ehrlich und realistisch zu sein. Tatsächlich glaube ich, dass die größten Programmierer sich ihrer eigenen Fehlbarkeit und ihrer Fehler in der Vergangenheit voll bewusst sind. Sie haben daher bewusst die Gewohnheit entwickelt, ihre Annahmen zu überprüfen und diese kleinen Unit-Tests zu schreiben, um sich auf der sicheren Seite zu halten. ( "Ich bin kein großartiger Programmierer - nur ein guter Programmierer mit großartigen Gewohnheiten." - Kent Beck.)

Unit-Tests . Es ist die einzige Möglichkeit, Vertrauen in einen Code zu haben (schmutzig oder nicht).

Als Randnotiz;

Abkürzungen sorgen für lange Verzögerungen (Pippin)

Es ist gut zu lernen, zu akzeptieren, dass kein Softwaresystem mit angemessener Komplexität perfekt ist, unabhängig davon, wie oft Unit-Tests und Code-Optimierungen durchgeführt werden. Im Code lauert immer ein gewisses Maß an Chaos und Anfälligkeit für Unerwartetes. Dies bedeutet nicht, dass man nicht versuchen sollte, guten Code zu erstellen oder Komponententests durchzuführen. Das ist natürlich wichtig. Es muss ein Gleichgewicht gefunden werden, das von Projekt zu Projekt unterschiedlich sein wird.

Die Fähigkeit, die entwickelt werden muss, besteht darin, zu verstehen, welcher Grad an "Perfektion" für ein bestimmtes Projekt verwendet werden muss. Wenn Sie beispielsweise einen Antrag auf elektronische Patientenakten mit einer 12-monatigen Projektlaufzeit schreiben, möchten Sie viel mehr Zeit für das Testen und die Pflege Ihres Codes aufwenden als für eine einmalige Web-App zur Konferenzregistrierung das muss bis Freitag bereitgestellt werden. Probleme treten auf, wenn jemand, der die EMR-App ausführt, schlampig wird oder die Registrierungs-App nicht rechtzeitig bereitgestellt wird, weil der Programmierer zu beschäftigt ist, Code zu optimieren.

Schnell und schmutzig ist in einem Subsystem völlig in Ordnung . Wenn Sie eine gut definierte Schnittstelle zwischen Ihrem Mist und dem Rest des Systems haben und eine Reihe von Unit-Tests durchführen, die sicherstellen, dass Sie hässlichen, schnellen und schmutzigen Code verwenden, ist dies möglicherweise in Ordnung.

Möglicherweise haben Sie einen abscheulichen Hack von regulären Ausdrücken und Byte-Offsets, um einige Dateien von Drittanbietern zu analysieren. Angenommen, Sie haben einen Test, der besagt, dass das Ergebnis beim Parsen von Beispieldateien Ihren Erwartungen entspricht. Sie könnten das aufräumen, damit Sie ... Ich weiß nicht, schneller reagieren, wenn ein Dritter ein Dateiformat ändert? Das passiert einfach nicht oft genug. Es ist wahrscheinlicher, dass sie zu einer komplett neuen API wechseln, und Sie werden den alten Parser wegwerfen und einen neuen einsetzen, der der gleichen API entspricht, und voila, Sie sind fertig.

Wo schnell und schmutzig wird ein Problem ist, wenn Ihre Architektur schnell und schmutzig ist. Ihr Kern-Domain-Objekt muss gut durchdacht sein und Ihre Schnittstellen, aber die Ränder Ihres Systems können in der Regel chaotisch sein, ohne dass Sie jemals den Piper bezahlen müssen.

Hier ist eine Geschichte über einen schnellen und schmutzigen Programmierer, den ich kenne.

Ich kenne eine Person, die Unit-Tests als Zeitverschwendung ansieht. Nach langem Streit schrieb er schließlich einen. Es bestand aus einer langen Methode, die mit && und || bestreut war und gab einen Booleschen Wert zurück, um True zu behaupten. Die Aussage umfasst 20 Zeilen. Andererseits schrieb er eine Klasse, in der jede Methode eine Zeile und eine Hauptklasse über 1000 Zeilen ohne Leerzeichen enthielt. Es war eine Textwand. Als ich seinen Code überprüfte und einige neue Zeilen einfügte, fragte er, warum. Ich sagte 'Wegen der Lesbarkeit'. Er seufzte und löschte sie. Er fügte einen Kommentar hinzu: "Fass es nicht an, es funktioniert!"

Als ich das letzte Mal mit ihm gesprochen habe, hat er eine Website für eine Firma codiert. Er versuchte einen Bug zu finden. Er hatte die letzten 3 Tage damit verbracht, dies 8 Stunden am Tag zu tun. Ein bisschen später habe ich wieder mit ihm gesprochen und es stellte sich heraus, dass sein Teamkollege den Wert eines Buchstabens geändert und ihn an keiner anderen Stelle aktualisiert hat. Es war keine Konstante. Also änderte er auch die anderen Literale, so dass sein Fehler behoben wurde. Er beschwerte sich über den Spaghetti-Code seines Teamkollegen. Er sagte zu mir: "Haha, wissen wir nicht alle, wie es ist, die ganze Nacht mit dem Debugger wach zu bleiben und keinen Schlaf über einen bösen Bug zu bekommen?"

Außerdem findet er das Lesen von Programmierbüchern und Blogs nutzlos. Er sagt, "fang einfach an zu programmieren". Er hat das 12 Jahre lang gemacht und er denkt, er ist ein ausgezeichneter Programmierer. / facepalm

Hier ist noch mehr.

Ein anderes Mal haben wir eine DatabaseManager-Klasse für unsere Web-App geschrieben. Er hat alle Datenbankaufrufe darin abgelegt. Es war eine Gottesklasse mit über 50 Methoden für alle erdenklichen Dinge. Ich schlug vor, dass wir es in Unterklassen aufteilen, da nicht jeder Controller über jede Datenbankmethode Bescheid wissen muss. Er war anderer Meinung, weil es "einfach" war, nur eine Klasse für die gesamte Datenbank zu haben, und es "schnell" war, eine neue Methode hinzuzufügen, wann immer wir eine brauchten. Letztendlich verfügte DatabaseManager über mehr als 100 öffentliche Methoden, von der Authentifizierung des Benutzers bis zur Sortierung archäologischer Fundorte.

Meine Lektion, schnell und schmutzig auszuweichen, bestand darin, dass ich sechs Monate Zeit hatte, um die geschätzte (unterschätzte) Arbeitsleistung von einem Jahr zu erbringen. Ich entschied mich, Methoden zu erforschen, bevor ich mit der Arbeit anfing. Am Ende habe ich drei Monate Forschung investiert und konnte in den verbleibenden drei Monaten liefern.

Wir haben große Gewinne erzielt, indem wir gemeinsame Funktionen identifiziert und die erforderlichen Bibliotheken erstellt haben, um diese Anforderungen zu erfüllen. Ich sehe immer noch Codierer, die ihren eigenen Code schreiben, wenn Bibliotheksroutinen verfügbar sind. Diese Codierer schreiben häufig denselben Code um oder schneiden ihn bestenfalls aus und fügen ihn ein, wenn sie später dasselbe Problem lösen müssen. Fehlerkorrekturen erfassen immer nur einige der Codekopien.

Ein Entwickler gab eine aussagekräftige Antwort, als ich ihn aufforderte, Bibliothekscode zu verwenden: "Betrügt das nicht? Ich musste in der Schule meinen gesamten Code selbst schreiben."

In einigen Fällen könnte es eine große Anzahl von Regressionstests geben, die "alle" Fehler finden und das Verhalten überprüfen, wodurch eine schnelle und schmutzige Codierungstechnik ermöglicht wird. Aber meistens ist es nur eine Frage der schlechten Projektplanung und eines Managers, der es für wichtiger hält, es zu erledigen, als es richtig zu erledigen.

Und vergessen Sie "später aufräumen", das passiert nie. In den seltenen Fällen hat der Programmierer den größten Teil des Codes vergessen, was die Arbeit viel teurer macht, als wenn er es beim ersten Mal richtig gemacht hätte.

Das Produkt wird versandt.

Code existiert nicht im luftleeren Raum. Ich habe unbeschreibliche Trauer erlitten, als ich die Konsequenzen der schnellen und schmutzigen Codierung und der Cowboy-Codierung bekämpfte. Manchmal ist es jedoch die Priorität, das Produkt fertig zu stellen und nicht herauszufinden, wie der beste Code geschrieben wird. Letztendlich, wenn das Produkt gut ausgeliefert wird und funktioniert, werden die Benutzer und Kunden nicht wissen oder sich darum kümmern, wie "schlecht" der Code im Inneren ist, und ich gebe zu, dass es Zeiten gab, in denen es mir überhaupt nichts ausmachte, es zu bekommen rechts ", solange ich es aus der Tür bekam.

Ja, dies ist ein organisatorisches Problem und "sollte niemals passieren". Wenn Sie jedoch zufällig Code in einer Organisation schreiben, die schlecht verwaltet und stark fristgebunden ist, sind die Optionen für einzelne Programmierer begrenzt.

Ich glaube nicht, dass sie ehrlich sagen können, dass sie es richtig gemacht haben, wenn es nicht einfach zu warten ist. Wenn sie zugeben, dass sie "später aufräumen" müssen, dann gibt es wahrscheinlich etwas, das sie nicht genug durchdacht haben. Wenn Sie es gründlich testen, werden nur Probleme mit unsauberem Code aufgedeckt.

Ich persönlich möchte nicht die Fähigkeit entwickeln, schmutzigen Code zu schreiben und sicher zu sein, dass er korrekt ist. Ich würde lieber gleich beim ersten Mal richtigen Code schreiben.

Woher wissen sie, dass sie es richtig verstanden haben? Testen ist die einfache Antwort.

Wenn ihr Code von einem guten QA-Team gründlich getestet wurde und bestanden wurde, würde ich sagen, dass sie es richtig gemacht haben.

Das Schreiben von schnellem und unsauberem Code ist keine Gewohnheit, aber es gibt Situationen, in denen Sie 20 Minuten damit verbringen können, Code zu schreiben, der als unsauber eingestuft wird, oder 4 Stunden damit, eine Menge Code zu überarbeiten, um es richtig zu machen. In der Geschäftswelt stehen manchmal nur 20 Minuten zur Verfügung, und wenn die Fristen schnell und schmutzig sind, ist dies möglicherweise die einzige Option.

Ich war selbst an beiden Enden dabei, musste den fehlerhaften Code reparieren und meinen eigenen schreiben, um die Einschränkungen eines Systems zu umgehen, in dem ich mich entwickelt habe. Ich würde sagen, dass ich Vertrauen in den Code hatte, den ich hatte schrieb, weil ich, obwohl es schmutzig und ein bisschen hackig war, manchmal sicherstellte, dass es gründlich getestet wurde und eine Menge eingebauter Fehlerbehandlung hatte. Wenn also etwas schief ging, würde es den Rest des Systems nicht zerstören.

Wenn wir auf diese schnellen und schmutzigen Programmierer herabblicken, müssen wir uns eines merken: Ein Kunde zahlt im Allgemeinen nicht, bis er das Produkt hat, wenn es ausgeliefert wird und er in UAT-Tests geht und die Fehler aus schnellem und schmutzigem Code herausfindet, der ein Fehler ist viel weniger wahrscheinlich, dass sie sich zurückziehen, wenn sie ein fast funktionierendes Produkt vor sich haben, aber wenn sie nichts haben und Sie ihnen sagen: "Sie werden es bald haben, wir reparieren nur x" oder "es wurde verzögert, weil wir es bekommen mussten." Sie arbeiten einfach perfekt. "Sie geben eher auf und gehen mit einem Konkurrenten.

Natürlich sollte niemand, wie dieses Bild zeigt, die Gefahr von schnellem und schmutzigem Code unterschätzen!

Ich denke nicht, dass du überhaupt anfangen solltest, diesen Weg zu gehen. Schnell und schmutzig mag Ihnen der zeitliche Vorteil eines schnelleren Endes bringen, aber Sie zahlen am Ende immer das Zehnfache dafür.

Meiner Meinung nach lohnt es sich nicht, zu lernen, Q & D-Codes auf ihre Richtigkeit hin zu beurteilen, da dies nur eine schlechte Übung ist. Hier ist der Grund:

Ich denke nicht, dass "schnell und schmutzig" und "Best Practice" zusammenpassen. Viele Programmierer (ich selbst eingeschlossen) haben als Ergebnis einer Verschiebung der dreifachen Beschränkungen schnellen und schmutzigen Code herausgeholt . Wenn ich es tun musste, war es in der Regel ein Ergebnis von Scope Creep in Kombination mit einer immer näher rückenden Frist. Ich wusste, dass der Code, den ich eincheckte, nicht funktioniert, aber er spuckte bei einer Reihe von Eingaben die richtigen Ausgaben aus. Sehr wichtig für unsere Stakeholder, wir haben pünktlich versendet.

Ein Blick auf den ursprünglichen CHAOS-Bericht macht ziemlich deutlich, dass Q & D keine gute Idee ist und das Budget später zunichte macht (entweder bei der Wartung oder bei der Erweiterung). Zu lernen, wie man beurteilt, ob der Q & D-Code richtig ist, ist Zeitverschwendung. Wie Peter Drucker sagte: "Es gibt nichts Unnützeres, als effizient das zu tun, was überhaupt nicht getan werden sollte."

Ich kann nicht sagen, ob mein neuer Code korrekt ist, wenn er zu schmutzig ist.

"Schmutzig" bedeutet für verschiedene Menschen verschiedene Dinge. Für mich bedeutet dies vor allem, sich auf Dinge zu verlassen, von denen Sie wissen, dass Sie sich wahrscheinlich nicht verlassen sollten, von denen Sie aber auch wissen, dass Sie in naher Zukunft mit einer Arbeit rechnen können. Beispiele: Angenommen, eine Schaltfläche ist 20 Pixel hoch, anstatt die Höhe zu berechnen. Festcodieren einer IP-Adresse, anstatt einen Namen aufzulösen; Wenn Sie auf ein zu sortierendes Array zählen, wissen Sie, dass dies der Fall ist, auch wenn die Methode, die das Array bereitstellt, dies nicht garantiert.

Schmutziger Code ist zerbrechlich - Sie können ihn testen und wissen, dass er jetzt funktioniert , aber es ist eine gute Wette, dass er irgendwann kaputt geht (oder Sie zwingen jeden, auf Eierschalen zu gehen, aus Angst, ihn zu zerbrechen).

Auf die Gefahr hin, ein wenig kontrovers zu klingen, würde ich argumentieren, dass niemand wirklich weiß, dass sein Code zu 100% korrekt und zu 100% fehlerfrei ist. Selbst wenn Sie eine wirklich gute Testabdeckung haben und gute BDD / TDD-Praktiken konsequent anwenden, können Sie Code entwickeln, der Fehler enthält, und ja, der sogar Nebenwirkungen enthalten kann!

Nur Code zu schreiben und anzunehmen, dass er funktioniert, bedeutet, dass der Entwickler zu viel Vertrauen in seine eigenen Fähigkeiten hat. Wenn Probleme auftreten (die unvermeidlich sein werden), ist der Aufwand zum Debuggen und Verwalten des Codes sehr hoch, insbesondere wenn ein anderer Entwickler dies benötigt um den Code später zu pflegen. Der eigentliche Unterschied ergibt sich aus der Anwendung bewährter Methoden der Softwareentwicklung, die sicherstellen, dass Sie sich darauf verlassen können, dass Ihr Code die meiste Zeit wahrscheinlich funktioniert, und dass das Debuggen einfacher ist, wenn Sie auf einen Fehler stoßen und viel weniger kostspielig zu ändern und zu warten, unabhängig von der Person, die später an diesem Code arbeitet.

Der springende Punkt ist, dass gut faktorisierter und erprobter Code es ANDEREN ermöglicht , Vertrauen in Ihren Code zu haben, was in den meisten Fällen wichtiger ist als Ihr eigenes Vertrauen.

Wenn schmutziger Code gut getestet ist, kann man ihm vertrauen. Das Problem ist, dass Unit-Tests von Dirty-Code normalerweise sehr schwierig und umständlich sind. Deshalb ist TDD so gut. Es enthüllt und entfernt Schmutz und Gerüche. Auch Unit-Tests sind oft das erste, was unter Zeitdruck leidet. Also, wenn der sauberste Kerl jemals den saubersten Code gemacht hätte, den er jemals gemacht hatte, würde ich ihm immer noch kein bisschen vertrauen, wenn er die Unit-Tests aus Zeitgründen weglassen würde.

Gute Programmierer (Quick & Dirty und andere) haben nicht die Hybris anzunehmen, dass sie es richtig gemacht haben. Sie gehen davon aus, dass alle großen Systeme Fehler und Mängel aufweisen, dass sie jedoch zu einem bestimmten Zeitpunkt ausreichend getestet und überprüft werden müssen, um ein ausreichend geringes Risiko oder ausreichend niedrige Ausfallkosten für die Auslieferung des Codes zu gewährleisten.

Warum gibt es diese sogenannten Quick & Dirty-Programmierer? Meine Hypothese ist die darwinistische Selektion. Programmierer, die funktionierenden Code schnell versenden, versenden gelegentlich, bevor der Wettbewerb ausläuft, oder das Budget knapp wird oder die Firma bankrott geht. Daher sind ihre Unternehmen immer noch im Geschäft und beschäftigen neue Programmierer, um sich über die Unordnung zu beschweren, die beseitigt werden muss. Sogenannte Clean-Code-Schiffe ebenfalls, aber nicht differenziell genug, um Quick & Dirty-Codierer vom Aussterben zu bedrohen.

Man könnte wahrscheinlich denken, dass ein nicht optimaler Teil eines Codes aufgrund der kurzen Lebensdauer, der geringen Auswirkung auf das Geschäft oder der geringen Zeit, die zur Erledigung benötigt wird, keinen Unterschied machen könnte. Die richtige Antwort ist, dass Sie es nicht wirklich wissen. Jedes Mal, wenn ich jemandem zuhöre, der sagt, "das ist ein kleines Feature", oder "machen wir es so schnell und einfach wie möglich", und nicht genügend Zeit zum Nachdenken über das richtige Design aufbringe, die einzigen beiden Dinge, die tatsächlich und immer wieder auftreten sind:

1-) Das Projekt wird größer und die Motivation des Teams geringer. Es arbeitet an einem Code voller "Stiche". In diesem Fall wird das Projekt wahrscheinlich zu einer Überholspur in Richtung Chaos führen.

2-) Es wird bekannt, dass das Projekt eine nicht optimale Lösung ist, und es wird davon abgeraten, eine neue Lösung oder ein Refactoring zu wählen, das so teuer ist wie eine neue Lösung.

Versuchen Sie immer, den bestmöglichen Code zu erstellen. Wenn Sie nicht genug Zeit haben, erklären Sie, warum Sie mehr brauchen. Setzen Sie sich nicht mit schlecht gemachter Arbeit einem Risiko aus. Sei immer ein besserer Profi. Niemand kann Sie dafür bestrafen, wenn Sie vernünftig sind. Wenn ja, ist es nicht der Ort, an dem Sie arbeiten sollten.

Besprechen Sie dies mit dem Senior und bewerten Sie die Auswirkungen von Fehlern, falls vorhanden. Zum Beispiel dauert eine Situation, in der Sie das Problem beheben können, 1 Tag und ein robuster Code erfordert Design- und Architekturänderungen, die 4 bis 6 Monate dauern können, und eine zusätzliche Validierungszeit, um alle Workflows, die von der Designänderung betroffen waren, vollständig zu validieren.

Wir müssen eine Entscheidung treffen, die auf Zeit + Kapazität + Prioritäten in der Liste basiert. Eine gute Diskussion im Team mit Senioren oder Personen mit höherer Erfahrung kann dazu beitragen, eine Entscheidung zu treffen, die am besten zum Team und den erzielbaren Ergebnissen passt.

Clean Code ist der erste und wichtigste Ansatz, bei dem als Dirty Code Eskalationen, Go / No-Go-Entscheidungen der Kunden, Aufzeigen von Stoppern, Ansehen des Unternehmens auf dem Spiel stehen und vieles mehr, wo Dirty Code in Clean Code übergeht.