Il semble beaucoup de fois sur stackoverflow, que les gens (les programmeurs en particulier) ont tendance à trop compliquer une solution à un problème où la solution est beaucoup plus compliquée que le problème d'origine? Je ne suis en aucun cas un expert, mais beaucoup de fois j'essaie de choisir la solution la plus simple qui fonctionne (et évidemment cela ne fonctionne pas PARTOUT) mais j'ai eu un assez bon succès en suggérant des solutions simples sur le tas que les gens semblent ignorer pour des solutions BEAUCOUP plus compliquées?

Est-ce que c'est comme une chose normale pour les programmeurs ..... ou est-ce que je ne pense pas dans la bonne perspective.

De toute évidence, certains programmeurs sont impatients de montrer à quel point ils sont intelligents en créant du code incroyablement compliqué que personne ne peut comprendre. D'autres programmeurs tirent à un niveau si élevé que la complication des solutions est une évolution naturelle.

Le pire code que j'ai jamais vu était une méthode qui contenait plus de 2000 lignes de code. Sans doute, ce code était complexe, mais il était également très pauvre.

Je pense qu'un bon programmeur évite le code trop compliqué. Cela implique d'éviter la tentation de forcer un modèle de conception à s'intégrer dans une solution qui n'en a pas vraiment besoin. Cela inclut également d'éviter les objets divins, les boutons magiques, l'optimisation prématurée, la généralisation prématurée et d'autres anti-modèles.

Je refactorise constamment et cherche des opportunités pour simplifier mes solutions car la croissance de la complexité est une chose organique. Comme beaucoup d'autres choses organiques, il doit être taillé et taillé si nous voulons qu'il continue à être utilisable. Je déteste devoir interagir avec des solutions trop compliquées car avec une complexité accrue, il y a une probabilité accrue de casser le code.

Je pense que la lisibilité est l'élément le plus important de la maintenance du code, et les solutions trop compliquées réduisent presque toujours la lisibilité et augmentent les coûts de maintenance.

J'ai vu beaucoup de code plus complexe que nécessaire et presque toujours pour ces trois raisons:

1) Sur-ingénierie en raison d'une généralisation prématurée ou en essayant d'anticiper les besoins futurs qui ne se sont jamais posés

2) Le (s) développeur (s) souhaitaient apprendre / expérimenter avec un nouveau modèle de conception ou une nouvelle technologie qu'ils n'avaient pas utilisé auparavant et l'ont intégré même lorsqu'il était excessif. Ils le font parce que cela rend leur travail plus intéressant et qu'ils apprennent quelque chose de nouveau.

3) Des fonctionnalités et des corrections de bugs ont été ajoutées, mais le code existant n'a pas été correctement refactorisé à l'époque. Il peut ne s'agir que d'un petit morceau de duplication ou d'un autre argument indicateur sur une méthode, mais tout s'additionne. En effet, des hacks sont ajoutés et il ne faut pas longtemps pour que tout devienne trop compliqué en raison de toutes les odeurs de code. C'est le plus courant et généralement dû au fait de ne pas savoir mieux ou à cause du temps.

C'est absolument une chose courante. Comme le disent la plupart des livres, un bon développeur sait rester simple. Il est tout simplement trop facile de compliquer excessivement quelque chose avec une nouvelle technologie ou un cadre "cool" que vous venez de trouver, alors vous commencez à chercher des moyens de l'utiliser, au lieu de penser du point de vue des problèmes.

Comme l'a dit Martin Fowler, ceux qui apprennent une nouvelle technologie ont un problème à court terme où ses solutions "technologiques" sont axées.

Je ne pense pas que ce soit normal pour tous les programmeurs, mais j'ai certainement vu beaucoup de programmeurs faire cela.

Je pense que certaines personnes pensent que certaines personnes voient que quelque chose de vraiment simple est «trop facile» et que ce n'est pas une bonne vitrine de leurs compétences. Par conséquent, ils doivent trouver une solution grande et complexe qui est un moyen de dire «regarde ce que je peux faire!», Même si ce n'est peut-être pas la meilleure solution pour le problème en question.

J'ai vu des programmeurs écrire souvent plusieurs lignes de code pour accomplir une tâche qu'ils ignoraient déjà intégrée au langage. Ce n'est pas exactement intentionnel mais peut certainement être évité.

Cela dépend de ce que vous appelez "simple". Certaines personnes voient le code hautement refactorisé comme plus "complexe" car il y a plus de code et plusieurs graphiques d'appels. Cependant, ce code est plus "simple" dans la mesure où il est beaucoup plus facile d'apporter des modifications.

Je trouve souvent qu'une grande fonction semble "simple" jusqu'à ce que vous ayez besoin de faire des changements, puis elle devient rapidement complexe.

En d'autres termes, le simple est dans l'œil du spectateur dans de nombreux cas.

Le problème est si vous ne pouvez pas voir clairement les solutions simples (c'est là que les discussions avec les collègues entrent en jeu) ou si vous généralisez trop tôt.

En d'autres termes, vous faites des boucles simples en fonctions de bibliothèque avancées parce que vous pensez que vous en aurez besoin pour votre prochain projet de toute façon (sauf que vous ne le ferez pas sous cette forme exacte). Faites cela trop longtemps et vous avez une application extrêmement complexe avec un noyau très simple.

Vous pourriez également constater que vous avez besoin d'un code très robuste, et toute la robustesse le rend complexe par défaut. Cependant, je ne pense pas que ce soit votre problème.

Dans certains cas, cela pourrait être simplement la complexité de trouver une solution propre / simple.

Il y a une citation dont je ne me souviens pas ou qui va quelque chose seule: le code n'est pas complet une fois que vous avez écrit tout ce que vous avez besoin d'écrire, mais ne complétez qu'une fois que vous n'avez plus rien à supprimer.

Le manque de clarté empêchera les gens de retirer tout l'excès.

Les meilleurs ingénieurs sont ceux qui peuvent prendre des problèmes très compliqués et les transformer en solutions faciles à mettre en œuvre et à comprendre. Cela semble simple, mais il n'y a pas beaucoup d'ingénieurs / développeurs comme celui-là qui existent. En fait, il n'y a pas beaucoup de gens comme ça qui existent. En réalité, la majorité des gens font exactement le contraire. Ils prennent des problèmes simples et les compliquent au-delà de la reconnaissance. Il suffit de regarder nos politiciens pour un exemple de personnes qui parviennent à prendre des problèmes simples et à les transformer en un chaos total. Les programmeurs ne sont pas différents à cet égard.

Personnellement, je n'ai jamais intentionnellement tenté de compliquer un logiciel. Cependant, j'ai terminé quelque chose et j'ai pensé "wow, c'est trop compliqué" et j'y suis retourné et refactorisé. Certaines personnes peuvent voir cela et penser que cela fonctionne et que c'est assez bon et ne pas le refactoriser.

Un sage aurait dit que vous devriez garder les choses aussi simples que possible, mais pas plus simples. La même chose pourrait s'appliquer au code. Parfois, vous devez utiliser une technique que certains considèrent comme complexe (la récursivité peut être un bon exemple, elle fait souvent peur aux programmeurs débutants).

Cependant, en général, je pense que le code complexe se produit souvent de manière organique. Un problème simple est résolu avec du code qui est simple, puis la portée se développe et le code est modifié sans trop de réflexion, et au fil du temps, vous obtenez du code qui essaie de couvrir le nouveau problème mais a été vraiment conçu pour résoudre un problème différent. Il devient une courtepointe patchwork de différentes pièces de logique. Un tel code peut alors souvent sembler beaucoup plus complexe que le problème ne l'exige, mais il l'a obtenu parce que chaque petit changement semblait, à l'époque, être le moyen le plus simple de faire fonctionner le code.

Je ne pense pas que la plupart des développeurs aient délibérément décidé de rendre le code complexe (bien que vous obteniez une démonstration étrange qui utilisera une certaine technique pour prouver leur propre compétence), je pense que le code ne fonctionne que de cette façon s'il n'est pas agressivement maintenu et refactorisé .

Une autre raison qui n'a pas encore été soulevée est que les gens peuvent trop compliquer les solutions livrées pour s'assurer que vous aurez besoin de leurs services plus tard pour prendre en charge ces solutions. En d'autres termes: pour la sécurité de l'emploi.

Peut-être un problème d'erreur classique?

30. Révélateur plaqué or.

Les développeurs sont fascinés par les nouvelles technologies et sont parfois impatients d'essayer de nouvelles fonctionnalités de leur langage ou de leur environnement ou de créer leur propre implémentation d'une fonctionnalité fluide qu'ils ont vue dans un autre produit - qu'elle soit ou non requise dans leur produit. L'effort requis pour concevoir, implémenter, tester, documenter et prendre en charge les fonctionnalités qui ne sont pas nécessaires allonge le calendrier.

• Steve McConnell, développement rapide.

Oui, parfois, nous compliquons trop le code pour nous amuser. Surtout si la perception que le code est trop compliqué vient d'un participant ignorant ou junior du projet.

OUI ... et j'ai payé le prix trop de fois.

Mon tableau blanc a maintenant une déclaration en astérisques tout en haut qui indique

"Si ce n'est pas simple, ce n'est pas bien"

... et chaque fois que je prototype quelque chose sur le tableau blanc, cela attire toujours mon attention.

Cela fonctionne vraiment pour moi car mes conceptions complexes deviennent beaucoup plus simples, ce qui se traduit par un code plus propre.