Ich wollte sehen, was die Leute für den besten Weg hielten, um den jüngeren Mitgliedern zu helfen, Vertrauen in ihre Fähigkeit zu haben, Code zu refaktorisieren. Ich finde, dass oft junge Entwickler einfach den bestehenden Mustern folgen und eine Abneigung spüren, um irgendetwas aufgrund des wahrgenommenen Risikos zu brechen. Ich versuche, sie dazu zu bringen, die Anforderungen (neu und existierend) zu betrachten und den Code dem Domänenmodell zuzuordnen, anstatt die vorhandene Codebasis zu "tweaken" oder "zu biegen", um neue Funktionen zu unterstützen. Ich wollte nur sehen, ob es Leute gibt, die hier Erfolg haben. Wir denken gerade darüber nach, mehr Paar-Programmierung, TDD, Code-Reviews etc. zu machen, wollten aber überprüfen, ob es andere Erfolgsgeschichten gibt ...
Die einzige zuverlässige Antwort wird Unit Tests IMHO sein. Nicht unbedingt TDD - bringen Sie sie dazu, Tests für die vorhandenen Methoden / Klassen zu schreiben, die sie umgestalten wollen, stellen Sie sicher, dass sie tun, was sie tun, und erlauben Sie ihnen, wie verrückt zu refactorisieren, während Sie sich auf die Tests verlassen Methoden sind immer noch gültig.
Die Tests für das Konfidenzniveau und die Flexibilität, die Unit-Tests erlauben, sind bei solchen Aktivitäten äußerst wertvoll.
Es scheint, dass Paar-Programmierung mit einem Senior-Entwickler in Kombination mit Schreibtests die optimale Situation wäre. Wenn der erfahrenere Entwickler des Paares führend ist, wird das Testen nur ein Teil davon sein.
Das Schreiben von Tests allein lässt noch Raum für Verbesserungen. Das Schreiben von Tests in einer Paarumgebung ist das Beste aus beiden Welten und sollte daher das Vertrauen schneller aufbauen.
Ich empfehle Ihnen Unit-Tests vor einem starken Refactoring zu starten, wenn Sie eine gute Codeabdeckung haben, indem Sie einfach die Tests ausführen, die Sie sehen können, wenn ein Test fehlschlägt, wobei das Refactoring das gewünschte Programmverhalten beeinflusst hat / p>
Grundsätzlich kann Unit Testing Ihnen das Vertrauen geben, das Ihr Team für die Umgestaltung braucht.
Egal was, Sie sollten nach "mehr Paar-Programmierung, TDD, Code-Reviews usw." forschen. Sie sollten auch sicherstellen, dass Ihre Programmierer (sowohl Junior in Jahren und in Gewohnheiten) in den Grundlagen geschult sind.
Ich empfehle, dass sie McConnells Code Complete und Fowlers Refactoring lesen.
Mein Vorschlag wäre, ein System zu nehmen, das sich im Laufe der Zeit ziemlich ändern wird, und einem Junior-Entwickler einen Plan zu geben, welche Grundlagen er darauf anwenden soll, z. Fehlen Komponententests, welches Designmuster kann sinnvoll sein, um die neue Funktionalität hinzuzufügen, ist das ein "guter" Code und wenn nicht, welche Änderungen würden Sie daran vornehmen? Ein Teil davon ist, sie in den Code einzubringen und damit vertraut zu werden. Wenn ein Entwickler nicht weiß, was irgendetwas im System tut, besteht die Möglichkeit, dass er minimale Änderungen vornehmen möchte, aus Angst, etwas zu kaputt zu machen und den nachfolgenden negativen Fall. Wenn es ein hochrangiges Mitglied geben kann, das als Mentor fungieren kann und das, was Junior-Entwickler vorschlagen, zu etwas führt, das besser zu dem passt, was gesucht wird, dann ist das vielleicht das Größte, um da rein zu kommen.
Beachten Sie, dass für die oben genannten, Senior-Mitglied muss möglicherweise eine gute Vertrautheit und in einer Art und Weise bereits die Planung, wie die Änderungen, die der Junior-Entwickler tun, gemacht werden, aber die Idee ist, die Junioren mehr zu bekommen In den Code würde ich es sehen. Wenn sich die Junior-Entwickler daran gewöhnen können, in Dinge hineinzuspringen und dazu ermutigt werden, dann kann ich dort Erfolg sehen. Der Schlüssel ist, die Idee zu haben, wie man das, was der Junior-Entwickler vorschlägt, korrigiert und sie dennoch ermutigt, mehr in den Gesamtprozess zu geben, anstatt gesagt zu bekommen, was zu tun ist.
Manche Leute werden eher herausragen und eine Chance ergreifen. Der Schlüssel ist für die Gruppe, um zu sehen, wie sich herausstellt, was Sie am Ende wollen. Eine Gruppe von Junior-Entwicklern, die alle an verschiedenen Lösungen arbeiten, wo der Senior-Entwickler ist Vielleicht haben sie das System ursprünglich gebaut oder verschiedene Produkte zusammen integriert und können so einen Input geben, was getan werden sollte, aber eher als Leitfaden dienen als als Eltern, um Dinge zu erledigen.
Eine andere Möglichkeit, dies zu betrachten, besteht darin, Dinge einfach aus der Sicht des Junior-Entwicklers zu visualisieren. Wenn sie etwas vorschlagen und etwas bekommen, z.B. Lob oder bessere Aufgaben, dann kann dies die Dinge ins Rollen bringen, obwohl man vorsichtig sein muss, was gegeben wird, wenn man die Dinge weiter in den Griff bekommt, kann zu Problemen führen, wenn es zu hoch wird.
Versuchen Sie auch, einige Coding-Dojos zu machen. Ein Paar sitzt und programmiert im Beamer und dreht alle fünf Minuten einen Entwickler. Lassen Sie sie darüber sprechen, wie sie umgestalten und warum.
Siehe: Ссылка
Ich glaube, dass die Frage nicht spezifisch für C # ist, also werde ich vorschlagen, es mit Java auszuprobieren, indem Sie Eclipse verwenden. Eclipse hat die besten Refactoring-Tools, die ich je gesehen habe (obwohl ich IntelliJ IDEA oder Resharper nie ausprobiert habe). Ich habe viel davon profitiert, indem ich das Refactoring durch Eclipse gelernt habe, insbesondere das Vorschaufenster, bevor ich Änderungen vorgenommen habe.
Ich würde eine Kombination aus Büchern, Tools, Programmierung und Mentoring empfehlen.
Vor allem anderen - bringen Sie den Kandidaten dazu, Refactoring von Martin Fowler zu kaufen oder zu leihen und lesen Sie es.
Wenn Sie ein gutes Quellcodeverwaltungssystem haben, sollte es trivial sein, einen separaten Zweig zu erstellen, mit dem Sie spielen können. Auch wenn das Endergebnis der Übung nützlich ist, können Sie es leicht in den Stamm zusammenführen.
Wählen Sie als Nächstes eine bestimmte Aufgabe, von der Sie wissen, dass sie die Anwendungs- struktur verstehen muss. Bitten Sie sie zum Beispiel, einen Teil des Systems zu instrumentieren. Dies stellt eine Aufgabe zur Verfügung, in der statt allgemeiner Anweisungen gearbeitet werden kann (lesen Sie beispielsweise die Framework-Dokumentation oder lesen Sie diesen Code).
Der nächste Teil besteht darin, zu fragen, dass Tests geschrieben werden, um die von dieser Aufgabe berührte Funktionalität zu unterstützen. Überprüfen Sie die Tests und ermutigen Sie zum Schreiben umfassender Tests. Es ist wichtig, ein Tool wie NUnit zu verwenden, oder wenn Ihre IDE Komponententests unterstützt, verwenden Sie das. Ermutigen Sie die Person, Fragen zu stellen und herauszufinden, warum die Dinge so sind, wie sie sind.
Wenn Sie eine IDE verwenden, die sie unterstützt, führen Sie die Refactoring-Tools in der IDE ein und ermutigen Sie sie, den Code zu refaktorieren. Verwenden Sie Paarprogrammierung oder regelmäßige Codeüberprüfungen, um die Person zu beraten. Die Tests können verwendet werden, um zu zeigen, wie Komponententests ein wichtiger Teil eines guten Refactoring-Aufwands sind. Fange klein an - ändere die Namen der Dinge oder extrahiere Felder in Eigenschaften und gehe dann zu komplexeren.
Hoffentlich wird die Person am Ende der Übung nicht nur bequem genug sein, um die Anwendung zu hinterfragen, zu optimieren und zu ändern, und Sie könnten auch einige nützliche Funktionen daraus haben: -)
Tags und Links c# refactoring