Comment convaincre votre développeur camarade d'écrire de courtes méthodes?

https://stackoverflow.com/questions/881871

22-08-2019
|

Question

Méthodes longues sont mal pour plusieurs raisons:

Ils sont difficiles à comprendre
Ils sont difficiles à changer
Ils sont difficiles à réutiliser
Ils sont difficiles à tester
Ils ont une faible cohésion
Ils peuvent avoir élevé couplage
Ils ont tendance à être trop complexe

Comment convaincre votre collègue développeur d'écrire de courtes méthodes? (Armes sont interdites =)

La solution

Vous avez fait une liste des inconvénients. Essayez de faire une liste de ce que vous gagnerez en utilisant des méthodes courtes. Des exemples concrets. Ensuite, essayez de le convaincre à nouveau.

Autres conseils

Demandez-lui d'écrire des tests unitaires pour les méthodes.

Cela dépend de vos définitions de "court" et "long".

Quand j'entends quelqu'un dire « écrire de courtes méthodes », je réagis immédiatement mal parce que je l'ai rencontré trop de spaghettis écrits par des gens qui pensent la méthode idéale est de deux longues lignes: une ligne à faire la plus petite unité possible du travail suivi par une ligne d'appeler une autre méthode. (Vous dites que les méthodes longues sont mal parce que « ils sont difficiles à comprendre »? Essayez de marcher dans un projet où chaque action triviale génère une pile d'appel 50 méthodes en profondeur et en essayant de comprendre qui de ces 50 couches est celui que vous devez changer ...)

Par contre, si, par « court », vous voulez dire « autonome et limitée à une seule fonction conceptuelle », alors je suis pour. Mais rappelez-vous que ce ne peut pas être mesurée simplement par des lignes de code.

Et, comme tydok a fait remarquer, vous prenez plus de mouches avec du miel qu'avec du vinaigre. Essayez de leur dire pourquoi votre chemin est bon au lieu de pourquoi leur chemin est mauvais. Si vous pouvez le faire sans faire de comparaisons manifestes ou des références à eux ou à leurs pratiques (à moins qu'ils ne demandent spécifiquement comment vos idées se rapporter à quelque chose qu'ils font), ça va fonctionner encore mieux.

Je lis cette citation de quelque part:

Écrivez votre code comme si la personne qui doit le maintenir est un violent psychopathe, qui sait où vous habitez.

Dans mon expérience, la meilleure façon de convaincre un pair dans ces cas est par exemple. Il suffit de trouver des occasions de leur montrer votre code et de discuter avec eux les avantages de courtes fonctions par rapport aux fonctions longues. Finalement, ils réaliseront ce qui est mieux spontanément, sans qu'il soit nécessaire de les faire se sentir programmeurs « mauvais ».

Examens du code!

Je vous suggère d'essayer et obtenir des revues de code en cours. De cette façon, vous pourriez avoir un petit atelier sur les meilleures pratiques et quel que soit le formatage de votre entreprise à adhère librement. Cela ajoute le contexte que les méthodes courtes est un moyen de rendre le code plus lisible et plus facile à comprendre et aussi conforme à la SRP.

Si vous avez essayé d'expliquer la bonne conception et des gens ne reçoivent pas, ou sont tout simplement refusent de le faire, puis cesser d'essayer. Il ne vaut pas l'effort. Tout ce que vous aurez est un mauvais représentant pour vous-même. Certaines personnes sont sans espoir.

En fait ce qu'il revient à dire que certains programmeurs ne sont tout simplement pas fait pour le développement. Ils peuvent comprendre le code qui est déjà écrit, mais ils ne peuvent créer eux-mêmes.

Ces gens devraient être orientés vers un rôle de soutien, mais ils ne devraient pas être autorisés à travailler sur quelque chose de nouveau. Le soutien est un bon endroit pour voir beaucoup de code différent, peut-être après quelques années ils vont venir voir les avantages d'une bonne conception.

Je aime l'idée du Code avis que quelqu'un d'autre a suggéré. Ces programmeurs bâclée devraient non seulement leur propre code en revue, ils devraient assister à des critiques de bon code. Cela leur donnera une chance de voir ce bon code est. Peut-être qu'ils ont juste jamais vu du bon code.

Pour élargir la réponse de rvanider, effectuer l'analyse de la complexité cyclomatique sur le code a fait des merveilles pour attirer l'attention sur la question importante de la méthode; amener les gens à changer était encore dans les travaux quand je suis parti (trop d'élan vers les grandes méthodes).

Le point de basculement a été lorsque nous avons commencé à relier la complexité cyclomatique à la base de données de bogue. Un CC de plus de 20 qui n'était pas une usine a été assuré d'avoir plusieurs entrées dans la base de données de bogues et souvent ces bugs avait une « lignée » (fix Bug A cause Bug B, corriger Bug B causé Bug C, etc.). Nous avions en fait trois CC de plus de 100 (maximum de 275) et ces méthodes sont employées dans 40% des cas dans notre base de données bug - « vous savez, peut-être que 5000 la fonction de ligne n'est pas une bonne idée ... »

Il est plus évident dans le projet que je menais quand j'y ai commencé. L'objectif était de garder CC aussi bas que possible (97% avaient moins de 10) et le résultat final était un produit que je essentiellement cessé de soutenir parce que les 20 bogues que j'avais ne valaient pas la fixation.

logiciel BUGS ne va pas se produire en raison des courtes méthodes (et cela peut être un argument que vous devrez répondre), mais les corrections de bugs sont très rapides et sont souvent exempts d'effets secondaires lorsque vous travaillez avec des méthodes courtes et concises.

Bien que l'écriture des tests unitaires les guérirait probablement des méthodes longues, votre entreprise n'utilise probablement pas de tests unitaires. Rhétorique ne va si loin et travaille rarement sur les développeurs qui sont coincés dans leurs manières; leur montrer comment ces chiffres sur la création de logiciels méthodes plus de travail et buggy.

Trouver le bon mélange entre la longueur de la fonction et la simplicité peut être complexe. Essayez d'appliquer une mesure telle que complexité cyclomatique pour démontrer la difficulté maintenir le code dans sa forme actuelle. Rien ne vaut une mesure non-personnelle qui repose sur les facteurs de tests tels que le nombre de succursales et de décision.

Je ne sais pas où cette grande citation vient, mais:

« Debugging est deux fois plus dur que l'écriture du code en premier lieu. Par conséquent, si vous écrivez le code aussi intelligemment que possible, vous êtes, par définition, pas assez intelligent pour déboguer »

le forcer à lire le code complet par Steve McConnell. Dire que tout bon développeur doit lire.

lui Enivrez-vous? : -)

Le point sérieux à cette réponse est la question, « pourquoi dois-je écrire régulièrement de courtes fonctions, et me déteste quand je ne le fais pas? »

La raison est que j'ai du mal à comprendre le code complexe, être que les longues fonctions, des choses qui maintiennent et manipulent beaucoup d'état, ou ce genre de chose. J'ai remarqué il y a plusieurs années qu'il ya un bon nombre de gens là-bas qui sont beaucoup mieux à faire face à ce genre de complexité que je suis. Ironie du sort, il est probablement à cause de cela que je tends à être un meilleur programmeur que beaucoup d'entre eux. mes propres limites me forcer à affronter et nettoyer ce genre de code

Je suis désolé, je ne peux pas vraiment donner une vraie réponse, mais peut-être cela peut donner une idée pour nous aider à mener à une réponse.

Les forcer à lire le livre « code propre », il y a beaucoup d'autres, mais celui-ci est nouvelle, bonne et une lecture facile.

En leur demandant d'écrire des tests unitaires pour le code complexe est un bon moyen de prendre. Cette personne a besoin de voir pour lui-même ce que la dette que la complexité lors de l'exécution apporte la maintenance ou de l'analyse.

La question que je demande toujours à mon équipe est la suivante: « Il est 23 heures et vous devez lire ce code - pouvez-vous Comprenez-vous sous pression Pouvez-vous, par téléphone, pas de connexion à distance, les conduire à la section où? ils peuvent corriger une erreur? » Si la réponse est non, le suivi est « Pouvez-vous isoler une partie de la complexité? »

Si vous obtenez un argument en retour, il est une cause perdue. Jeter quelque chose alors.

Je leur donnerais 100 lignes de code tout sous 1 méthode, puis une autre 100 lignes de code divisé entre plusieurs méthodes et leur demander d'écrire une explication de ce que chacun fait.

Combien de temps il faut pour écrire les deux paragraphes et leur montrer le résultat.

... Assurez-vous de choisir le code qui prendra deux ou trois fois plus de temps pour comprendre si elle était sous un même méthode - Main () -

Rien ne vaut mieux que l'apprentissage par exemple.

court ou long sont des termes qui peuvent être interprétées différemment. Pour un court est une méthode 2 de la ligne alors que certains autres penseront que méthode sans plus de 100 lignes de code sont assez courts. Je pense qu'il serait préférable de dire qu'une seule méthode ne doit pas faire plus d'une chose en même temps, ce qui signifie qu'il ne devrait avoir une responsabilité. Peut-être que vous pourriez laisser vos collègues développeurs lire quelque chose sur la façon de mettre en pratique les principes solides.

Je normalement leur montrer les anciens projets qui ont des méthodes bien écrites. Je voudrais ensuite étape par ces méthodes tout en expliquant les raisons pour lesquelles nous les avons développées de cette façon.

Si tout va bien quand on regarde l'image plus grande, ils comprendraient les raisons derrière tout cela.

ps. En outre, cet exercice pourrait être utilisé dans conjuction comme un mini transfert de connaissances sur les projets plus anciens.

Montrez-lui combien il est facile de tester des méthodes courtes. Prouver que l'écriture des méthodes courtes sera plus facile et plus rapide pour lui d'écrire des tests pour ses méthodes (il est tester ces méthodes, non?)
Apportez lorsque vous examinez son code. "Cette méthode est assez longue, compliquée, et semble faire quatre choses distinctes. Méthode extract ici , ici et ici ."

Méthodes longues signifient généralement que le modèle d'objet est défectueux, à savoir une classe a trop de responsabilités. Il y a des chances que vous ne voulez pas seulement plus de fonctions, chacune plus courte, dans la même classe, mais les responsibilies correctement attribuées à différentes classes.

Ne pas utiliser l'enseignement d'un porc à chanter. Il gaspille votre temps et agace le porc.

Juste éclipser quelqu'un.

Quand il vient le temps de corriger un bug dans la routine de la ligne 5000, alors vous aurez une routine de dix lignes et une routine 4990 en ligne. Pour ce faire, lentement, et personne ne remarque un changement soudain, sauf que les choses commencent à travailler mieux et lentement la grosse boule de boue s'évapore.

Vous pouvez leur dire qu'il pourrait avoir une très bonne mémoire, mais vous n'avez pas. Certaines personnes sont capables de gérer des méthodes beaucoup plus que d'autres. Si vous avez tous les deux être en mesure de maintenir le code, il ne peut être fait si les méthodes sont plus petites.

Seulement faire s'il ne dispose pas d'un complexe de supériorité

[modifier] pourquoi est-ce collecte des scores négatifs?

Vous pouvez commencer refactorisation chaque méthode simple ils ont écrit dans plusieurs méthodes, même quand ils travaillent actuellement sur eux. Attribuer du temps supplémentaire à votre emploi du temps pour « refactoring d'autres méthodes de rendre le code maintanable ». Faites comme vous pensez qu'il devrait être fait, et - vient ici la partie éducative - quand ils se plaignent, dites-leur que vous n'auriez pas à factoriser les méthodes si elles auraient fait dès la première fois. De cette façon, votre patron apprend que vous devez corriger d'autres de lazyness et vos collègues apprennent qu'ils devraient le rendre différent.

C'est au moins une théorie.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow