La possession d'un code individuel est-elle importante? [fermé]

Je suis en train de me disputer avec certains de mes collègues pour savoir si la possession par l’équipe de la base de code entière est préférable à la propriété individuelle de ses composants.

Je suis un grand partisan d’assigner à chaque membre de l’équipe une part à peu près égale de la base de code. Il permet aux utilisateurs d’être fiers de leur création, donne aux agents de contrôle des bogues un premier lieu évident pour attribuer les tickets entrants et contribue à atténuer le "syndrome de fenêtre brisée".

Il concentre également la connaissance de fonctionnalités spécifiques avec un (ou deux) membre de l'équipe, ce qui facilite grandement la résolution des bugs.

Surtout, il donne le dernier mot sur les décisions majeures avec une personne qui a beaucoup d’informations à la place d’un comité.

Je ne préconise pas l'exigence d'une autorisation si quelqu'un d'autre souhaite modifier votre code; Peut-être que la révision du code sera toujours faite au propriétaire, bien sûr. Je ne suggère pas non plus de construire des silos de connaissances: il ne devrait y avoir aucune exclusivité dans cette propriété.

Mais lorsque j'ai suggéré cela à mes collègues, j'ai eu une tonne de réactions, certainement beaucoup plus que ce à quoi je m'attendais.

Je demande donc à la communauté: quelle est votre opinion sur le travail en équipe sur une base de code volumineuse? Y at-il quelque chose qui me manque dans le maintien vigilant de la propriété collective?

Je crois que la propriété d'une équipe est beaucoup plus bénéfique à long terme.

Il vous suffit de regarder les 2 scénarios suivants pour comprendre pourquoi la concentration des connaissances sur un nombre minimal de personnes est loin d'être idéale:

• Un membre de l'équipe rencontre un malheureux accident
• Un membre de l'équipe rencontre de meilleures opportunités d'emploi

Naturellement, les personnes qui rédigent des sections particulières en auront une meilleure connaissance, mais ne cédez pas à la tentation de les transformer en un seul silo de connaissances. Les silos vous donneront des gains à court terme par des douleurs à long terme.

Le fait que vous n'ayez pas la propriété individuelle des sections de code, depuis que vous l'avez écrit, ne signifie pas que vous n'aurez toujours pas l'aspect "fierté de votre création", etc. diminuer tout sentiment personnel de propriété du code écrit.

En fin de compte, l’équipe possède le code. Mais pour toutes les raisons que vous avez mentionnées, nous avons désigné des auteurs individuels pour des parties spécifiques du code. Chaque auteur a la responsabilité principale de sa partie du code et secondaire la base de code dans son ensemble.

Si un problème survient avec une partie de la base du code, j'essaie de revenir à la personne qui a initialement écrit le code pour un correctif. Bien entendu, rien n'empêche les autres membres de l'équipe d'appliquer un correctif; Tous les membres de l'équipe sont censés connaître le code de chacun. Mais nous essayons toujours d’avoir d’abord une solution de l’auteur original. Après tout, ils ont écrit le code; ils sont le plus au courant.

J'ai travaillé dans des environnements d'équipes où, comme les gens ne sentaient pas qu'ils étaient propriétaires de ce qu'ils écrivaient, ils n'étaient pas obligés d'écrire un excellent code, mais simplement du code moyen.

Bien que je convienne, du point de vue des entreprises, de raisons pour diffuser les connaissances sur le produit; la réalité est qu’une personne concentrant ses efforts sur un domaine donné de toute chose deviendra au fil du temps beaucoup plus versé dans ce domaine.

Ignorer cela, c'est ignorer la science. Le cerveau est malheureusement incapable de retenir tout ce qu'il rencontre. Il rappelle ce qui est valable et valable à un moment donné, même si le stockage diminue avec le temps.

J'aurais tendance à être d'accord avec vous sur le fait que la propriété d'un module ou d'un compartiment spécifique au sein de la base de code plus large produira généralement de meilleurs résultats. Est-ce que quelqu'un qui part sans préavis peut nuire au succès? Certainement. Cependant, il est naïf de prétendre que tout le monde au sein de l'équipe devrait avoir la même connaissance en ce qui concerne la base de code; il ne fait rien pour améliorer le code; il tente de protéger le code. Protéger le code est le rôle de l'entreprise pour des raisons évidentes. La longueur des efforts déployés par une entreprise pour protéger le code peut souvent être préjudiciable.

Vous ne vous assurez pas que tous les joueurs de votre équipe peuvent jouer le quarterback, n'est-ce pas? Je dirais que s’assurer que tous les membres de l’équipe ont des intérêts dans la base de code va dans le même sens que d’essayer d’amener chaque joueur de votre équipe à jouer le quarterback à un niveau satisfaisant… ça ne donne rien. Avez-vous des sauvegardes? Bien sûr que oui ... mais les membres de l'équipe doivent avoir une identité au sein de l'équipe. Croire que tout le monde est pareil, c'est demander une douleur différente…

Je ne sais pas si la possession d' un code individuel est une bonne idée. Du moins pas dans le sens où les gens peuvent dire "Ceci est mon code, et je ferai ce que je veux avec". Peut-être est-il préférable de dire que vous devriez avoir une gestion de code individuelle : le code devrait appartenir à l'équipe, mais il y a une personne en particulier à qui l'équipe délègue la responsabilité et l'autorité.

La raison en est que si c'est la responsabilité de tous, alors ce n'est la responsabilité de personne.

J'épouserais la propriété d'une équipe sur une personne pour les raisons suivantes:

• Cohérence du code sur l'ensemble du projet
• Favorise la discussion sur le code, ce qui conduit toujours à des solutions meilleures et mieux contrôlées
• Si un membre de l'équipe est malade (ou pire), toute une section de code n'est pas sujette à des retards
• Les membres de l'équipe peuvent travailler sur toutes les parties du projet, ce qui permet d'intégrer la révision du code dans le processus de développement.

La spécialisation est acceptable - pour une grande base de code, cela peut, à long terme, faire gagner un peu de temps de communication - mais la propriété ne l’est pas.

Ce que je veux dire, c’est que l’attitude devrait être que l’ équipe a un bogue, et personne ne devrait dire que "oh, seul X peut toucher ce code, donc ce n’est pas mon problème". Si vous faites partie de l'équipe, il est également de votre responsabilité de corriger les bugs dans la base de code entière si vous le pouvez et de le faire correctement. La personne X peut être le meilleur choix pour le faire, mais on devrait s’attendre à ce que tout le monde le fasse s’il le fallait. Cela nécessite naturellement que le code soit écrit d'une manière qui permette et invite les membres de l'équipe à travailler avec. Avoir un code grossier interdira cela, alors efforcez-vous d'obtenir un code clair et cristallin, car cela permet à la plupart des développeurs de travailler avec. Vous voudrez peut-être procéder à un examen par les pairs pour que cela continue .

Je ne suis pas d'accord avec vous: la propriété d'équipe d'une base de code est une bien meilleure option que la propriété individuelle.

L’inconvénient évident de la propriété individuelle est que, si quelque chose arrive à un employé (licenciement, retraite, malade, etc.) , il faut un peu de temps avant que quelqu'un écrive un code vraiment propre pour adopter le code de ce dernier. code, surtout s’ils doivent également gérer leur propre code.

Ce sont aussi trop d'outils qui facilitent la propriété d'équipe. Les révisions de code, le contrôle de source - ce sont des choses qui encouragent l'implication de l'équipe dans toute la base du code En outre, comment attribuez-vous une partie particulière d'une base de code à une seule personne? Dites-vous simplement que seule cette personne peut modifier ce fichier?

Enfin, je pense que si une partie d’une base de code tombe en panne, il est trop facile de blâmer la personne qui en était responsable et cela ne fait que créer plus de problèmes.

Je pense que vous avez besoin des deux, car il existe une tension entre les deux approches.

Si pour un élément de code, une seule personne peut travailler dessus, c'est vraiment mauvais à long terme pour l'entreprise, surtout si / cela augmente, car chaque développeur devient un point d'échec. D'autre part, la propriété de code individuel (espérons-le) permet un délai de livraison plus court, car le développeur préfère généralement cette approche (incitation), car le développeur connaît très bien le code, etc. ... Il y a aussi un problème de temps: cela devrait être possible. Réaffecter les développeurs à des projets spécifiques en fonction des besoins de l'entreprise, mais si vous le faites quotidiennement, c'est horrible (ne serait-ce que parce que les développeurs le détestent, mais aussi parce que le coût de la commutation est tout simplement trop lourd et que vous passez le plus clair de votre temps rien).

OMI, un des rôles du responsable est de trouver un bon équilibre entre les deux. La révision du code, les normes de codage, la normalisation d’un ensemble d’outils devraient également contribuer à réduire le problème de défaillance. Après tout, l’essentiel du code maintenable est de s’attaquer à ce problème.

Je pense que la possession collective de code est incomparablement meilleure que la possession de code individuel.

Je ne suis pas si dérangé par l'argument du camion: dans un modèle de propriété individuelle, la perte d'un propriétaire coûte cher en temps, mais il est assez rare que le coût amorti soit faible.

Je pense plutôt que la propriété collective de code conduit directement à un code de haute qualité. Ceci pour deux raisons très simples. Premièrement, parce que la triste vérité est que certains de vos programmeurs ne sont pas aussi bons que les autres, et s’ils possèdent du code, ce code sera mauvais; le donner à vos meilleurs programmeurs l’améliorera. Deuxièmement, la révision du code: si tout le monde est propriétaire du code, tout le monde peut le réviser et l’améliorer; Même les bons programmeurs écrivent un code sous-pair s'ils sont livrés à eux-mêmes.

Je dis cela basé sur l'expérience dans mon projet actuel. Notre objectif est de pratiquer la propriété collective, mais certaines parties du système sont devenues spécialisées. Un autre type et moi-même sommes de facto propriétaires du système de construction. Par exemple, il y a un type qui effectue l'essentiel du travail sur les flux de données entrants. , un autre gars travaillant sur l’importation d’images, et ainsi de suite. Dans plusieurs de ces domaines (en particulier, je dois l'avouer, dans ma région!), La qualité du code en a sérieusement souffert - il y a des erreurs, des idées fausses, des critiques et des bidouilles qui ne survivraient tout simplement pas à l'attention des autres membres de l'équipe.

Je remarque que vous pourriez tirer parti des avantages de la propriété collective de code en ayant une propriété individuelle où la propriété d'un morceau de code particulier passe régulièrement entre différents programmeurs (par exemple, tous les trois mois, ou chaque version, voire même à chaque fois?) . Un équivalent de programmation de la rotation des cultures. Cela pourrait être amusant. Je ne vais pas essayer moi-même, cependant.

Je ne pense pas que la propriété de code d'équipe soit aussi importante que d'avoir plusieurs contributeurs comprendre l'architecture de base des sous-systèmes en vigueur.

Par exemple, quelques membres de notre équipe créent des pages Web administratives pour nos produits de serveurs. Nous avons construit un moteur de script personnalisé côté serveur afin de pouvoir utiliser les fonctions C essentielles du serveur directement à partir de nos scripts Java ou HTML. Je pense qu'il est plus important que nos gars du "web" comprennent comment utiliser ce moteur, par opposition à la copropriété des applications de page Web de chacun.

Je pense que vous prenez la propriété individuelle du code au moment de l'écrire, puis que vous le remettez à l'équipe. De cette façon, tout le monde prend ses responsabilités et contribue. Tout le monde devrait vouloir réparer un échec de codage qu'ils ont créé. Avec une révision du code, cela crée des normes plus élevées. Personne ne veut le travail de nettoyage après les autres.

Pensez plus de responsabilité et moins de propriété. Après tout, celui qui écrit les chèques est de toute façon le véritable propriétaire.

Jim, je suis avec vous à ce sujet à 100%. Je suis au beau milieu de la même bataille sur mon lieu de travail - c'est pourquoi je suis tombé par hasard sur votre question.

La façon dont je vois les choses est: "quand tout le monde le possède, personne ne le possède".

Pour moi, il n'y a pas de facteur plus important pour la qualité du code que la propriété et la responsabilité.

Des exemples tirés de la vie réelle illustrent bien cela. qui prendrais-tu mieux en charge: ta pelouse privée ou le parc de la communauté? Assez évident.

En passant, cela ne doit pas forcément être échangé pour une "flexibilité d'équipe". Cela signifie simplement que quand une personne possède quelque chose, elle la possède - et ne serait-ce que pour la journée.

Pour moi, cela dépend de la dynamique de votre équipe.

Par exemple, si vous avez une équipe qui n'est pas unifiée par les normes, les évaluations par les pairs, les tests méthodiques ou si vous avez une équipe dont les niveaux de compétence varient énormément d'un membre à l'autre, il peut être judicieux de rechercher une notion plus forte de propriété du code. avec un état d'esprit modulaire plus black-box.

Si vous ne le faites pas, par exemple, votre interface soigneusement conçue et conforme aux principes de SOLID pourrait rapidement être ruinée par une personne qui ne connaît même pas le mot "SOLID" et qui veut ajouter de nouvelles fonctions éclectiques à l'interface pour plus de commodité, par exemple: C'est de loin le pire.

Vous pouvez également traiter avec des collègues bâclés dont l'idée de corriger un bogue consiste à résoudre le symptôme sans comprendre le problème fondamental (ex: essayer de répondre à un rapport d'incident en insérant simplement des solutions de contournement dans le code uniquement pour masquer le bogue et transférer le message mortel. effets secondaires à quelqu'un d'autre). Dans ce cas, le sabotage de la conception d’interface n’est pas aussi grave et vous pouvez protéger vos intentions avec des tests unitaires soigneusement construits.

La solution idéale consiste à resserrer votre équipe au point de rendre cette notion de propriété et de propriété moins importante. L'évaluation par les pairs ne concerne pas seulement l'amélioration de la qualité du code, mais également celle du travail en équipe. Les normes ne concernent pas uniquement la cohérence, elles améliorent le travail d'équipe.

Pourtant, il existe des scénarios dans lesquels l'examen par les pairs et la conformité de tous à une norme est sans espoir et suscitera de nombreuses critiques désespérément inexpérimentées. Je dirais que le fait que la propriété de code ou la propriété d’équipe soit une priorité plus forte dépendra en grande partie de la capacité de votre équipe à effectuer une évaluation par les pairs efficace et à laisser tous ceux qui sortent comme ils en ont bénéficié (à la fois en termes de révision et se rapprocher dans la mentalité et les normes en conséquence). Dans les grandes équipes, lâches et / ou disparates, cela peut sembler sans espoir. Si votre équipe peut fonctionner comme une "équipe" où vous pouvez à peine dire qui a écrit quoi, alors l'unique propriétaire commencera à ressembler à une idée stupide.

Dans ce type de scénario loin d'être idéal, cette notion de propriété de code peut en fait aider. Il essaie de compenser le pire des scénarios, mais cela peut être utile si le travail en équipe est généralement sans espoir de placer une clôture autour du code d'un auteur. Dans ce cas, le travail d'équipe diminue, mais cela peut être mieux si le "travail d'équipe" ne conduit qu'à un pas en avant.