Où tracez-vous la ligne pour votre perfectionnisme? [fermé]

Le perfectionnisme peut être bon ou mauvais lors de la programmation.

• Quand et où tracez-vous la ligne lorsque vous résolvez un problème?
• Quand décidez-vous quand une solution est excessive, trop générale ou simplement trop futuriste?

Veuillez commenter si la question n'est pas claire.

KISS et YAGNI , en particulier YAGNI.

Développez seulement une solution pour les choses dont vous savez que vous allez bientôt avoir besoin. Ne le modifiez pas pour les choses qui pourraient être nécessaires dans deux ans, car il est fort probable que vous aurez besoin de choses très différentes et que vous devrez le réorganiser de toute façon.

Au moment où vous commencez à parler de "avec cette conception à un moment donné dans l’avenir, nous pourrions faire X, ou même Y", au lieu de "cette conception nous permet de répondre aux besoins des clients Z dans la prochaine version", c’est à ce moment-là que vous obtenez dans l'astronomie de l'architecture.

En réponse aux commentaires:

• KISS = Keep It Simple, Stupid = prétendre que vous êtes un crétin et que vous devez comprendre le design
• YAGNI = Vous n'en aurez pas besoin = arrêtez de prétendre que vous pouvez prédire l'avenir dans votre conception

Utilisez une approche itérative et ce problème disparaît généralement. Votre code doit être exécuté le premier jour et presque tous les jours après. Répondez d'abord aux exigences minimales et ajoutez-en davantage au fil du temps. Ne perdez jamais de grands changements lorsque vous ne pouvez pas exécuter votre code pendant longtemps.

Une solution est exagérée lorsque le temps supplémentaire nécessaire pour la mener à bien vaut plus que l'impact négatif potentiel, de la solution la plus facile à la dernière à la prochaine mise à niveau / modification naturelle.

Fondamentalement, vous négociez l'heure maintenant avec l'heure plus tard. Si vous passez plus de temps maintenant, vous économiserez plus tard, vous le faites mal. Si vous avez vraiment trop d'ingénierie, vous passez maintenant du temps sans affecter votre temps (ou même le rendant plus long) que vous passerez plus tard.

Plus vous avez d'expérience, mieux vous vous en sortez. La meilleure façon de procéder (d'après mon expérience) est de faire ce dont vous avez besoin maintenant, mais d'une manière qui peut être augmentée plus facilement si les exigences ultérieures l'exigeaient. Travailler comment faire est la partie la plus délicate.

J'étais très perfectionniste (passer du temps à créer des cadres, pas des solutions).

Mais ce qui m'a vraiment aidé à accélérer ma production, c'est d'apprendre et de suivre les principes de BDD / TDD, y compris le principe de l'extérieur (que j'ai eu du mal à apprendre à embrasser).

Cela m’a vraiment appris à ne pas écrire une seule ligne de code avant qu’un test n’existe. Mais les tests unitaires n'existent pas avant qu'un test d'acceptation n'existe pour celui-ci. Et les tests d'acceptation proviennent des besoins réels des utilisateurs.

Par conséquent, toutes les lignes de code proviennent d'un besoin réel de l'utilisateur.

En principe, si vous n'êtes pas familiarisé avec l'extérieur, vous devez commencer à écrire des tests pour la couche la plus externe de votre application (c'est-à-dire l'interface graphique dans presque tous les cas) en utilisant des doubles de test pour simuler le comportement des couches inférieures. Ensuite, vous implémentez juste assez pour que les tests réussissent. Cette implémentation de la couche supérieure dicte ensuite les tests que vous devez écrire pour la couche suivante, etc., jusqu'à atteindre la couche inférieure de votre application.

Je remarque que je m'améliore par l'expérience.

Quand j'étais (très) jeune, je recherchais toujours la solution la plus parfaite, sans compromis. Maintenant, je suis mieux à garder des choses comme le budget et le temps à l'esprit.

La limite de temps dessine cette ligne assez clairement.

Mon patron fait effectivement :)

Je dois admettre que je vais de mieux en mieux, mais je ne fais pas encore beaucoup de compromis. Heureusement j'ai mon patron pour me freiner;)

Je voudrais cependant soulever un autre problème que la simple ingénierie, celle-ci étant assez facile à détecter.

Mon problème principal concerne le refactoring. Le problème est que la plupart du temps, même si j’essayais d’écrire le code aussi bien que possible, je ne savais pas ce que je savais maintenant (plus de codes, plus de motifs, de nouveaux idiomes, de nouveaux problèmes, de nouvelles solutions). Et donc, même si cela fonctionne, je connais maintenant de meilleures façons de le faire:

• Moyens d'améliorer la convivialité et de réduire les chances d'obtenir un bogue
• Moyens qui réduiraient les dépendances, améliorant le temps de compilation

Cependant, cela fonctionne comme il est, et par conséquent, le refactoring n'est pas une priorité, et la vérité est que cela me harcèle; Je comprends les raisons économiques et les attentes des clients (ils ne voient pas le code et préfèrent les nouvelles fonctionnalités et les corrections de bugs), mais j'aimerais bien avoir le temps de travailler dessus.

Pour l'instant, je ne fais que suivre l'ordre de mon patron, mais je dois avouer que je me sens mal à l'aise, sachant que le code fourni pour la production n'est pas le meilleur que je pourrais trouver maintenant. Le perfectionnisme, je suppose.

À la fois professionnellement et personnellement, la norme que j'essaie d'appliquer à moi-même est la suivante:

Sois content de gagner.

Si mon code résout le problème qu'il est censé résoudre et ne crée pas de nouveaux problèmes *, il est très probablement temps de passer à autre chose. Lorsque vous apprenez à placer la barre aussi haute que nécessaire, "Assez bon" devient, eh bien, assez bon.

La perfection est comme la vitesse de la lumière: vous n’y arriverez jamais, mais il n’ya pas de limite à l’énergie que vous pouvez dépenser pour essayer.

(* - Notez que "Buggy" et "Difficult to maintenance" entrent tous les deux dans la rubrique "Nouveaux problèmes". Je ne l'appelle donc pas complet tant que le code n'a pas été testé, si les bits superflus ont été coupés et les commentaires / la documentation de l'API mise à jour.)

Avec l'expérience, j'ai réalisé que le perfectionnisme n'était même pas possible avant d'avoir au moins quelques années dans les poches dans un contexte particulier (langage, cadre, plate-forme, standard). En tant que débutant, il y aura toutes sortes d'idiosyncrasies dont vous ne serez pas au courant (échappement, priorité, mots réservés, sucre syntaxique, délais d'attente, appels asynchrones, fonctionnalités non documentées et bugs), j'essaie juste de trouver une bonne solution, tous les tout en apprenant autant que possible. Il est important de noter que j'essaie toujours de simplifier la refactorisation du résultat: une architecture modulaire, des commentaires si nécessaire et aucune astuce intelligente .

Comme beaucoup d'autres programmeurs, j'ai beaucoup de code hérité à gérer. La tentation de tout refaire sera toujours là, mais je l’ai essentiellement résumée à un principe:

Est-ce que je (ou quelqu'un d'autre) devra résoudre ce problème à nouveau ?

Cela prend généralement beaucoup de code spaghetti en un code un peu plus gérable. Abstenez-vous de certains morceaux, lancez vos tests, et maintenant, il ne semble plus avoir besoin de perfection.