Ich verbringe viel Zeit mit der Arbeit an Projekten, bei denen ich der einzige Entwickler, Projektmanager, Designer, QT-Mitarbeiter (ja, ich weiß ... schlecht!) Und manchmal sogar der Kunde bin.

Ich habe so gut wie alles versucht, um Projekte zu planen und mich selbst zu verwalten, angefangen beim Sitzen und Arbeiten im Freestyle bis hin zu einer Einzelperson-Version von Scrum, bei der ich ein Fortschrittsgespräch mit mir selbst geführt habe -Man Burn Down Chart jeden Morgen (kein Scherz).

Was ist für diejenigen unter Ihnen, die viel Zeit damit verbringen, alleine zu arbeiten, die beste Möglichkeit, sich zu organisieren, große Projekte (für eine Person) zu verwalten und die Produktivität so hoch wie möglich zu halten?

Eine klare Liste Ihrer Ziele zu führen, ist von entscheidender Bedeutung. Es ist einfach für Feature Creep, ein selbst verwaltetes Projekt zu übernehmen. Der TDD-Ansatz "Fertig, wenn es funktioniert" ist ebenfalls hilfreich. Das hindert Sie daran, ein Perfektionist zu werden.

Eine Sache, die mir wirklich hilft, ist sich vorzustellen, was ein anderer Ingenieur oder ein Projektmanager in einer bestimmten Situation sagen würde. Oft kann ich mich aus schlechtem Code "herausschämen" oder wieder auf die Strecke kommen, wenn der Zeitplan ausrutscht.

Hier gehts ... http://xp.c2.com/ExtremeProgrammingForOne.html

XP lässt sich gut verkleinern, da es für kleine, fokussierte Teams optimal ist.

• Sie können eine Tabelle mit Funktionsanforderungen erstellen, diese priorisieren und die oberste auswählen.
• Definieren Sie die Akzeptanzkriterien (wie es aussieht) und verschlüsseln Sie sie in einen ausführbaren Test
• Definieren Sie als Nächstes die zu erledigenden Engineering-Aufgaben
• Schreibe Unit-Tests, mache das Einfachste (YAGNI) und überarbeite die ganze Zeit. Ziel ist es, den äußeren Abnahmetest zu bestehen
• Timebox jeder Sitzung. Für ein effektives Zeitmanagement können Sie sich auch die Pomodoro-Technik ansehen .
• Verwenden Sie die Versionskontrolle und richten Sie einen CI-Server / eine Batch-Datei ein, um eine Installation oder eine ZIP-Datei Ihrer Software zu erstellen
• Demo häufig. Leiten Sie das Feedback in die ursprüngliche Tabelle und priorisieren Sie es neu

Das Einzige, was Sie in einem Team nicht können, ist PairProgramming.

Wenn Sie alleine arbeiten. Hier sind die Ratschläge:

1. Mache so wenig Arbeit wie möglich. Verwenden Sie so viele Bibliotheken und Tools wie möglich, einschließlich Dingen, von denen Sie glauben, dass sie sich leicht codieren lassen (tun Sie es nicht, sondern verwenden Sie einfach die Bibliothek).
2. Gehen Sie von oben nach unten vor. Codieren Sie nur Dinge, die Sie wirklich brauchen.
3. Wenn Sie ein Problem in einem abstrakten Begriff sehen, durchsuchen Sie Google und verwenden Sie bereits nachgewiesene Forschungsarbeiten aus der akademischen Gemeinschaft. Sie müssen nur ihren Algorithmus codieren.
4. Entwerfen Sie Ihr System so, dass Sie die Dinge so weit wie möglich frei ändern können. (einschließlich Kopieren und Einfügen von Code von hier nach dort). Der Zweck ist, Ihnen Zeit zu sparen, wenn Sie feststellen, dass Sie einen Fehler gemacht haben. Versuchen Sie, den Arbeitsaufwand so gering wie möglich zu halten, wenn Sie einen Fehler machen. Ein Teil des Codes, der weggeworfen werden muss (anstatt von hier und da zu kopieren und einzufügen), entspricht der Zeit, die Sie beim Schreiben des Codes verloren haben.
5. Haben Sie viele automatisierte Tests, so dass Sie bei jeder Änderung regelmäßig Regressionstests durchführen können
6. Trennen Sie die Verantwortlichkeiten Ihres Designs (dh reduzieren Sie die Kopplung). Machen Sie die Dinge so modular wie möglich
7. Verwenden Sie einen Debugger, um Fehler zu debuggen, und verwenden Sie die binäre Suche, um Fehler zu finden.
8. Überarbeiten Sie Ihren Code ständig, um die (explizite) Kopplung und die Offenlegung öffentlicher Methoden (implizite Kopplung) zu verringern.
9. Nichts wirklich. Dies ist hier nur für den Fall, dass ich mir etwas Neues einfallen lassen kann: P

Code-Überprüfungen.

Diese sind besonders nützlich, da Sie den Code jemandem erklären werden, der nicht an demselben Projekt gearbeitet hat, sodass er keine Ihrer Annahmen darüber hat, wie es funktionieren soll.

Sie haben auch den zusätzlichen Vorteil, dass sie ihr Wissen im gesamten Unternehmen teilen können, sodass sie nicht bei Null anfangen müssen, wenn jemand anderes an dem Projekt arbeiten muss (weil die Leute anderweitig beschäftigt sind, krank sind, zurückgetreten sind oder gefeuert wurden) .

Ich habe meine eigene Version von Agile entwickelt, die sich auf Storys, intensive Kundeninteraktion, häufige Veröffentlichungen und testgetriebene Entwicklung stützt. Ich benutze ein Wiki, um Geschichten zu verfolgen, den Kunden so weit wie möglich in das Schreiben einzubeziehen und den Kunden mit mir zusammenarbeiten zu lassen, um Prioritäten zu setzen und Veröffentlichungen zu organisieren. Ich benutze TDD, um das Design und die Implementierung voranzutreiben. Ich habe einen QS-Server eingerichtet, auf dem der Kunde häufige Releases ausprobieren kann (manchmal täglich, wenn neue Funktionen entwickelt werden), damit ich schnell Feedback bekomme. Ich gehe selten mehr als 3 Iterationen ohne eine Freigabe an QA. Der Kunde kann entscheiden, wann die QA-Version über genügend Funktionen verfügt, um live geschaltet zu werden - und ob keine weiteren Funktionen von der Liste mehr entwickelt werden müssen.

In meiner Firma arbeitet unsere Gruppe alle am selben Projekt, aber an relativ unabhängigen Teilen davon. Eine Sache, die wir hier häufig tun, ist, wenn etwas, das Sie tun, ein wenig knifflig erscheint, oder wenn Sie an einer Weggabelung mit mehr als einer Möglichkeit sind, etwas umzusetzen, Sie sich jemand anderen schnappen und die Vor- und Nachteile vorher besprechen Sie fahren fort. Wenn Sie warten, bis Sie den Code für fertig halten, um eine Überprüfung durchzuführen, haben Sie in der Regel bereits zu viel Zeit investiert, um größere architektonische Änderungen in Betracht zu ziehen, obwohl bei den Codeüberprüfungen mit Sicherheit viele Mängel aufgedeckt werden.

Außerdem ist mir klar, dass Test Driven Development in letzter Zeit ein kleines Modewort ist, aber es kann eine große Hilfe für Solo-Entwickler sein, da es eine Qualitätsprüfung bietet, während Sie fortfahren Code. Es hilft auch späteren Betreuern, den Code nicht versehentlich auf schwer erkennbare Weise zu knacken.

Ich schlage Ihnen Folgendes vor:

1. Testgetriebene Entwicklung
2. Einfache Verwendung von "TODO: notiere hier" in deinem Code, wenn du etwas siehst, das du nicht sofort tun kannst, und komm zu ihnen zurück, wenn du Zeit hast, stattdessen auf Facebook zu bleiben und darauf zu warten, dass dein Kunde zurückruft
3. Schreiben Sie Ihren Code so, wie es Ihr Kunde kaufen wird. Betrachten Sie den Code und nicht nur das Ergebnis. Stellen Sie sich Ihren Kunden als Vorsitzenden für eine Codeüberprüfung vor.
4. Füllen Sie Ihren Code of Asserts

Ich wünschte, ich könnte sagen, ich könnte das, was ich predige, 100% der Zeit üben, aber BDD scheint ein guter Ansatz zu sein, um Ihre Situation in den Griff zu bekommen:

Hier ist ein Link mit weiteren Informationen: http://en.wikipedia.org/wiki/Behavior_driven_development

Ich bin in einem sehr ähnlichen Boot. Ich versuche, möglichst agilen Prinzipien zu folgen (so gut ich sie verstehe). Ich mache die Dinge wahrscheinlich nicht "richtig", aber ich habe große Erfolge bei meinen Projekten erzielt, indem ich versucht habe, agilen Prinzipien zu folgen. Es erfordert eine enorme Menge an Disziplin, da es kein Team gibt, das dafür sorgt, dass Sie nicht einfach anfangen, Abkürzungen zu nehmen.

Ich stelle fest, dass die Verwendung von Code-Formatierungs-Tools wie ReSharper sicherstellt, dass der Code für andere Entwickler zumindest optisch einfach zu erlernen ist.

In Bezug auf die tatsächlichen Methoden ist es für einen einzelnen Entwickler schwierig, sich an einen bestimmten zu halten. Ich bin ein Berater, der in der Regel alleine arbeitet, und ich finde es für mich und den Kunden am einfachsten, einen agilen Prozess zu verwenden. Ich versuche normalerweise, meine Kunden dazu zu bringen, ihre Anforderungen direkt in ein Tool wie Trac einzugeben (oder ich werde es in ihrem Namen tun). Dies hilft nicht nur anderen Entwicklern, den Zweck von Code zu erkennen, sondern auch sich selbst 3 Monate später!

Philosophie: XP / TDD + GTD

allgemeiner Überblick:

• Stakeholder befragen
• Bildschirmmodelle, exemplarische Vorgehensweisen, Papierprototypen (nach Bedarf)
• Feature / Story-Brainstorming (mit und ohne Stakeholder)
• Testfall-Brainstorming (mit und ohne Stakeholder)
• Überlegungen zu Gesamtdesign / Architektur (nach Bedarf)
• Iterationsplanung (mit Stakeholdern)
• Iterationen
• Prozessüberprüfung, Schulung, Wartungsplanung usw. (falls erforderlich)

Jede geeignete Methodik wird helfen - unabhängig von der Anzahl der Personen, die an dem Projekt beteiligt sind. Wählen Sie also jeweils eine aus und sehen Sie, wie Sie Ihre Domain beantragen und zuordnen und deren Erfolge messen können.

Vielleicht ist es interessanter zu fragen, welche Methoden nicht wegzuwerfen sind, da nur 1 Person an dem Projekt arbeitet.

Und der Schlüssel, der mir auffällt, ist die Quellcodeverwaltung (Ja, das ist ein Werkzeug, aber es ist Teil Ihres Arbeitsablaufs, also auch ein Prozess). Leute könnten versucht sein, diesen Pass zu vergeben, da sie "nicht mehrere Personen gleichzeitig beim Editieren des Codes unterstützen müssen".

Ironischerweise finde ich, dass eine verteilte Versionskontrolllösung wie GIT für eine Person besser ist als SVN.

Wenn der Code weggeworfen wird, kann er mit den Methoden ein wenig verwirrt sein, aber alles Wichtige und ich würde sagen, dass Ihre Art, ihn als Teamprojekt mit einer Person zu behandeln, sehr nett und diszipliniert ist.

Schreiben Sie Ihren Code für den nächsten zu lesen, nicht Sie ... seien Sie nett zu ihm / ihr. Sogar der Code zum Wegwerfen bleibt für immer bestehen.

Agil

Features, Storys und Testfälle sind weitaus lehrreicher als formale Dokumentationen, und eine Reihe von Funktionstests ist besser geeignet, um zu demonstrieren, wie etwas verwendet wird oder wie etwas funktioniert, als jede Menge abgestorbener Bäume

Es ist auch einfacher, die Arbeit zwischen den Iterationen abzugeben.

Als selbstständiger Berater würde ich vorschlagen, dass Sie einen Weg finden, bei jedem Auftrag immer mindestens zwei Entwickler zu sein.

Ich bin damit einverstanden, agil zu werden und eine agile Spur von Geschichten und Tests zu hinterlassen, denen andere folgen können, aber ich glaube nicht, dass dieser oder ein anderer Prozess oder eine andere Methodik Bestand haben wird , während die Leute alleine arbeiten.

Ich denke, Code-Reviews sind ein guter Anfang, aber ich mag es, wenn es informell und unterhaltsam ist, wie ein Pair-Code-Review oder eine Pair-Programmierung, um ein bestimmtes Problem oder eine Verbesserung zu lösen (z. B. das Ändern von Legacy-Code, um neue Codierungsstandards zu erfüllen) ). Manchmal sind zwei Augenpaare besser als eines und es macht auch Spaß. Ich finde, dass das Teilen und Diskutieren offener erscheint. Sie könnten auch gerne ein formelles / informelles Mittagessen einnehmen und Sitzungen diskutieren, um zu besprechen, was Sie einzeln oder als Gruppe getan haben, z. B. über ein neues Muster, das Sie verwendet haben, oder neue Technologien, wie ein Problem gelöst wurde.