Entwicklungsmethoden, wenn Hunderte von Entwicklern an einer einzigen Lösung arbeiten?

Wir sind eine Organisation, die aus rund 200 Entwicklern besteht, die ununterbrochen an einem einzigen Produkt arbeiten (unter Verwendung der Versionskontrolle Git), das zu einem bestimmten Zeitpunkt veröffentlicht werden soll.

Aufgrund der großen Anzahl von Entwicklern versuchen wir, "funktionsübergreifende" Teams mit etwa 10 Entwicklern in jedem Team zu erstellen, was zu etwa 20 Entwicklungsteams in der Organisation führt.

Da wir einen kontinuierlich "hohen Standard" (dh, wenn der Entwickler einen Pull ausführt, sollte das Produkt zumindest kompilierbar sein usw.) des Produkts im Haupt-Repository beibehalten möchten, möchten wir eine Art Qualitäts-Gates verwenden.

Ich bin mir nicht sicher, wie ich die Frage formulieren soll, aber ich frage mich, ob ich Ratschläge zu Entwicklungsmethoden für eine so große Gruppe von Entwicklern erhalten könnte, die an einem einzelnen Produkt arbeiten.

Unserer Meinung nach besteht ein Ende des Spektrums darin, es jedem Entwickler zu ermöglichen, sich direkt auf das Haupt-Repository festzulegen. Wir befürchten jedoch, dass aufgrund der hohen Anzahl von Entwicklern / Festschreibungen das "Haupt-Repository" ständig in einem defekten Stadium sein könnte Wir können nicht für jedes Commit ein anspruchsvolles "Quality Gate" haben.

Das andere Ende des Spektrums könnte wie ein Baum oder eine Pyramidenstruktur aussehen (wir glauben, Linus Torvalds / Linux macht das), in der das "Haupt-Repository" nur drei Pull-Quellen hat, diese drei haben nur eine Handvoll vertrauenswürdiger Pull-Quellen usw Wir haben jedoch das Gefühl, dass bei einer solchen Struktur Änderungen eine lange Kette haben müssen, um in das "Hauptlager" zu gelangen. Außerdem liegt das Problem bei einem Zusammenführungskonflikt bei einem anderen Entwickler als dem "ursprünglichen Entwickler".

Wie können wir mit all diesen Hintergrundinformationen und Meinungen die empfohlenen Entwicklungsmethoden für so viele Entwickler lernen und lesen? Wie strukturieren große Organisationen (Microsoft, Facebook, Ubuntu usw.) ihre Entwicklung?

Sie sollten auf jeden Fall in Betracht ziehen , das Produkt in Module aufzuteilen, wobei die Schnittstellenteams diese konstituierenden Module zu einem Produkt zusammenfassen. Dies wiederum würde bedeuten, dass die Repositorys entsprechend der Partitionierung und Hierarchie des Moduls aufgeteilt werden. Wenn sich herausstellt, dass dies nicht möglich ist, wird das Projekt wahrscheinlich aufgrund der Anzahl der beteiligten Entwickler zum Stillstand kommen.

Wenn Sie planen, Git für die Versionskontrolle zu verwenden, würde ich die Verwendung eines Code-Überprüfungssystems (wie Gerrit ) empfehlen , um die Transparenz zu verbessern und die Qualität für jedes Repository sicherzustellen. Auf diese Weise müssten alle Arbeiten genehmigt werden, bevor sie in einem maßgeblichen Repository zusammengefasst werden. In diesem Szenario ist es sinnvoll, bestimmten vertrauenswürdigen Personen Berechtigungen zum Pushen von einem Repository unter einem Codeüberprüfungssystem in ein anderes Repository (möglicherweise auch unter einem Codeüberprüfungssystem) zu erteilen. Bei richtiger Anwendung sollte dies ein schneller und äußerst nützlicher Prozess sein, der den Entwicklungsprozess nicht behindert.

In Bezug auf die Buildüberprüfung benötigen Sie einen CI-Server (Continuous Integration), der den Zweck hat, Code automatisch zu erstellen und zu überprüfen. Mit "Code verifizieren" meine ich, dass der Code erfolgreich kompiliert wurde und die Tests bestanden wurden. Infact Jenkins (CI-Server) kann im Rahmen der Gerrit- Überprüfungsphase mit dem Gerrit- Codeüberprüfungssystem verknüpft werden, wodurch der Prozess vollständig automatisiert wird.

Zusätzlich zu diesen Integrationstools ist es wichtig, im Rahmen der Entwicklungsmethodik eine häufige Integration anzustreben, um die Zeit für das Zusammenführen zu minimieren.

Es kann sich lohnen , einen agilen Entwicklungsprozess wie Scrum in Betracht zu ziehen, dessen Ziel es ist, ein komplexes Produkt in überschaubare Teile von Produktinkrementen (so genannte Sprints) zu zerlegen. Dies würde Integrationsmöglichkeiten zwischen Repositories bieten.

Mit einem 200-köpfigen Entwicklungsteam müssen Sie natürlich eine hierarchische Struktur haben. Eine Einzelperson oder eine kleine Gruppe von Personen trifft Entscheidungen über das Design des Softwareprodukts. Ihr Entwicklungsprozess sollte dies widerspiegeln: Sie benötigen Codeüberprüfungen und Tests, um sicherzustellen, dass die zu erstellende Software tatsächlich mit dem übereinstimmt, was Sie erstellen möchten (und auch aus Qualitätsgründen).

Sogar die kleinen Teams brauchen Führungskräfte, die die Teams leiten und ihre Arbeit überprüfen, während sie einzelne Komponenten entwickeln. Dies sollten auch Qualitätskontrollprozesse auf Teamebene sein.

Also, ja, Sie sollten in Bezug auf das Repository einer hierarchischen Struktur folgen. Dies soll der hierarchischen Struktur des Projekts insgesamt entsprechen.

Einzelne Komponenten sollten mit einem gewissen Maß an Eignung gebaut und getestet werden, bevor Sie überhaupt darüber nachdenken, sie alle zusammenzusetzen. Es wäre ein Chaos, wenn 200 Menschen sich direkt für das Hauptprojekt engagieren könnten. Sie sollten für jede Gruppe separate Bereiche haben, in denen einzelne Personen ihre Änderungen täglich vornehmen können, ohne dass dies Auswirkungen auf den Hauptteil des Projekts hat.

Es ist eine sehr gute Sache, wenn "Änderungen eine lange Kette haben, die es zu überwinden gilt, um in das Haupt-Repository zu gelangen", da Sie mit dieser Kette die Qualität sicherstellen können. Es mag schneller erscheinen , wenn alle Änderungen sofort auf das Haupt-Repository angewendet werden. Tatsächlich bereitet dies jedoch nur enorme Kopfschmerzen, da Sie einen ständig fehlerhaften und unbrauchbaren Haupt-Build Ihrer Software haben.

Es ist auch eine gute Sache, dass "wenn ein Zusammenführungskonflikt auftritt, das Problem auf einem anderen Entwickler landet" - insbesondere sollte ein Entwickler auf höherer Ebene entscheiden, wie ein Konflikt gelöst werden soll.

Wenn Sie etwas Großes und (in der Folge) Unbeherrschbares haben, besteht der Ausweg darin, es in kleinere und überschaubare Teile zu teilen.

Es gibt verschiedene Schritte, mit denen Sie das Team und das Projekt besser pflegen können:

1. Funktionalität in Module aufteilen. Die Funktionalität sollte nach den Prinzipien der hohen Kohäsion, der niedrigen Kopplung und der Abhängigkeitsinversion in maximal unabhängige Module unterteilt werden. Das erste Prinzip hilft Ihnen, logisch konsistente Module zu erstellen. Der zweite wird dazu beitragen, diese Module so unabhängig wie möglich zu halten. Das dritte Modul hilft, abhängige Module gleichzeitig zu entwickeln (wenn Modul A von Modul B abhängt, sollte B eine Schnittstelle bieten, die A verwenden kann, auch wenn B nicht vollständig bereit ist).

2. über klare Unterlagen verfügen. Wenn so viele Menschen zusammenarbeiten, können Dinge leicht vergessen oder missverstanden werden. Daher müssen Sie der gesamten Dokumentation, von den Anforderungen bis zu architektonischen Lösungen, besondere Aufmerksamkeit widmen.

3. Menschen für Aufgaben (niemals Aufgaben für Menschen). Nachdem Sie die Funktionalität in kleinere Gruppen unterteilt haben, erstellen Sie Teams, um an diesen Gruppen zu arbeiten. Das Erstellen von Teams wird in dieser Phase einfacher, da Sie bereits wissen, woran jedes Team arbeiten soll. Und Aufgaben wie Codeüberprüfungen würden in jedem Team durchgeführt.

4. Klares Aufgabensystem. Jeder der 200 Entwickler sollte genau wissen, woran er arbeiten soll. Auf diese Weise behalten Sie den Überblick darüber, was bereits erledigt ist, woran die einzelnen Personen arbeiten und wie viel Arbeit noch übrig ist.

5. Quellcodeverwaltung. (Ich denke, das ist in anderen Antworten ziemlich gut umrissen))

Versuchen Sie schließlich, eine möglichst einfache Struktur von Teams und Modulen zu erstellen. Bei einem so großen Projekt kann man sich Komplexität nicht leisten.

Zusätzlich zu den anderen Antworten, die eine hierarchische Struktur vorschlagen: Dies impliziert, dass Sie Integrationszeitpunkte einplanen müssen, bei denen der Fokus ausschließlich darauf liegt, den Code in der Hierarchie nach oben zu verschieben und alles zusammenzufügen. Dies unterscheidet sich nicht wesentlich von kleineren Projekten mit einer letzten Phase, in der keine andere Arbeit als das Testen und Beheben von Fehlern ausgeführt wird, sondern nur häufiger. Da Sie in einer großen Gruppe arbeiten, die nach hohen Standards strebt, wird das meiste davon (Gemütsverfassung) wahrscheinlich bereits vorhanden sein.

Zusätzlich zu der Antwort von hotpotato (die sich direkt auf der Marke IMHO befindet) würde ich auch vorschlagen, einige Versionskontrolltore zu implementieren, wie Sie vorschlagen. Als wir ein großes Team und eine große Codebasis für SCM nach Git verlegten, entschieden wir uns für die so genannte "Wohlwollende Diktator" -Methode, ähnlich dem von Ihnen beschriebenen Modell.

In diesem Szenario gibt es viele verschiedene Zweige der vollständigen Codebasis, die regelmäßig von ihrem Quellzweig aus aktualisiert werden. Die Verantwortung für die Förderung des Codes in sichtbareren / öffentlicheren Bereichen liegt jedoch bei einer einzelnen Person (oder einer kleinen Gruppe von Personen). Dies ist in der Regel der Fall an einen Codeüberprüfungsprozess gebunden. Mit einer gut organisierten Verzweigungsstruktur kann dies WIRKLICH gut funktionieren. Weitere Informationen finden Sie unter diesem Link .

Ich habe an einem riesigen System gearbeitet, an dem mehrere hundert Entwickler gleichzeitig mit ungefähr 150 Millionen SLOC gearbeitet haben. Dies war auf einem Mainframe, wir sprechen also nicht von Visual Studio, aber die Prinzipien können trotzdem übernommen werden.

Wenn Sie Java verwenden, würde ich auf jeden Fall Maven verwenden. Wenn Sie VS verwenden, können Sie auch Nuget verwenden, obwohl ich nicht ganz sicher bin, ob es bei Maven noch vorhanden ist oder nicht (es ist auch etwas anders). Wenn Sie ein solches System verwenden, können Sie Ihre Abhängigkeiten ermitteln und sie einzeln verwenden. Sie müssten ein Build-Skript die relevanten Abhängigkeiten ziehen und als Batch erstellen.

Da Sie nicht direkt eine Frage stellen, sondern nach einer Methodik fragen, erkläre ich Ihnen, wie mein früherer Arbeitgeber damit umgegangen ist.

Das System wurde in Cluster aufgeteilt . Cluster repräsentierten Geschäftsbereiche und Systeminfrastrukturbereiche. Ich werde sie nicht nennen, aber für ein riesiges Einzelhandelsgeschäft könnte man sich Dinge wie Marketing, Einzelhandelsgeschäfte, Online-Geschäfte, Beschaffung und Vertrieb vorstellen. Die Systeminfrastruktur repräsentierte Dinge wie Kunden und Sicherheit. Innerhalb jedes Clusters gab es Komponenten . Mit der vorherigen Analogie können Sie beispielsweise Sicherheitskomponenten wie einmaliges Anmelden, Verzeichnisdienste, Überwachung, Berichterstellung usw. in Betracht ziehen. In jeder Komponente sind die entsprechenden Routinen gespeichert.

Als Namespace oder Paket hätten Sie beispielsweise Organisation.Security.DirectoryServices. Indem die Teams die gesamte Logik für die relevanten Bereiche enthielten, arbeiteten sie ziemlich autonom. Offensichtlich gab es große Projekte, bei denen mehrere Teams mitarbeiten mussten, aber die Abläufe verliefen weitgehend reibungslos.

Ich hoffe das hilft.