Existe-t-il un moyen d’éviter le code spaghetti au fil des ans ?[fermé]

https://stackoverflow.com/questions/369683

21-08-2019
|

Question

J'ai eu plusieurs emplois en programmation.Chacun avec 20 à 50 développeurs, projet en cours sur 3 à 5 ans.

A chaque fois c'est pareil.Certains programmeurs sont brillants, d'autres sont moyens.Tout le monde a son diplôme CS, tout le monde lit les modèles de conception.Les intentions sont bonnes, les gens s'efforcent d'écrire du bon code, mais après quelques années, le code se transforme en spaghetti.Les modifications apportées au module A interrompent soudainement le module B.Il y a toujours ces parties de code que personne ne peut comprendre, sauf celui qui les a écrites.Changer l'infrastructure est impossible et les problèmes de compatibilité ascendante empêchent l'intégration de bonnes fonctionnalités.La moitié du temps, vous souhaitez simplement tout réécrire à partir de zéro.

Et les gens plus expérimentés que moi considèrent cela comme normal.Vraiment ?Est-ce que c'est obligé?Que puis-je faire pour éviter cela ou dois-je l’accepter comme une réalité de la vie ?

Modifier:Les gars, je suis impressionné par la quantité et la qualité des réponses ici.Ce site et sa communauté rock !

La solution

diligence Ruthless combinée à des tests unitaires constante est la seule façon d'empêcher le code spaghetti. Même alors, il est seulement une solution sparadrap. Dès que vous arrêtez de payer l'attention sur les pâtes vient.

Très souvent, je trouve que le code spaghetti est introduit parce que quelqu'un est tout simplement être paresseux plat ce jour-là. Ils savent qu'il ya une meilleure façon de le faire et n'ont tout simplement pas le temps. Quand vous voyez que cela se produise, il n'y a qu'une seule chose à faire.

Appelez-les sur et demandez-leur de changer

Je trouve que rappelant la meilleure façon lors d'une révision du code est généralement suffisant pour amener les gens d'aller. S'ils vérifient dans et je me sens fortement, je vais le Refactor moi-même.

Dois-je de temps en temps se détacher comme un peu excentrique? Je suis sûr que je fais. Franchement si je ne me dérange pas. Je ne suis pas un crétin à ce sujet et aborder cette question de la meilleure manière possible sociale. Cependant laisser mauvais code faire vérifier à peu près que assure que je vais devoir déboguer à un moment donné dans l'avenir. Je préfère prendre un peu Flak maintenant et obtenir le bon code dans.

Je pense aussi qu'une culture de tests unitaires contribue également à prévenir le code spaghetti. Il est beaucoup plus difficile de code spaghetti test unitaire qui code bien pris en compte. Au fil du temps cela oblige les gens à garder leur code un peu factoré.

Autres conseils

Je crois que la clé pour éviter la pourriture du code se trouve dans le fond sonore des méthodologies de conception et de mise en œuvre (je crois si fort que j'appelé mon entreprise - Pensez Bottom Up - après). ici les outils de choix sont les suivants:

Programmation par contrat
conception en couches
Mise au point sur le découplage
Toujours construire avec la réutilisation à l'esprit, la recherche de solutions génériques
Gardez les cadres légers, simple et concentré

Comme suggéré par d'autres répondants, vous devez prendre rapidement les problèmes. Avec les développeurs verts, cela signifie que le mentorat (programmation paire est grand ici) et avis (avis de code et de conception). Avec les développeurs plus hauts, cela signifie la vigilance.

La plupart de tous, ne pas avoir peur de refactoring. Si refactoring vous fait peur, vous êtes déjà sombré. Si refactoring est considéré comme « mauvais », alors il y a quelque chose de mal avec votre entreprise.

Lorsque vous corrigez quelque chose, corriger correctement. J'utilise le terme « fux » pour décrire une solution qui a été fait dans le mauvais sens. Juste « Fux » votre base de code

Cheers,

Dan

20 à 50 développeurs est probablement le problème. C'est assez élevé et aurait besoin de beaucoup de gestion et de ressources pour tout garder sous contrôle.

J'envisager de scinder le projet en segments plus petits réutilisables. Résumé certaines couches de distance à partir du système de base.

Créer un « pare-feu » entre les différentes zones du code. Vous faites cela en définissant les différentes zones ou des couches de code, et la définition d'une API unique (en Java, cela se fait généralement avec une interface) que chaque couche répond. Il devrait y avoir Intefaces os ou bare-classes qui l'API utilise, mais « savoir » rien sur le fonctionnement interne de ces couches. Par exemple, l'interface utilisateur graphique ne doit pas savoir ou de soins que vous stockez des données, et la base de données ne doit pas savoir ou de soins comment les données sont présentées à l'utilisateur final.

Ces API ne doivent pas être coulé dans le béton - vous devriez être en mesure d'ajouter des choses au besoin, aussi longtemps que vous assurez-vous ne pollue pas les pare-feu

Je pense que le point principal est quand tu dis

tu veux juste tout réécrire à partir de zéro

Acceptez-le simplement.
Utilisez autant de tests unitaires que possible, puis laissez le refactoring devenir une pratique courante.
Les tests automatisés et unitaires garantiront que les changements n'introduiront pas de régressions ;consacrer un certain pourcentage de votre temps à refactoriser l'ancien code (et cela signifie, moins de nouveautés!) assurez-vous que la base de code existante ne vieillira pas, ou du moins pas si vite.

Les examens du code, le codage des normes et des politiques fermes.

Ce qui suit est applicable à notre magasin - puisque je ne sais pas quel genre de magasin que vous avez, votre kilométrage peut varier. Tout en se déplaçant à Team Foundation Server, une grande partie de notre accent a été mis sur le maintien de la qualité du code - ou tout au moins aider à maintenir la qualité de quelque façon que possible. Voici quelques exemples de ce que nous ajoutons:

Flux de travail de révision du Code - Impose révision du code dans le cadre du processus. Contient une politique qui empêchera check-ins de se produire si le code n'a pas été revu.
TeamReview - rend le code examine moins douloureux en offrant une expérience complète "à l'intérieur du IDE"
Politiques Check-in (en général) - De nombreux goodies cool disponibles pour contrôler le flux de code. Des choses comme faire en sorte que les méthodes publiques et protégées sont documentées avant l'enregistrement pour faire en sorte que le travail ne peut être vérifiée dans sans un élément de travail correspondant.

Comme je l'ai dit, si vous utilisez une autre plate-forme, peut-être l'outillage disponible et ce que vous pouvez faire est différent. Mais ne règle pas l'outillage pour aider de toute manière possible. Si vous pouvez l'utiliser pour améliorer, le contrôle et l'audit de votre flux de travail et les éléments qui se déplacent à l'intérieur, il doit être au moins à considérer.

Rappelez-vous, tout changement dans le processus va impliquer repoussage. La façon dont nous avons contribué à alléger est de construire les politiques dans la formation pour la transition de notre ancien contrôle de version / système de suivi des défauts.

On dirait que beaucoup ne suivent pas certains principes de base de encapsualtion et une bonne conception.

Garder les choses isolées et unreliant sur d'autres parties est essentielle pour éviter le problème que vous décrivez. Vous pourriez avoir besoin de concepteur de niveau supérieur ou un architecte. Ceci est un scénario typique où les gens ont justifié certains processus draconienne et la gestion du changement. (Je ne préconise pas)

Vous devez éviter les dépendances et les interrelations et définir et utiliser des interfaces publiques seulement. Bien sûr, cela est une simplification excessive, mais vous apprendrez probablement beaucoup par certains paramètres sur votre code - la complexité des classes, méthodes publiques, des diagrammes UML construits à partir de l'ingénierie inverse du code, etc.

Je pense que le couplage lâche, vous pouvez obtenir avec l'utilisation entière de l'injection de dépendance est une caractéristique technique qui peut aider beaucoup. Lorsque vous séparez les morceaux de l'application que vous êtes moins susceptibles d'obtenir des spaghettis résultant de la réutilisation « intéressante ».

Vous pouvez se diriger vers une fragmentation excessive à la place, mais c'est une autre question et moins de problème structurel global.

Ne laissez pas le code à engager jusqu'à au moins deux paires d'yeux ont vu.

refactorisation

Efforcez-vous garder le design aussi propre que possible. Ce n'est pas facile, mais il vaut la peine.

Je ne pense pas que ce soit normal. Il est vraiment difficile de lutter contre cette chose quand il était là pendant quelques années.

La seule façon de l'éviter est de changer l'attitude:

« L'attitude que les développeurs agiles ont envers la conception du logiciel est la même attitude que les chirurgiens ont envers la procédure stérile. procédure est stérile, ce qui rend la chirurgie possible . Sans elle, le risque d'infection serait beaucoup trop élevé pour tolérer. Les développeurs Agile se sentent de la même façon sur leurs conceptions. Le risque de laisser même le plus minuscule peu de pourriture commencer est trop élevé pour tolérer « . Martin C. Robert « Principes Agile, modèles et pratiques en C # »

Je recommande fortement de regarder dans ce livre pour des conseils. Les noms de tout « conception odeurs », les raisons de leur existence et les conséquences de leur départ. Que cela vous aidera à persuader votre gestion que la situation actuelle ne convient pas.

Bonne chance!

Le plus gros problème dans l'industrie du logiciel est que la qualité du code de programmation est considérée comme une question subjective. Sans une certaine mesure bien définie, juste être propre et bien rangé, et en suivant les conventions ne suffit pas pour garantir que la qualité est acceptable.

Il y a des tentatives pour changer cette , mais ils sont peu susceptibles d'obtenir un intérêt suffisant ou l'acceptation principalement parce que la culture établie de longue date de programmeurs est très difficile d'essayer de rester loin de tout ce qui ressemble à l'ingénierie. Le « art pur » philosophie de programmation signifie que vos 20-50 développeurs vont tous flail le code dans leur propre mode unique, de sorte que peu importe la qualité des codeurs individuels, la somme totale de l'effort du groupe va toujours être « une grosse boule de boue ».

Pour éviter cela, obtenir tous les codeurs sur la même page », faire partie de code normalisé de votre convention, ou courir après des emplois ont été les équipes de développement sont plus petits (1-3 personnes) et vous êtes le grand Kahuna. Un jour les grandes équipes peuvent trouver un moyen de construire des choses mieux, mais jusque-là, même les meilleurs d'entre eux sont extrêmement chanceux s'ils peuvent tout simplement se rapprocher de 6 sur 10. Nous construisons des logiciels de mauvaise qualité parce que ce que nous avons mis en place notre industrie à faire ...

Paul.

Vous devez suivre les pratiques de développement de logiciels étroitement. Il doit y avoir des revues de code et tests unitaires qui font constastantly en sorte que les mises à jour touchent d'autres choses dans le système. 20 - 50 devs est beaucoup, mais il peut être fait. La mise en œuvre de bons processus est la seule chose qui vous sauvera dans cet environnement. Enforced normes de codage sont également essentielles.

le suivi des défauts et des performances des différentes parties du système vous permettra d'identifier les problèmes. Comme les systèmes sont modifiés fonctions mal conçus ou écrits ou modules auront un taux plus élevé de défauts. Lorsqu'un module « problème » est identifié une décision peut être de réécrire le module (PAS l'application).

continue refactoring. Vous Vous à refactorisons que vous allez, en particulier au niveau de la conception. Quand vous voyez le code cassé ou de la conception, soyez prêt à le fixer. Cela est souvent une affaire de fixer quelque chose qui est pas cassé, en soi. Sauf qu'il est ... il est tout simplement pas le manifester est brisement ... encore.

Non

Shore et Warden de L'art du développement Agile est un grand livre, avec une section sur « l'application de XP à un projet existant » (au chapitre 4). Les projets se aggravent au fil du temps à moins que vous combattez difficile: surmonter cette dette technique est difficile et il sera de plus en plus difficile à expédier les rejets acceptables. La seule solution est de réduire la vitesse à laquelle vous livrer de nouvelles fonctionnalités, et passer le gain de temps et d'améliorer la couverture refactoring test.

En général, les projets n'ont pas beaucoup de couverture de test, et n'ont pas la possibilité d'exécuter un script automatisé de 10 minutes qui va construire et d'exercer votre code assez bien. Au lieu de cela, la plupart du code est structuré de telle sorte qu'il est difficile de tester. La meilleure option est alors d'ajouter une couverture de test simple où vous pouvez, tout en commençant à factoriser en vue de rendre le code Abstraite tel qu'il est plus facile à tester.

Bien que l'équipe aura besoin de passer du temps en améliorant le code pour le rendre propre et testable vous ne serez probablement pas en mesure d'arrêter la livraison pour le temps qu'il faudrait « terminer » le nettoyage. Donc, vous devez le faire étape par étape, tout en ajoutant de nouvelles fonctionnalités. C'est d'accord, choisissez les zones les plus première, et ne vous attendez pas droit avantages évidents loin. Persévérez, parce que finalement vous allez y arriver. Ne pas écouter les voix qui disent tous les grands projets sont mauvais.

En bref, passer un peu de temps chaque semaine rangement, et assurez-vous que le code est mieux la semaine prochaine qu'il est cette semaine.

Plus de commentaires de code et peut-être la propriété de code.

Si vous pirater juste un code aléatoire, alors vous ne se soucient pas autant que pour le code « propre ». S'il est de votre responsabilité de maintenir un module du projet, vous voulez briller.

Et les revues de code est un moment où vous montrez votre code.

Commencer à créer des tests unitaires, cela vous aidera à découpler votre code et éviter les erreurs de suivi sur des corrections de bugs. Il vous avez une bonne couverture, il sera plus facile pour vous de supprimer le code utilisé ainsi.

Licencié sous: CC-BY-SA avec attribution

Non affilié à StackOverflow