Comment gérez-vous le refactoring avec une grande base de code et de nombreux développeurs?

Je voudrais éviter une situation où deux développeurs refactoriser le même code simultanément sans en parler d'abord, probablement en utilisant un outil quelconque, peut-être un plug-in Eclipse. Pouvez-vous m'aider?

Nous avons 4,5 millions de lignes de code et plus de 20 équipes de développeurs sur quatre continents.

Idéalement, j'aimerais que le deuxième des développeurs mentionnés plus haut remarque que quelqu'un d'autre travaille sur le même morceau de code et parle au premier avant de modifier quoi que ce soit.

Connaissez-vous une solution?

De nombreux systèmes de contrôle de source de 2e génération fonctionnent à l'aide d'une «caisse» connectée qui informe le serveur que vous avez l'intention de modifier un fichier. Les exemples incluent TFS, SourceGear Vault et bien d'autres. De cette façon, vous pouvez techniquement accomplir votre exigence. Comme l'a souligné Adam Butler, ces types d'outils sont livrés avec leurs propres problèmes (sans entrer dans un long débat - un soutien limité pour le travail hors ligne et un flux de travail de développement généralement contre-productif).

Je suggérerais certainement une sorte d'approche hiérarchique pour répartir le travail de refactorisation. Les développeurs pourraient logiquement être regroupés en sous-équipes, chacune responsable de domaines spécifiques du code. Selon la façon dont vous aimez structurer les équipes, chacune pourrait avoir un rôle de «chef de file» responsable de la conception de haut niveau de la zone de l'équipe. Cette structure doit être bien connue des développeurs, et elle doit simplifier la communication pour le refactoring. Je suis sûr que cette approche semble trop formelle et rétrograde pour certains, mais je pense qu'il est grandement préférable que plus de 20 développeurs utilisent une approche «gratuite pour tous» pour refactoriser un grand système. Certains refactorings auront lieu à un niveau élevé (par exemple, comment le module X communiquera-t-il avec le module Y), dans ce cas, vous aurez besoin de personnes capables de passer des appels au niveau approprié. Tous les développeurs de l'équipe ne devraient pas prendre de décisions architecturales, donc une hiérarchie est presque imposée dans tous les cas, même si l'on choisit de l'ignorer.

Donc, fondamentalement, il existe des outils pour répondre à l'exigence de base que vous mettez en avant, mais aucun outil ne remplacera les communications appropriées et n'aura qu'un petit nombre de personnes conduisant l'architecture générale de votre projet.

1. Assurez-vous que les développeurs se voient attribuer des modules spécifiques.
2. Avoir un système de suivi des tâches / bogues qui suit chaque changement de refactorisation. Attribuer chaque problème à un seul développeur
3. Certains systèmes de contrôle de version ont la possibilité de verrouiller un fichier afin qu'un seul développeur puisse avoir des droits de mise à jour sur le fichier. Je n'ai jamais utilisé cette fonctionnalité mais si les développeurs se chevauchent constamment, c'est quelque chose que vous voudrez peut-être considérer.
4. Ayez des tests unitaires afin que même si les développeurs travaillent sur le même fichier, vous savez que leurs modifications ne cassent en aucune façon l'application.
5. Tout ce qui précède aiderait si votre refactoring est contenu dans des modules. Cependant, si quelqu'un effectue une refactorisation sur un problème transversal tel que la journalisation ou la sécurité, cela affectera de nombreux fichiers par définition. Celles-ci doivent être traitées avec soin, surtout si vous n'avez pas déjà profité des approches AOP.

Il existe / existait des systèmes de contrôle de version qui obligent les développeurs à extraire le code avant de pouvoir le modifier, mais ceux-ci ont leur propre ensemble de problèmes. La meilleure pratique consiste à faire en sorte que les développeurs s'engagent et mettent à jour souvent. Un développeur pourrait alors marquer une classe comme dépréciée et s'engager, puis si l'autre développeur se met à jour avant de commencer sa refactorisation, il verra l'intention.

La technologie ne peut pas résoudre les problèmes sociaux. Vous devez obliger vos développeurs à se parler et à coordonner leur travail. Avec 20 équipes, une structure et des règles seront essentielles. Vous voudrez les soutenir avec des solutions technologiques, mais les gens passent avant tout.

Si vous partez notice that someone else is working on the same piece of code and talk to the first one before modifying anything, selon ce que vous avez dit, vous avez besoin d'un système de contrôle de version (CVS / SVN / GIT). Je ne suis pas sûr cependant, mais si vous voulez l'inclure aussi, vous aurez besoin de choses avancées (une sorte de mécanisme de déclenchement / quelque chose de personnalisé peut-être).

Les développeurs qui verrouillent des fichiers dans le contrôle de code source devraient résoudre facilement votre problème, mais je pense que vous pourriez avoir de plus gros problèmes.

4,5 millions de LOC sont un énorme bac à sable dans lequel jouer, donc dans une solution bien conçue et architecturée, vous devriez rarement vous retrouver dans une situation où plusieurs équipes de développeurs se marchent les uns les autres. Le fait que cela se produise plus que par coïncidence est révélateur de graves défauts potentiels de conception qui devraient être examinés.

Quelques choses:

1. Modules séparés sur lesquels travailler
2. Parler des changements avant qu'ils ne soient effectués [avec tous les développeurs]
3. Tests unitaires [pour vérification et éviter les bris de choses liées]
4. Comme les autres l'ont mentionné, un VCS