Ich bin Programmierer mit 1 Jahr Erfahrung, vor kurzem habe ich festgestellt, dass ich ein Projekt selten richtig beginne (der Großteil meines Nebenprojekts), normalerweise verläuft der Projektzyklus wie folgt

1. Beginnen Sie mit einigen Anwendungsfällen
2. Starten Sie die Codierung
3. Erkenne ein paar Dinge, die ich nicht gut behandelt habe und die nicht gut in die aktuelle Codebasis passen.
4. Schreiben Sie den größten Teil des Codes neu

und das könnte ein paar mal gehen

Also meine Fragen sind

1. Ist eine solche Praxis üblich oder impliziert sie, dass ich nicht kompetent bin?
2. Wie kann ich mich in diesem Aspekt verbessern?

Der von Ihnen beschriebene Zyklus ist normal. Der Weg, die Dinge zu verbessern, besteht nicht darin, diesen Kreislauf zu umgehen, sondern ihn zu straffen. Der erste Schritt ist zu akzeptieren, dass:

1. Es ist fast unmöglich, am ersten Tag eines Projekts alles zu wissen .
2. Selbst wenn Sie irgendwie alles wissen, wird sich bis zum Abschluss des Projekts etwas (die Anforderungen des Kunden, der Markt, mit dem Sie arbeiten, die Wünsche ihrer Kunden) geändert und geändert haben Zumindest ein Teil dessen, was Sie als ungültig oder falsch kannten.

Daher ist es unmöglich, alles im Voraus zu planen, und selbst wenn Sie dies könnten, würde die Befolgung dieses Plans dazu führen, dass Sie etwas Unvollkommenes oder Veraltetes bauen. In diesem Wissen integrieren wir Veränderungen in unsere Planung. Schauen wir uns Ihre Schritte an:

1. Beginnen Sie mit einigen Anwendungsfällen
2. Starten Sie die Codierung
3. Erkenne ein paar Dinge, die ich nicht gut behandelt habe und die nicht gut in die aktuelle Codebasis passen.
4. Schreiben Sie den größten Teil des Codes neu

Das ist eigentlich ein guter Ausgangspunkt. So würde ich es angehen:

1. Beginnen Sie mit einigen Anwendungsfällen

Gut. Indem man sagt , „Use Cases“, konzentriert sind Sie auf , was die Software ist für . Wenn Sie "ein paar" sagen, versuchen Sie nicht, alles zu entdecken. Sie halten an einer überschaubaren Menge Arbeit fest. Alles, was ich hier hinzufügen möchte, ist, sie zu priorisieren. Erarbeiten Sie mit Ihrem Kunden oder Endbenutzer die Antwort auf diese Frage:

Was ist die kleinste und einfachste Software, die ich Ihnen geben kann, um Ihre Situation zu verbessern?

Dies ist Ihr Produkt mit minimaler Lebensfähigkeit - alles, was kleiner ist, ist für Ihren Benutzer nicht hilfreich, aber alles, was größer ist, läuft Gefahr, zu früh zu planen. Holen Sie sich genügend Informationen, um dies zu erstellen, und fahren Sie dann fort. Denken Sie daran, dass Sie zu diesem Zeitpunkt noch nicht alles wissen werden.

2. Starten Sie die Codierung.

Toll. Sie arbeiten so schnell wie möglich. Bis Sie Code geschrieben haben, haben Ihre Kunden keinen Vorteil erhalten. Je mehr Zeit Sie mit der Planung verbringen, desto länger hat der Kunde ohne Amortisation gewartet.

Hier möchte ich Sie daran erinnern, guten Code zu schreiben . Beachten und befolgen Sie die SOLID-Prinzipien , schreiben Sie angemessene Komponententests für alles, was zerbrechlich oder komplex ist, machen Sie sich Notizen zu allem, was Sie wahrscheinlich vergessen oder das später Probleme verursachen könnte. Sie möchten Ihren Code so strukturieren, dass Änderungen keine Probleme verursachen. Zu diesem Zweck strukturieren Sie Ihren Code jedes Mal, wenn Sie sich entscheiden, etwas auf diese Weise anstatt auf diese Weise zu erstellen, so, dass von dieser Entscheidung so wenig Code wie möglich betroffen ist. Im Allgemeinen besteht eine gute Möglichkeit darin, den Code zu trennen:

• Verwenden Sie einfache, diskrete Komponenten (abhängig von Ihrer Sprache und Situation kann es sich bei dieser Komponente um eine Funktion, eine Klasse, eine Assembly, ein Modul, einen Dienst usw. handeln. Sie haben möglicherweise auch eine große Komponente, die aus kleineren Komponenten aufgebaut ist, z eine Klasse mit vielen Funktionen oder eine Assembly mit vielen Klassen.)
• Jede Komponente erledigt einen Job oder Jobs in Bezug auf eine Sache
• Änderungen an der internen Funktionsweise einer Komponente sollten nicht dazu führen, dass sich andere Komponenten ändern müssen
• Komponenten werden sollten gegeben Dinge , die sie verwenden oder davon abhängen , anstatt das Abrufen oder Erstellen von ihnen
• komponenten sollten anderen komponenten informationen geben und sie zur arbeit auffordern, anstatt informationen abzurufen und die arbeit selbst zu erledigen
• Komponenten sollten nicht auf das Innenleben anderer Komponenten zugreifen, diese verwenden oder von diesem abhängig sein. Verwenden Sie nur deren öffentlich zugängliche Funktionen

Auf diese Weise isolieren Sie die Auswirkungen einer Änderung, sodass Sie in den meisten Fällen ein Problem an einer Stelle beheben können und der Rest Ihres Codes nichts davon merkt.

3. Auf Probleme oder Mängel im Design stoßen.

Das wird passieren. Das ist unvermeidlich. Akzeptiere das. Wenn Sie auf eines dieser Probleme stoßen, entscheiden Sie, um welche Art von Problem es sich handelt.

Einige Probleme sind Probleme in Ihrem Code oder Design, die es schwierig machen, das zu tun, was die Software tun sollte. Bei diesen Problemen müssen Sie zurückgehen und Ihr Design ändern, um das Problem zu beheben.

Einige Probleme sind darauf zurückzuführen, dass nicht genügend Informationen vorhanden sind oder dass Sie an etwas gedacht haben, an das Sie vorher nicht gedacht haben. Bei diesen Problemen müssen Sie zu Ihrem Benutzer oder Client zurückkehren und ihn fragen, wie er das Problem beheben möchte. Wenn Sie die Antwort haben, aktualisieren Sie Ihr Design, um damit umzugehen.

In beiden Fällen sollten Sie darauf achten, welche Teile Ihres Codes geändert werden mussten, und während Sie mehr Code schreiben, sollten Sie darüber nachdenken, welche Teile in Zukunft möglicherweise geändert werden müssen. Auf diese Weise können Sie leichter herausfinden, welche Teile möglicherweise zu stark miteinander verknüpft sind und welche möglicherweise stärker isoliert werden müssen.

4. Schreiben Sie einen Teil des Codes neu

Sobald Sie festgestellt haben, wie Sie den Code ändern müssen, können Sie die Änderung vornehmen. Wenn Sie Ihren Code gut strukturiert haben, müssen Sie normalerweise nur eine Komponente ändern. In einigen Fällen müssen jedoch auch einige Komponenten hinzugefügt werden. Wenn Sie feststellen, dass Sie eine Menge Dinge an vielen Orten ändern müssen, denken Sie darüber nach, warum das so ist. Könnten Sie eine Komponente hinzufügen, die den gesamten Code in sich behält, und dann alle diese Stellen nur diese Komponente verwenden? Wenn Sie dies können und wenn Sie diese Funktion das nächste Mal ändern müssen, können Sie dies an einem Ort tun.

5. Test

Eine häufige Ursache für Softwareprobleme ist, dass Sie die Anforderungen nicht gut genug kennen. Dies ist oft nicht die Schuld der Entwickler - oft ist sich der Benutzer auch nicht sicher, was er benötigt. Der einfachste Weg, dies zu lösen, besteht darin, die Frage umzukehren. Anstatt zu fragen, "Was muss die Software tun?", Geben Sie dem Benutzer jedes Mal, wenn Sie diese Schritte ausführen, das, was Sie bisher erstellt haben, und fragen Sie ihn: "Ich habe das erstellt - tut es das, was Sie benötigen?". Wenn sie ja sagen, haben Sie etwas gebaut, das ihr Problem löst, und Sie können aufhören zu arbeiten! Wenn sie Nein sagen, können sie Ihnen genauer sagen, was mit Ihrer Software nicht stimmt, und Sie können dieses spezielle Problem beheben und weitere Rückmeldungen einholen.

6. Lernen

Achten Sie während dieses Zyklus auf die Probleme, die Sie finden, und auf die Änderungen, die Sie vornehmen. Gibt es Muster? Können Sie sich verbessern?

Einige Beispiele:

• Wenn Sie immer wieder feststellen, dass Sie den Standpunkt eines bestimmten Benutzers übersehen haben, können Sie dann diesen Benutzer stärker in die Entwurfsphase einbeziehen?
• Wenn Sie immer wieder Änderungen vornehmen müssen, um mit einer Technologie kompatibel zu sein, können Sie dann eine Schnittstelle zwischen Ihrem Code und dieser Technologie erstellen, sodass Sie nur die Schnittstelle ändern müssen?
• Wenn der Benutzer seine Meinung zu Wörtern, Farben, Bildern oder anderen Dingen in der Benutzeroberfläche ändert, können Sie dann eine Komponente erstellen, die dem Rest der Anwendung diese Elemente zur Verfügung stellt, damit sie alle an einem Ort sind?
• Wenn Sie feststellen, dass sich viele Ihrer Änderungen in derselben Komponente befinden, sind Sie sicher, dass sich diese Komponente nur an einen Job hält? Könnten Sie es in ein paar kleinere Stücke teilen? Können Sie diese Komponente ändern, ohne andere berühren zu müssen?

Seien Sie agil

Was Sie hier anstreben, ist ein Arbeitsstil, der als Agile bekannt ist. Agile ist keine Methodik, sondern eine Methodenfamilie, die eine ganze Reihe von Dingen umfasst (Scrum, XP, Kanban, um nur einige zu nennen). Allen ist jedoch gemeinsam, dass sich die Dinge ändern und wir als Softwareentwickler sollten planen, sich an Änderungen anzupassen, anstatt sie zu vermeiden oder zu ignorieren. Einige seiner Kernprinzipien - insbesondere diejenigen, die für Ihre Situation relevant sind - sind die folgenden:

• Planen Sie nicht weiter voraus, als Sie mit Zuversicht vorhersagen können
• Berücksichtigen Sie, dass sich die Dinge auf Ihrem Weg ändern
• Anstatt etwas Großes auf einmal zu bauen, bauen Sie etwas Kleines und verbessern Sie es dann schrittweise
• Binden Sie den Endbenutzer in den Prozess ein und erhalten Sie umgehend regelmäßiges Feedback
• Untersuchen Sie Ihre eigene Arbeit und Ihren Fortschritt und lernen Sie aus Ihren Fehlern

Das ist normal.

Sie können einen von zwei Ansätzen wählen:

1. Willkommene Änderung

Wenn Sie davon ausgehen, dass Sie etwas falsch machen, müssen Sie eine Codebasis erstellen, die für Änderungen offen ist. Meist geht es darum, den Code am Ende eines Buches zum Refactoring zu verwenden und den Code von Anfang an so zu erstellen (Zerlegbarkeit, gute Testabdeckung, ...).

2. Vermeiden Sie Änderungen

In diesem Fall müssen Sie eine BDUF (großes Design vorne) durchführen. Sie müssen viele Papier-Prototypen erstellen, mit potenziellen Benutzern oder sich selbst über Ideen diskutieren, verschiedene Dinge in Prototypen oder Mockups ausprobieren, eine vollständige Spezifikation aufschreiben und erst dann, wenn Sie das Gefühl haben, die Lösung gefunden zu haben, sind Sie es auch kann mit dem Programmieren beginnen. Wenn alles getan wird, was unerwartete Veränderungen nicht wirklich beseitigt, wird es nur ein wenig reduziert, das erste Jahr oder so. Sie müssen also immer noch Ihren Code erstellen, damit er leicht geändert werden kann.

Veränderung ist also eine Selbstverständlichkeit. Angenommen, es wird passieren. Erstellen Sie Ihren Code entsprechend. In der Praxis finden Sie einen Mittelweg zwischen den Ansätzen des Design-Up-Front und des Just-Start-Codings, der unbeabsichtigte Änderungen vermeidet, ohne sich in einer Analyse-Lähmung festzusetzen. Es braucht nur ein bisschen Erfahrung.

Die Softwareentwicklung wurde als eine Reihe von von Natur aus "bösen" Problemen beschrieben .

Horst Rittel und Melvin Webber haben ein "böses" Problem als eines definiert, das nur durch Lösen oder durch Lösen eines Teils davon * klar definiert werden kann. Dieses Paradox impliziert im Wesentlichen, dass Sie das Problem einmal "lösen" müssen, um es klar zu definieren und dann erneut zu lösen, um eine funktionierende Lösung zu erstellen. Dieser Prozess ist seit Jahrzehnten Mutterschaft und Apfelkuchen in der Softwareentwicklung

Dies beschreibt perfekt das Problem, mit dem Sie konfrontiert sind. Grundsätzlich ist das , was wir tun, schwierig . Wenn es einen Teil gibt, der als "Routine" beschrieben werden könnte, isolieren und automatisieren wir ihn im Laufe der Zeit. Alles, was übrig bleibt, ist entweder das Neue oder das Schwierige.

Es gibt andere Möglichkeiten, solche Probleme zu lösen. Einige Leute verbringen viel Zeit damit, die Probleme im Voraus zu prüfen und keinen Code zu schreiben, bis sie mit dem Design vertraut sind. Andere wenden sich an Personen, die sich bereits mit solchen Problemen befasst haben, entweder über Pair Programming oder einfach über solche Websites.

Aber sicherlich deutet Ihr Ansatz nicht auf Inkompetenz hin. Das einzige Problem könnte sein, dass Sie beim Zurückgehen nicht darüber nachdenken, warum Sie sich dazu entschlossen haben, Dinge auf diese Weise zu tun, und ob Sie in der Lage waren, den "besseren" Weg ohne den zu sehen umschreiben.

In vielen Fällen war dies der Fall, und Sie können es für das nächste Mal in Ihren Entwurfsprozess einbeziehen. In einigen Fällen gab es keine (oder die Kosten wären so hoch oder höher gewesen als die Kosten Ihres anderen Ansatzes), und Sie können einfach Ihre Sorge loslassen.

1. Ja, dies ist üblich, mit Ausnahme des Teils "Den größten Teil des Codes neu schreiben ". Sie werden nie von Anfang an alle Anforderungen erfüllen, daher ist es wichtig, gut mit Veränderungen umzugehen. Darum geht es beim Konzept der "Code-Wartbarkeit". Natürlich hilft es auch, etwas mehr Zeit darauf zu verwenden, die Anforderungen und das Design richtig zu machen.
2. Überlegen Sie sich zunächst, welche Änderungen in früheren Projekten erforderlich waren und wie Sie diese hätte vorhersehen oder besser darauf vorbereiten können. Denken Sie zu Beginn eines Projekts mehr über die Details der Anwendungsfälle nach. Machen Sie ein abstraktes Design (was sind die Hauptkomponenten des Codes und wie kommunizieren sie, was sind ihre APIs), bevor Sie mit der Implementierung beginnen. Versuchen Sie vor allem, den Code so einfach und leicht wie möglich zu ändern, und informieren Sie sich über Konzepte wie SOLID, DRY, KISS und YAGNI.

Ist eine solche Praxis üblich oder impliziert sie, dass ich nicht kompetent bin?

Diese schließen sich nicht aus. Das Muster könnte häufig vorkommen, und Sie sind möglicherweise immer noch inkompetent. Ihre Kompetenz kann bestimmt werden, indem Sie Ihre Leistung an Ihren Zielen messen. Erreichen Sie Ihre Ziele?

Ist dieses Muster üblich? Leider ja. Viele Menschen tauchen in Projekte ein, ohne eine klare Vorstellung davon zu haben, welches Problem sie lösen, wie sie eine korrekte Lösung finden und welche Messgrößen den Erfolg ausmachen.

Wie kann ich mich in diesem Aspekt verbessern?

Wenn Sie sich dazu entschlossen haben, irgendwohin zu gehen, und dann einen Tag entdeckt haben, an dem Sie wirklich einen Elefanten von Kapstadt nach New York City transportieren mussten, war die ganze Zeit, die Sie damit verbracht haben, spazieren zu gehen, verschwendet. Finde heraus, was du tust, bevor du damit beginnst.

Überlegen Sie sich zu Beginn: Wie sieht Code aus, der nie neu geschrieben werden muss ? Dieser Code:

• Tut eine nützliche Sache.
• Macht es richtig.
• Funktioniert es mit ausreichender Leistung.

Also: Je mehr Code Sie schreiben, wo dieser Code eine nützliche Sache richtig macht, bei guter Leistung, desto weniger Code müssen Sie jemals umschreiben.

Ich denke, es ist sicher zu sagen, dass Sie nicht so weit von einer besseren Arbeitsweise entfernt sind und dass Sie nicht der einzige in diesem Boot sind.

Was ich denke, dass Sie vermissen, ist, dass, obwohl Sie bestimmen, was Sie wollen, Sie nicht aufhören, den gleichen Prozess zu tun, wie Sie es tun werden.

Dieser Schritt des Anhaltens und Überlegens, wie das Problem insgesamt gelöst werden soll, wird als Design bezeichnet. In diesem Schritt müssen Sie einige Zeit für die Entwicklung der Struktur oder Architektur des Systems aufwenden, damit alles, was Sie von da an tun, zur endgültigen Lösung beiträgt Teile in ein Puzzle einpassen, sobald Sie die Kanten ausgearbeitet haben.

Viele Leute machen diesen Schritt nicht, aber als ich mit dem Codieren anfing, war es obligatorisch. Ich denke, der Unterschied liegt in den Entwicklungswerkzeugen - während ich mit einem Texteditor angefangen habe, gibt es jetzt alle Arten von Funktionen, mit denen Sie springen und wegschreiben können.

Nehmen Sie sich also etwas Zeit, um herauszufinden, welche Bereiche, Komponenten und Interoperabilitäten zwischen ihnen bestehen, und definieren Sie die Objekte, aus denen Ihre Lösung besteht, bevor Sie mit dem Code beginnen. Es muss nicht immens detailliert sein und es muss klar sein, dass Sie es am Anfang nicht perfekt hinbekommen, damit es sich im Laufe der Zeit weiterentwickelt. Es muss nicht viel geändert werden.

Sie haben bereits einige gute Antworten, aber Ihre Frage erinnert an einige Dinge, von denen ich dachte, ich würde versuchen, sie zu berühren.

1. Wie Sie bemerkt haben, sollten Sie sich überlegen, wie sich die Auswirkungen auf Ihr Projekt auswirken und wie Sie die Auswirkungen bei der Auswahl von Design / Codierung minimieren können, während Sie gleichzeitig eine mentale Übersicht darüber erstellen, wo Menschen häufig späte Änderungen vornehmen. Mit der Erfahrung können Sie Flexibilität für Dinge vorhersehen und programmieren, von denen Sie wissen, dass sie wichtig sind - obwohl es in der Branche Uneinigkeit über dieses Konzept gibt, da einige entgegenwirken, dass Sie in einen Bereich investieren, der per se nicht speziell angefordert wird .

2. An der Testfront kann es eine gute Möglichkeit sein, einen Prototyp für Ihre Projektbeteiligten zu erstellen, um die Anforderungen zu verfeinern. Während der Entwicklung können Sie jedoch nach Möglichkeiten suchen, um zu "sehen", was in Ihrem Code vor sich geht, ohne viel Unordnung oder Komplexität zu verursachen. Es gibt sicherlich Tools, die Ihnen helfen können, aber Sie können auch viel ohne sie tun, wenn Sie möchten. In beiden Fällen kann das Verlassen des Codes, um zu sehen, was mit einem kritischen Auge geschieht, verschiedene Arten von Einsichten liefern.

3. Suchen Sie nach gemeinsamen Aktivitäten. Sie werden feststellen, dass Sie sich immer wieder mit denselben Problemen befassen. Nach einer Weile sollten Sie die Defizite oder Kompromisse der verschiedenen Auswahlmöglichkeiten erkennen und eine Methode finden, mit der Sie diese vermeiden können. Wenn Sie in einem Framework arbeiten, sind einige dieser Probleme möglicherweise in den Tools enthalten, die Sie bereits verwenden.

4. Wenn Sie innerhalb eines Frameworks arbeiten, nehmen Sie sich Zeit, wenn Sie Zeit dafür haben, und überlegen Sie, wie Sie die Dinge von Grund auf neu machen. Beispielsweise können Sie auf einfache Weise eine Anforderungsnachricht zusammenstellen, einen Socket öffnen und eine GET- oder POST-Anforderung manuell ausgeben. Wenn Sie möchten, können Sie XML-Nachrichten manuell analysieren. Was auch immer Sie tun, die Fragen, die Sie generieren, und die Antworten, die Sie finden, werden Ihre Fähigkeiten erweitern. Natürlich können Sie auswählen, welche Arten von zugrunde liegenden Themen wichtig oder von Interesse sind. Ich würde diese persönliche Entwicklung in Betracht ziehen und nicht damit rechnen, hier viel Zeit auf der Uhr zu verbringen.

5. Silberkugeln, Methoden und Probleme mit hohem Summenfaktor gibt es überall. Grundsätzlich ändern sich die grundlegenden Realitäten der Arbeit mit Informationen nicht so schnell. Beachten Sie, ob das vorhandene Framework, Toolset oder die vorhandene Methodik in verschiedenen Situationen hilfreich oder hinderlich ist. In großen Unternehmen wurden viele Methoden ausprobiert, obwohl das Unternehmen diese nicht effektiv ausführen konnte. Genau wie Frameworks sind Methoden kein ausfallsicherer Weg, um auf hohem Niveau zu funktionieren, selbst wenn sie auf den Praktiken einiger hochfunktioneller Teams basieren.

Es ist schwierig, Erfahrungen zusammenzufassen und zugänglich zu machen. Ich denke, ein kurzer Weg, dies alles zu formulieren, besteht darin, die Augen offen zu halten, über das nachzudenken, was Sie sehen, und niemals aufzuhören zu lernen.

Ich möchte ein paar Hinweise hinzufügen

1) Ich persönlich fand es unglaublich nützlich, Dinge zu visualisieren . Zeichnen Sie Kästchen, Pfeile, Linien ... Egal welche Modellierungssprache Sie verwenden. Zunächst tun Sie es FÜR SICH. Es sollte Ihrem Gedankenfluss helfen.

2) Finde einen Sparringspartner - nimm einen Kaffee und das Flipchart / Diagramm usw. von oben und fahre in die Stadt. IMHO ist es sogar besser, wenn Sie nicht zusammenpassende Technologiefähigkeiten haben. Sie treiben die Ideen für die Implementierung des Usecase auf und ab. Sie finden eine Sackgasse oder zwei - Sie finden eine Lösung. Mit einem agilen Verstand wird in dieser Phase oft weniger Zeit aufgewendet, als wenn Sie Code schreiben, der nicht funktioniert und Sie müssen Teile Ihrer Arbeit töten oder wiederholen

3) Finden Sie einen Chef, der verstehen kann, dass Sie Ihre geschriebene Software wahrscheinlich nie verbessert haben. Wenn Sie immer neue Funktionen / Anforderungen einbinden, die auf Ihrem Schreibtisch landen, und sich nie um Ihre Software kümmern , wird sie Sie mit Fehlern, unfreundlicher Wartung und vielen Haaren ein paar Jahre später zurückschlagen. Holen Sie sich diese Software Wartungszeit / Budget zugeteilt! Eine gute runde magische Zahl ist ungefähr 20% der Zeit, die für die Entwicklung der Software pro Jahr benötigt wird, um sie im Laufe ihres Lebens in Form zu halten.

4) Dieser Prozess des inkrementellen Lernens hört nie auf (und sollte es nicht)! Sie werden in 10 Jahren zurückblicken und lächeln.

Hoffe das hilft ein bisschen und viel Glück!