Wie kann die Wiederverwendung und Dokumentation von Code gefördert werden? [geschlossen]

Als Teamleiter von mehr als 10 Entwicklern möchte ich die Wiederverwendung von Code fördern. Wir haben viel Code geschrieben - viele davon haben sich in den letzten Jahren wiederholt. Das Problem ist nun, dass viele dieser Codes nur ein Duplikat eines anderen Codes oder eine geringfügige Variation davon sind.

Ich habe die Bewegung (Diskussion) begonnen, wie man Code in Komponenten umwandelt, damit sie für zukünftige Projekte wiederverwendet werden können, aber das Problem ist, dass ich befürchte, die neuen Entwickler oder andere Entwickler, die die Komponenten nicht kennen, werden einfach weitermachen und schreibe ihr eigenes Ding.

Gibt es eine Möglichkeit, die Entwickler daran zu erinnern, die Komponenten wiederzuverwenden, die Dokumentation zu verbessern, zur zugrunde liegenden Komponente beizutragen, anstatt den vorhandenen Code zu duplizieren und zu optimieren oder einfach nur ihren eigenen Code zu schreiben?

Wie können die Komponenten leicht auffindbar und benutzerfreundlich gemacht werden, damit jeder sie verwenden kann?

Ich denke, jeder Entwickler kennt die Vorteile von wiederverwendbaren Komponenten und möchte sie nutzen. Wir wissen nur nicht, wie wir sie erkennbar machen können. Außerdem wissen die Entwickler, wenn sie Code schreiben, dass sie wiederverwendbaren Code schreiben sollten, aber es fehlt ihnen die Motivation, dies zu tun.

Sie brauchen eine Dokumentation, eine ordnungsgemäße. Es sollte leicht zu finden und zu navigieren sein. Du brauchst auch Disziplin. Wenn Ihre wiederverwendbaren Codebibliotheken bereits eine Lösung enthalten, der Entwickler jedoch stattdessen (ohne Angabe von Gründen) seine eigene Lösung verwendet, sollten Sie seine Lösung zurücksetzen und ihn auffordern, die vorhandene Lösung zu verwenden.

Ich stimme auch dem Kommentar von Euphoric zu dieser Frage zu. Es ist oft unmöglich, irgendetwas zwischen verschiedenen Projekten wiederzuverwenden (normalerweise sehen alle CRUD-Operationen gleich aus, aber normalerweise können Sie sie nicht wieder verwenden).

Neben den bereits genannten Faktoren "Dokumentation", "leicht zu finden und zu navigieren", "Disziplin" und "Codereview"

wiederverwendbarer Code muss sein

• einfach zu bedienen (= brauche Beispiele zB Unittests)
• ohne zu viele Abhängigkeiten zu anderen Modulen und
• Es muss eine stabile API haben, damit ich meine Anwendung nicht aktualisieren muss, um die Bibliothek zu verwenden.

ohne die letzten beiden Elemente ist es viel einfacher, "copy & past-inheritance" zu verwenden, die wir nicht wollen.

Ich denke, der beste Weg, um sie tatsächlich dazu zu bringen, Code wiederzuverwenden, ist Motivation. Wenn Sie die wiederverwendbaren Komponenten in zusätzliche Projekte investieren, wie von Euphoric vorgeschlagen, müssen Sie viel Aufwand betreiben. Wo ich arbeite, haben wir ein Projekt erstellt, das eine Reihe vordefinierter Schnittstellen in konfigurierbaren Ausführungsplänen ausführt und einige Dienste bereitstellt (zB verschiedene Klassen für DB_interaction, einen FTP-Dienst, ...). Das Projekt ist ein großer Erfolg, weil unsere Entwickler das Mikro-Framework tatsächlich nutzen wollen , weil es ihnen viel Zeit spart, um Boilerplate-Code für ähnliche Projekte zu schreiben. Das Gleiche gilt für Utility-Bibliotheken für Listen, Strings usw., in diesem Fall möchten Sie jedoch vorhandene Bibliotheken nur einmal verwenden. (Warum das Rad neu erfinden?)

Fazit: Lassen Sie Ihre Entwickler die Vorteile bewährter wiederverwendbarer Komponenten erleben. Aber ich stimme auch der Antwort von Andrzej Bobak zu: Viele Dinge sind nicht wiederverwendbar, weil sie ähnlich, aber nicht gleich sind.

Das wird schwierig, weil die Leute gerne neuen Code für einfache Komponenten schreiben und es gerne auf ihre Weise machen. Es ist viel schwieriger, eine vorhandene Lösung zu nutzen und zu erweitern, als eine vollständig neue Implementierung mit den neuen Anforderungen zu schreiben. Wie bereits erwähnt, müssen Sie im Team einen Codeüberprüfungsprozess starten, um Situationen zu identifizieren, in denen eine vorhandene Komponente anstelle einer neuen verwendet / erweitert werden sollte.

Sie müssen auch eine sehr gute und gründliche Dokumentation führen, damit die Benutzer darauf verweisen und leicht finden können , was sie benötigen. Wenn die Dokumentation unvollständig ist oder nicht mit der Originaldokumentation übereinstimmt, werden die Benutzer nicht dazu motiviert, sie zu durchsuchen oder zu verbessern.

Als Teamleiter sollten Sie die Leute auch ermutigen, sich zu fragen, ob eine ähnliche Komponente vorhanden ist, bevor Sie eine eigene erstellen, und sie an die Dokumentation weiterleiten, damit sie diese nachschlagen können. Sicher, der Codeüberprüfungsprozess wird es erkennen, wenn jemand eine vorhandene Komponente übersehen hat, aber was ist, wenn er bereits 10 Stunden Entwicklungszeit in seine eigene Implementierung gesteckt hat? Sie müssen diese Situationen vermeiden, indem Sie ein gutes Forschungsverhalten im Team durchsetzen.

Wir sind mit diesem Problem bei einem großen Projekt konfrontiert, an dem ich gerade arbeite. Wir haben in den letzten Monaten einige Entwicklerrotationen gehabt, es ist auch eine ziemlich große Codebasis, und selbst diejenigen, die von Anfang an an dem Projekt beteiligt waren, wissen nicht jeden Zentimeter davon.

Obwohl der Code oft gut geschrieben und in kleine Teile mit einzelnen Verantwortlichkeiten aufgeteilt ist und die Dokumentation vorhanden ist, ist es ziemlich einfach, etwas zu übersehen, was getan wurde. Konsistente Namenskonventionen sind sehr hilfreich, da in jeder IDE leicht etwas nachgeschlagen werden kann. Die Dokumentation mag umfassend sein, aber wenn sie länger wird, ist es ein bisschen mühsam, sie durchzulesen.

Eine Sache, die wir meiner Meinung nach getan haben, um die Situation erheblich zu verbessern, war die Einführung einer Sache, die wir Lightning-Gespräche nennen . Jedes Mal, wenn jemand einen Code schreibt, von dem er glaubt, dass er dem Team bekannt sein sollte, wird eine kurze Präsentation (in der Regel 5 bis 15 Minuten) organisiert. Wir versuchen dies einmal pro Woche zu tun. Die Themen variieren in der Regel von neuen Funktionen und Möglichkeiten zur Behandlung komplexer Probleme, die in letzter Zeit aufgetreten sind, über Test- / Codierungsansätze, wiederverwendbare Komponenten bis hin zu Gesprächen über die Grundlagen der App und deren Umgestaltung.

Bestimmte Themen werden in ähnlichen, unternehmensweiten Gesprächen angesprochen. Wir haben festgestellt, dass es eine ziemlich effiziente Möglichkeit ist, den Wissensaustausch voranzutreiben. Es ist viel einfacher, eine kurze Präsentation zu sehen und sich zu merken und zu wissen, wo Sie nach zusätzlicher Dokumentation suchen oder wen Sie um Hilfe bitten können, als an sehr langen und selten abgehaltenen Schulungen teilzunehmen oder einfach dort zu sitzen und die Dokumente von vorne bis hinten zu lesen.

Die unternehmensweiten Gespräche standen eigentlich an erster Stelle. Wir haben diesen Ansatz gerade für den projektspezifischen Wissensaustausch übernommen und ich denke, er funktioniert ziemlich gut.

Paarprogrammierung beschleunigt auch die Wissenszirkulation erheblich.

Ich denke, das sind eigentlich zwei Fragen in einer - ich werde versuchen, beide zu beantworten.

1) Wie reduzieren wir doppelten Code in einer Codebasis?
Es hilft uns, uns an den Vorteil dieser Vorgehensweise zu erinnern: Es führt zu weniger Fehlern aufgrund doppelter Geschäftslogik und es muss weniger Code gepflegt werden. Der beste Weg, dies zu verhindern, ist die Kommunikation - wie in den anderen Antworten erwähnt. Ich stimme der Empfehlung zu, Codeüberprüfungen mit der zusätzlichen Einschränkung zu verwenden, dass Sie die Verantwortung für die Codeüberprüfung gleichermaßen teilen sollten, um das Wissen richtig zu verbreiten. Sie sollten auch tägliche Stand-ups verwenden, damit Entwickler häufig erkennen, wenn jemand versucht, ein Problem zu lösen, für das bereits nützlicher Code vorhanden ist. Sie sollten auch das Koppeln von Code in Betracht ziehen, da dadurch der Wissensaustausch verbessert und die Programmierer diszipliniert werden.

Ich würde auch empfehlen, Ihre Entwickler so nah wie möglich zusammenzubringen, vorzugsweise im selben Raum. Mit vielen geteilten Whiteboards und viel Platz. Dann schick sie zusammen zum Essen. Je mehr Ihre Entwickler "binden", desto besser kommunizieren sie miteinander.

Ich bin mit der Empfehlung, ein Wiki oder ähnliches wie Dokumentcode zu verwenden, nicht einverstanden. Egal wie diszipliniert Entwickler sein wollen, die Dokumentation weicht vom ursprünglichen Code ab. Ein effektiverer Ansatz wäre die Verwendung von Spezifikationen durch Beispielstiltests. Diese dokumentieren den Code auf eine Weise, die klar macht, wie er verwendet werden soll, und Ihre Tests schlagen fehl, wenn jemand den Code ändert, ohne die Beispiele zu ändern.

Sie haben bereits eine große Codebasis mit vielen doppelten Codes, daher sollten Sie wahrscheinlich daran arbeiten, diese zu überarbeiten. Es kann schwierig sein, doppelten Code zu finden, der nicht ausgeschnitten und eingefügt wurde. Ich schlage vor, Sie analysieren Ihre Änderungshistorie, anstatt dies zu tun. Suchen Sie nach Dateien, die sich häufig gleichzeitig ändern. Dies weist wahrscheinlich auf Probleme mit der Kapselung hin, wenn kein tatsächlicher doppelter Code angezeigt wird und es sich trotzdem lohnt, diesen zu bereinigen. Wenn Sie Ihren Bugfix-Verlauf auch anhand Ihrer Codeänderungen analysieren können, finden Sie möglicherweise bestimmte Hotspots, an denen häufig Korrekturen erforderlich sind. Wenn Sie diese Hotspots analysieren, werden Sie wahrscheinlich feststellen, dass viele davon auf doppelte Geschäftslogik zurückzuführen sind, die ein Entwickler nur an einer Stelle geändert hat, ohne zu bemerken, dass sie zweimal geändert werden muss.

2) Wie sollten wir nähern gemeinsame Widgets machen, Komponenten, Bibliotheken, etc. , die dann in anderen Projekten verwendet werden können .
In diesem Fall sollten Sie nicht versuchen, die Geschäftslogik zu verpacken, sondern nützlichen Framework-Code gemeinsam nutzen. Dies kann eine heikle Angelegenheit sein, da die Kosten für das Erstellen und Verwalten eines Satzes gemeinsam genutzter Komponenten sehr hoch sein können und es schwierig sein kann, vorherzusagen, in welchen Fällen dies sinnvoll ist. Der Ansatz, den ich hier vorschlagen würde, ist eine Drei-Treffer-Regel. Machen Sie sich keine Gedanken darüber, einen ähnlichen Code zweimal zu schreiben. Wenn Sie ihn jedoch ein drittes Mal ausführen müssen, müssen Sie ihn in eine gemeinsam genutzte Komponente umgestalten. An diesem Punkt können Sie sich ziemlich sicher sein, dass es nützlich ist, und Sie haben eine gute Vorstellung von den umfassenderen Anforderungen für das Bauteil. Natürlich ist hier die Kommunikation zwischen Entwicklern von entscheidender Bedeutung.

Ziehen Sie in Betracht, so viele Ihrer gemeinsam genutzten Komponenten wie möglich als Open Source zu nutzen. Dies ist keine Geschäftslogik, sodass Ihre Konkurrenten keinen großen Vorteil daraus ziehen können. Es bedeutet jedoch, dass Sie zusätzliche Prüfer und Betreuer kostenlos erhalten.

IMMO der Schlüssel ist nicht Dokumentation oder Tools, der Schlüssel ist KOMMUNIKATION. 10+ Entwickler sind nicht viele Leute, einige Dinge, die diese Kommunikation verbessern:

• Paarprogrammierung: Bei zwei Personen gibt es weitere Änderungen, bei denen einer der beiden weiß, dass das Problem bereits in einem anderen Teil des Projekts gelöst ist, und verwendet es erneut.

• Kollektiver Code-Besitz: Alle Menschen arbeiten mit den verschiedenen Teilen des Systems. Auf diese Weise ist es viel einfacher, zu wissen, dass etwas bereits in einem anderen Teil des Projekts getan wurde. Für mich ist dies eine grundlegende Praxis in einem Team.

• Nehmen Sie sich Zeit für die Bearbeitung horizontaler Projekte, z. B. einen oder zwei Freitags im Monat, und die Entwickler können in dieser Zeit an eigenen Projekten arbeiten, die für Ihr Unternehmensprojekt relevant sind. Auf diese Weise können die Entwickler wiederverwendbare Bibliotheken und Komponenten schreiben. Manchmal ist der Code bereits vorhanden, muss jedoch bereinigt und dokumentiert werden.

• Machen Sie Vorträge und Workshops: Nehmen Sie sich Zeit für Entwicklervorträge und Workshops, der Entwickler kann über seine Bibliotheken sprechen oder Sie können Refactor-Workshops durchführen und duplizierten Code nehmen und die Duplikate entfernen, um eine wiederverwendbare Komponente zu erstellen.

Dokumentation wird wahrscheinlich benötigt, ist aber nur ein kleiner Teil des tatsächlichen Bedarfs: Verbesserung der Kommunikation in Ihrem Team.

Wie wäre es mit einer lokalen Suchmaschine wie Lucene (oder etwas spezifischerem für den Quellcode), um Ihren Code zu indizieren? Wenn jemand anfängt, eine neue Klasse oder eine neue Funktion zu schreiben (zum Beispiel), muss er (als interne Richtlinie) einige Suchvorgänge durchführen, bevor er seinen eigenen Code schreibt. Auf diese Weise können Sie zu viel Kommunikation vermeiden und sich auf gute Kommentare, Methoden und Klassennamen verlassen. Ich mache das mit Open-Source-Suchmaschinen, die im Internet verfügbar sind: Ich weiß nicht, wer was geschrieben hat oder wie eine Methode oder eine Klasse heißt, aber mit ein paar Suchanfragen oder Synonymen finde ich immer, was ich brauche.

Sie benötigen ein Tool, das Ihren Entwicklern dabei hilft, dies nahtlos zu tun. Wenn Ihre Entwickler feststellen, wie viel Zeit sie sparen können, indem Sie die Code-Schnipsel wiederverwenden (nicht nur beim Schreiben des Codes, sondern natürlich für die Qualitätssicherung, Integration usw.), unterstützt durch ein effizientes Tool, das einfach zu bedienen und zu verwenden ist direkt in die Entwicklungsumgebung integriert, werden sie Sie bitten, ein solches Tool zu übernehmen!

Achten Sie darauf, dass die Realisierung von Bibliotheken für die Wiederverwendung von Code häufig nicht zu einem großen Vorteil führt (sie werden in der Regel zu leistungsfähig und umfangreich ...). Stattdessen möchte ich mich auf einfache Ausschnitte konzentrieren, dh wenige Codezeilen, die eine bestimmte Aufgabe auf effektive Weise lösen.

Auf diese Weise können Sie die Verwendung von Richtlinien und Best Practices erzwingen, indem Sie reale Beispiele angeben, die direkt von Programmierern verwendet werden können.

Es gibt verschiedene Tools für die Snippet-Verwaltung. Ich empfehle dieses Tool: http://www.snip2code.com .

(Haftungsausschluss: Ich bin einer der Gründer von Snip2Code, und ich war - zusammen mit meinen Mitbegründern - vor einiger Zeit in derselben Denkweise: Aus diesem Grund haben wir uns entschlossen, dieses Projekt zu starten, in dem alle von mir erfassten Funktionen zusammengefasst sind oben erwähnt, dh Teilen von Snippets innerhalb eines Teams, Integration in IDEs wie Visual Studio, Eclipse, IntelliJ, Notepad ++ usw.)