En tant que développeur de logiciels, l'une de mes tâches principales est de garder la complexité sous contrôle.
Cependant, dans certains projets, il y a un moment où le niveau de complexité augmente si haut qu'il atteint une sorte de point de "non retour". Passé ce moment, vous ne pouvez jamais ramener le projet à un niveau de complexité acceptable en moins de temps que nécessaire pour tout réécrire à partir de zéro.
Ce moment particulier a-t-il un nom dans le dialecte des programmeurs (quelque chose de similaire à la loi de Godwin pour les trolls)?
--Éditer--
Désolé si je ne suis pas clair. Je ne pense pas que ce "moment" ait un nom officiel ou une métrique sérieuse. Je pensais à quelque chose dans l'esprit du "Ballmer peak" dans xkcd .
terminology
Thibault J
la source
la source
Réponses:
C'est plus une question de maintenabilité que de complexité.
Le phénomène est appelé «dette technique» et une fois qu'il atteint un niveau critique, le projet est sur le point de faire faillite.
C'est ce que vous vouliez dire?
la source
Le «point de complexité excessive» est désigné en anglais comme:
OH MON DIEU QU'EST-CE QUE CE CRAP.
Le problème est que cela peut s'appliquer à quelque chose qui est en fait simple, mais qui est mis en œuvre d'une manière si horrible que vous avez la même réaction.
Il peut donc être difficile de distinguer quelque chose de très complexe de quelque chose de très horrible.
CEPENDANT: Ce qui a tendance à arriver à tous les logiciels est un processus un peu comme ceci:
Étape 1: Avoir une belle spécification, faire une belle conception, mettre en œuvre de belles choses. Tout le monde est content.
À la fin de l'étape 1: les développeurs se félicitent de la merveilleuse élégance de leur conception et s'en vont heureux en pensant "J'ai un héritage merveilleux ici pour que d'autres ajoutent des choses à l'avenir, ce sera merveilleux et le monde sera un meilleur endroit."
Étape 2: Certaines modifications sont apportées, des choses sont ajoutées, de nouvelles fonctions sont incluses. L'architecture et la structure de l'étape 1 ont rendu ce processus assez indolore. [Mais oups, le "facteur de cruauté" a juste augmenté un peu.]
À la fin de l'étape 2: les développeurs se félicitent de la merveilleuse élégance de leur conception et s'en vont heureux en pensant "Gee, je suis tellement intelligent d'avoir fait toutes ces indemnités à l'étape 1. Cela s'est si bien passé. J'ai un merveilleux héritage ici pour que d'autres ajoutent des choses à l'avenir, ce sera merveilleux et le monde sera un meilleur endroit. "
Étape 3: Plus de modifications sont apportées, plus de choses sont ajoutées, plus de nouvelles fonctions, un tas de choses sont modifiées, les commentaires des utilisateurs sont réellement écoutés.
À la fin de l'étape 3: les développeurs se félicitent de la merveilleuse élégance de leur conception, et s'en vont assez heureux en pensant "Gee cette architecture est assez bonne pour permettre à tant de changements de s'insérer facilement. Mais je suis un peu mécontent à propos de X et Y et Z. Ils pourraient être nettoyés un peu maintenant. Mais !!! Ahhh !!! Je suis si intelligent d'avoir fait toutes ces allocations à l'étape 1. Cela s'est si bien passé. J'ai un merveilleux héritage ici pour d'autres à ajouter des choses à l'avenir, ce sera merveilleux et le monde sera un meilleur endroit. "
Étape 4: tout comme l'étape 3. Sauf:
À la fin de l'étape 4: les développeurs pensent: "Ce truc qui était si bon devient UGLY à entretenir. Il a vraiment besoin de changements sérieux. Je n'aime pas vraiment travailler là-dessus. Il a besoin de refactoring. Je me demande ce que le patron dira quand je lui dirai qu'il a besoin de 6 semaines et qu'il n'y aura rien à voir pour les utilisateurs à la fin de cela ... mais j'aurai encore 5 ans de portée de modification future délicieuse en faisant cela .... hmmm .. . le temps d'aller au pub pour un peu de bière. "
Étape 5: Un tas de modifications doivent être apportées.
Et PENDANT l'étape 5, les développeurs se disent: "Ce code est nul. Qui a écrit cela? Ils devraient être abattus. C'est horrible. Nous devons le RÉÉCRIRE."
L'étape 5 est fatale. C'est là que le facteur de cruauté est devenu si mauvais que le code ne peut pas simplement avoir quelques changements de plus, il doit avoir de gros changements.
Le problème à l'étape 5 est le désir de le jeter et de recommencer. La raison pour laquelle cela est fatal est "The Netscape Factor". Allez sur Google. Les entreprises meurent à ce stade, car recommencer signifie que vous commencez avec environ 50% d'hypothèses au lieu de faits, 150% d'enthousiasme au lieu de connaissances, 200% d'arrogance au lieu d'humilité ("Ces gars-là étaient tellement stupides!"). Et vous introduisez un tas de nouveaux bugs.
La meilleure chose à faire est de refactoriser. Changez un peu à la fois. Si l'architecture se fatigue un peu, corrigez-la. Ajoutez, étendez, améliorez. Progressivement. À chaque étape du parcours, testez, testez et testez encore plus. Des changements incrémentiels comme celui-ci signifient que 10 ans plus tard, le code actuel et original est comme une hache de grand-père ("il avait 10 nouvelles têtes et 3 nouvelles poignées mais c'est toujours une hache de grand-père"). En d'autres termes, il ne reste pas grand-chose en commun. Mais vous êtes passé de l'ancien au nouveau progressivement et avec soin. Cela réduit les risques, et pour les clients, cela réduit le facteur d'énervement.
la source
Je suis d'accord que le moment est difficile à reconnaître et peut être évité par des processus appropriés. Cependant, la question était de savoir comment l'appeler. En économie réelle, il y a le concept de «rendements décroissants»: le point auquel l'augmentation des intrants pour une ressource dans un processus diminue votre profit global par unité. Cela s'applique certainement au codage, et même de bonnes choses comme l'abstraction, la réutilisation, etc. ont un tel point de rendements décroissants. Le terme général spécifique à la programmation est "ingénierie excessive". Pour quelqu'un qui est enclin à faire cela, j'aime le terme de Joel " astronaute d'architecture ".
la source
Trop souvent, un bon code est jeté sous la fausse impression que la nouvelle équipe avec de nouveaux outils peut le faire moins cher, plus rapidement avec plus de fiabilité, pour constater que
Peut-être que le temps que vous avez décrit arrive avec des bases de code (je le pensais auparavant). Je n'ai jamais personnellement expérimenté un cas d'ancien code provoquant un projet de ventre ou de code réécrit en enregistrant un projet.
Je n'inclus pas dans ce cas où des mesures ont été utilisées pour identifier des modules ou des conceptions problématiques spécifiques, qui ont ensuite été éliminés et remplacés.
la source
Le vrai problème avec ce "moment" théorique est qu'il n'est reconnu qu'après coup. À moins que vos collègues ne soient des psychopathes, chaque engagement dans la base de code se fait avec la conviction que c'est une amélioration de cette base de code. C'est seulement en regardant le désordre qui s'ensuit que vous pouvez voir que vous avez passé ce "moment".
Mais j'aime qu'on puisse lui donner un nom. "Messieurs", pourriez-vous dire, en attirant vos collègues développeurs autour de vous, "Nous avons traversé la maintenabilité Hellespont. Envoyez un SMS à votre femme et dites-lui que vous ne la verrez pas avant un moment."
la source
Je ne sais pas s'il y a un nom mais s'il n'y en a pas je proposerais de l'appeler "point de fusion"
la source
Ce n'est pas une question très intéressante.
En effet, c'est trivial.
C'est tellement trivial que nous avons évolué de nombreuses façons de faire face.
Méthodologies de cascade. Beaucoup de gens passent beaucoup de temps à examiner les exigences et à concevoir des documents pour être sûr que la complexité est gérée.
Méthodologies Agiles. Moins de gens passent moins de temps à discuter de ce qui est immédiatement applicable pour résoudre le problème de quelqu'un et leur proposer un logiciel. La complexité est gérée parce que tout le monde se concentre sur la sortie de quelque chose.
La seule fois où quelqu'un se débat avec la «complexité», c'est parce qu'il n'a pas suivi la méthodologie et géré correctement son temps.
Pas de supervision détaillée dans une méthodologie de cascade. Ils ne sont pas obligés d'examiner les produits de travail intermédiaires au niveau des exigences, de l'architecture, de la conception de haut niveau ou des revues de conception détaillées.
Pas de délai de sprint ou de priorités de cas d'utilisation dans une méthodologie Agile. Ils ne se concentrent pas sur la diffusion de quelque chose à l'utilisateur le plus rapidement possible.
La complexité doit être limitée en fixant des objectifs.
Lutter contre la complexité signifie que les objectifs ne sont pas fixés ou ne sont pas récompensés correctement.
Il n'y a pas de "tournant". Si la gestion de la complexité est en quelque sorte un problème, quelque chose ne va déjà pas sur le plan organisationnel.
la source
Il existe des méthodes pour visualiser et surveiller le risque d'augmenter la complexité des (gros) projets et du code. Quand ils sont appliqués avec un peu de chance, un nouveau nom pour le point de non-retour n'est pas nécessaire. (Il existe un MOOC associé sur openHPI: https://open.hpi.de/courses/softwareanalytics2015/ )
La complexité structurelle est un problème de conception général - pas seulement pour la conception de logiciels dans de grandes équipes. La visualisation est la première étape de la gestion de la complexité structurelle. Des matrices et des graphiques dirigés peuvent également être utilisés à cette fin.
Les quelques méthodes pour réduire la complexité structurelle sont http://www.buch.de/shop/home/suche/?fq=3540878890 :
En outre, il existe le concept de conception axiomatique: https: \ en.wikipedia.org \ wiki \ Axiomatic_design \ Avec ce concept, les problèmes de fiabilité dus à une complexité inutile peuvent être évités.
Il existe donc un tas de méthodes disponibles. En fin de compte, il s'agit toujours de la décision d'y penser parce qu'un projet devient suffisamment grand.
la source