Dans quelle mesure éliminez-vous la Duplication de Code? [fermé]

j'ai toujours respecté le principe que la première duplication (original et une copie) n'est généralement pas la peine de l'enlever. C'est parce que l'original plus une copie est probablement un "one off", et vous ne gagnez pas assez de les enlever pour justifier le travail.

cependant, dès que je commence à faire une deuxième copie, je réécris alors les trois pour supprimer la duplication. C'est parce qu'il est maintenant (à mon avis) passé de "One off" à "trend". Il devient plus probable que je vais utiliser le code à nouveau de sorte que l'effort pour supprimer les doublons en vaut maintenant la peine.

j'hésite à appeler le processus "refactoring", parce que c'est un mot à la mode du camp XP, et je le faisais au début des années 80 avec FORTRAN et C.

Bon en programmation, est intemporelle (et généralement à la mode-moins, aussi).

Cheers,

- Richard

éviter de fractionner le code lorsque les paramètres de configuration (nécessaires pour modifier le comportement) obstruent l'intention du code. Va aussi loin que tu peux avant d'atteindre ce point ... mais c'est un acte d'équilibrage.

comme on l'a dit, j'essaie de vivre selon le principe "à sec" - mais je dirais aussi qu'il y a une autre condition où je suis souvent réticent à éliminer la duplication:

• ne modifiez pas le code pour lequel vous n'avez pas (ou ne pouvez pas développer économiquement/pratiquement) un test unitaire.

cette série d'essais inclurait le code appelant pour toute méthode extraite.

si Je ne peux pas tester Je ne peux pas vraiment dire que je n'ai pas introduit de défaut. Avec une suite de test, je peux au moins dire qu'il a fait ce qu'il utilisé pour.

je me considère comme un fanatique extrême quand il s'agit d'éliminer la duplication de code. Tant que nous ne sommes pas à un point critique d'un jalon, je fais de mon mieux pour supprimer tout code dupliqué que je rencontre dans mon code. Finalement, je suis à court de temps et je dois laisser le code pour la prochaine étape. Dans ce cas, cependant, je vérifie souvent au moins un commentaire en notant la duplication et ce qui doit être fait pour la supprimer.

j'essaie toujours de penser d'abord pourquoi ce code est dupliqué. La plupart du temps, la réponse est lazyness/ignorance/etc, et je repense. Mais, de temps en temps, le cas où la duplication est réellement valide apparaît. Ce que je parle ici est deux morceaux de code qui sont sémantiquement sans rapport, mais juste arriver pour avoir la même (ou similaire) mise en œuvre à l'heure actuelle . Considérons par exemple de règles métier pour complètement processus non liés (réels). Les règles peuvent être égales un jour, et le lendemain l'une d'elles change. Vous feriez mieux d'espérer qu'ils ne sont pas représentés par le même morceau de code, ou prier que le développeur faisant la modification peut repérer ce qui se passe (tests unitaires, n'importe qui?)).

on y travaille. Il est vraiment utile d'avoir un outil qui détecte une telle duplication; indépendamment des meilleures intentions, cela se produit parce qu'on ne pense pas, ou il ya un calendrier serré, etc.

Le CloneDR conclut code en double, à la fois des copies exactes et les quasi-accidents, à l'échelle de grands systèmes sources, paramétré par la langue de la syntaxe. Il supporte Java, C#, COBOL, C++, PHP et beaucoup d'autres langues. Nous l'utilisons nous-mêmes pour gérer notre propre code.

j'avais l'habitude d'être assez laisser - faire à ce sujet-évidemment essayer d'éviter la duplication là où jamais possible, mais si vous avez besoin de simplement copier les 15 lignes occasionnelles de code d'ici à là pour sauver le remaniement d'un après-midi, ce n'est probablement pas grave tant que vous ne faites pas une habitude de lui.

Puis j'ai commencé mon travail actuel.

le gars qui a écrit la plupart de cette base de données avant moi a pris la ligne "l'optimisation prématurée est la racine de tout le mal" extrême ridicule. Exemple: il y avait au moins cinq endroits différents dans l'application que le calcul de la taille d'une vignette d'une téléchargés graphique. Cela semblait être le genre de chose que je pouvais rationaliser, jusqu'à ce que je réalise que les vignettes des 5 "chemins" étaient affichées sur le même écran - et chaque fonction faisait le calcul d'une manière légèrement différente, et obtenait des résultats légèrement différents. Ils avaient tous commencé sous forme de Copy-pâtes, mais avaient chacun été rodés sur plus d'un an ou plus jusqu'à ce que nous obtenions à l'endroit où je l'ai trouvé.

donc, tout a été refactorisé. Et maintenant, je suis un fanatique de la suppression de dupe.

I"m à peu près un psycho à ce sujet. Si je fais quelque chose plus d'une fois je refactoriser. période. point d'exclamation.

la duplication de Code peut rapidement vous mordre dans le derrière et vous causer beaucoup de douleur. Si je vois le code dupliqué (habituellement ancien code d'autres personnes bien sûr;) j'essaie de le reformuler immédiatement. Il est très rare que cela n'en vaille pas la peine. Passer le temps ou vous passerez plus de temps à le faire plus tard.

je le considère comme l'indicateur le plus important d'un bon programmeur. Si vous pouvez écrire du code entièrement factorisé -- alors presque par définition c'est du bon code.

il semble que presque toutes les autres pratiques de programmation sont juste des moyens d'obtenir votre code sec.

C'est un peu exagéré, mais pas trop. Entre être sec et rendre vos interfaces aussi stables et minimales que possible (séparation des préoccupations) vous êtes sur le point d'être un ingénieur logiciel réel et pas un programmeur / Hacker..

très. En ce qui me concerne, presque tous nos conseils, énoncés et "meilleures pratiques" découlent du principe de ne pas répéter le code et de le rendre réutilisable. MVC, decorator, OOP etc.

évidemment, il faut parfois garder le sens du pragmatisme, mais j'ai tendance à me pencher très fortement vers le sec.

j'étais assez fanatique pour commencer, mais une expérience récente m'a probablement rendu plus, et m'a donné un autre ensemble d'outils à utiliser. Plus précisément, les algorithmes / concepts de la bioinformatique. Dans un nouveau poste, Nous sommes en train de mettre à jour L'interface utilisateur web pour utiliser une mise en page pilotée par CSS au lieu de tables, donc j'analyse 700 fichiers JSP existants. J'ai mis toutes les lignes de code dans une base de données et sur un total de 100k De lignes, moins de 20K étaient uniques. Puis je représente chaque fichier comme une séquence d'ID de ligne, et de trouver les suites communes de 2 lignes ou plus; la plus longue était presque 300 lignes dupliquées entre un couple de fichiers JSP, et cas flagrant de coupe et passé. C'est là que j'en suis maintenant, mais mon prochain plan est de représenter les fichiers comme une séquence de line_id ou de subsequence_id (commun), de les trier, puis d'effectuer une comparaison Levenshtein de fichiers contigus les uns aux autres dans l'ordre de tri. Cela devrait aider à la correspondance floue des dossiers qui ne contiennent pas seulement des subsequences communes, mais de sous-séquences sont un par un et.

je suis un grand partisan du codage à sec. Ne Vous Répétez pas. Si vous n'avez plus d'une fois, le mettre dans une classe d'assistance.

il y a très peu de choses qui sont pires que de devoir se rappeler d'apporter des changements à la même chose à plusieurs endroits.

comme mentionné dans la question réécrire ou réparer , vous pourriez effectuer certains remaniements comme la suppression de code de duplication de temps en temps, comme vous les détectez.

mais je crois que ce genre d'action "réécrire" est mieux géré lorsqu'il est détecté par un métrique , à partir d'un outil d'analyse statique du code , qui:

• détecte ces codes doubles
• souligne une tendance (comme de plus en plus de code dupliqué tend à être détecté)

dans ce cas, une action corrective peut être priorisée, pour se concentrer sur ce genre de remaniement.

à la réflexion, je me demande si Je ne suis pas le QA guy Zig se réfère à; -)

puisque la duplication prête à copier-coller, j'essaie toujours d'éviter la duplication ou le remaniement là où il y a déjà duplication dans le code existant.

normaliser le code, normaliser les variables, normaliser la base de données, normaliser la hiérarchie ministérielle, normaliser le gouvernement...

je suis parfois coupable de copier-coller, mais j'essaie d'éliminer la duplication partout où c'est possible. L'exception est quand j'ai une fonction qui appelle plusieurs autres fonctions et est très lente. Parfois le contenu des sous-fonctions peut être combiné pour la vitesse, ou les requêtes SQL sous-jacentes peuvent être combinées en moins ou juste une.

exemple: Dans la gestion des stocks, la quantité minimale disponible pour un article est égale à la quantité dans votre réserve de travail plus la quantité en stock de sécurité. Le stock de sécurité est égal à la moitié du travail de réserve.

Function workingReserve(itemCode, someDate)
     ' Inside here is a looping structure that adds up the requirements for the next six weeks (because that's how long it takes between reorder and receipt).
End Function

Function safetyStock(itemCode, someDate)
    safetyStock = workingReserve(itemCode, someDate) / 2
End Function

Function minimumOnHand(itemCode, someDate)
    minimumOnHand = workingReserve(itemCode, someDate) + safetyStock(itemCode, someDate)
End Function

Je m'excuse que cela soit écrit en VB, mais c'est à partir D'une fonction VBA Excel.

en effet, la fonction de réserve de travail tourne deux fois sur les mêmes données. La performance peut être améliorée en combinant la logique d'affaires de la fonction safetyStock() dans la fonction minimumOnHand ().

Function minimumOnHand(itemCode, someDate)
    minimumOnHand = workingReserve(itemCode, someDate) * 1.5
End Function

dans le vrai code, j'ai commentaires dans le code expliquant la logique commerciale, mais les ont omis ici pour la brièveté.