Bloqué pour avoir «trop de connaissances» [fermé]

Notez plus de discussion à http://news.ycombinator.com/item?id=4037794

J'ai une tâche de développement relativement simple, mais chaque fois que j'essaye de l'attaquer, je finis par me laisser envahir par des pensées profondes: comment pourrait-il prolonger l'avenir, quels besoins de la 2e génération vont avoir besoin, comment cela affecte-t-il le "non fonctionnel" aspects (par ex. Performance, autorisation ...), quel serait le mieux pour un architecte de permettre le changement ...

Je me souviens de moi il y a quelque temps, plus jeune et peut-être plus désireux. Le "moi" que j'étais alors n'aurait pas pensé à tout cela - il serait allé de l'avant et aurait écrit quelque chose, puis réécrit, puis réécrit à nouveau (et encore ...). Le "moi" aujourd'hui est plus hésitant, plus prudent.

Aujourd'hui, je trouve qu'il est beaucoup plus facile aujourd'hui de planifier et d'instruire d'autres personnes sur la façon de faire les choses que de les faire moi-même - non pas parce que je n'aime pas coder - au contraire, j'adore! - Mais parce que chaque fois que je suis assis au clavier, je me retrouve dans le même endroit agaçant.

Est-ce faux? Est-ce une évolution naturelle ou est-ce que je me suis entraîné dans une ornière?

Divulgation loyale - dans le passé, j'étais développeur, aujourd'hui, mon titre est "architecte système". Bonne chance pour comprendre ce que cela signifie - mais c'est le titre.

Sensationnel. Honnêtement, je ne m'attendais pas à ce que cette question génère autant de réponses. Je vais essayer de résumer.

Les raisons:

1. Analyse paralysie / Over engineering / Gold Plating / (Tout autre "trop ​​de réflexion en amont peut vous blesser")
2. Trop d'expérience pour la tâche donnée.
3. Ne pas se concentrer sur ce qui est important.
4. Pas assez d'expérience (et en réalisant cela).

Solutions (non adaptées aux raisons):

1. Tester d'abord.
2. Commencez à coder (+ pour vous amuser)
3. Un à jeter (+ une API à jeter).
4. Définir des contraintes de temps.
5. Enlevez les peluches, restez avec le truc.
6. Créez un code flexible (un peu en face de "un à jeter", non?).

Merci à tous - je pense que le principal avantage ici était de réaliser que je ne suis pas seul dans cette expérience. En fait, j'ai déjà commencé à coder et certaines des choses trop grosses sont tombées naturellement.

Étant donné que cette question est close, j'accepte la réponse avec le plus grand nombre de votes à compter d'aujourd'hui. Quand / si cela change - je vais essayer de suivre.

Penser à ces choses-là, c'est bien, mais ne laissez pas cela arrêter vos progrès.

Une approche qui fonctionne vraiment bien (en particulier avec le développement itératif) consiste à mettre en œuvre une solution simple, puis à la refactoriser si nécessaire. Cela garde le code aussi simple que possible et évite une ingénierie excessive. La plupart des modifications de performances ou d'architecture que vous envisagez ne seront probablement pas nécessaires de toute façon, alors ne vous embêtez pas pour les écrire tant qu'elles ne sont pas devenues officielles. Par exemple, ne vous inquiétez pas des performances tant qu'un profileur ne vous a pas dit qu'il était temps d'améliorer les performances.

Une des choses que vous pouvez faire pour vous aider à vous ajuster est de définir une limite de temps difficile pour définir le temps de réflexion avant d’écrire du code. La plupart du temps, le code sera meilleur si vous réfléchissez un peu, écrivez-le, prenez conscience de vos erreurs, puis corrigez-les par refactoring.

Il y a un équilibre à trouver ici. Vous ne devriez pas simplement vous lancer la tête la première et ne pas penser aux conséquences, mais vous ne devriez pas non plus essayer de trop modifier votre code.

Wikipedia le nomme "Analyse paralysie" dans le logiciel. La recette est de s'en tenir à des méthodologies agiles. Cela signifie que toute activité ou action individuelle a beaucoup plus de valeur que d'essayer d'établir des pratiques ou des politiques. Chaque contributeur de l'équipe est précieux, que ses capacités soient ou non conformes aux idéaux architecturaux. En agile, les individus, les egos sont les premiers, les politiques sont les derniers.

Ma réponse préférée est "L'architecture est un verbe". Arrêtez de penser, commencez à agir, peu importe l’imperfection et l’inefficacité que vous et votre équipe ressentirez. Peut-être que les premières actions peuvent être le démantèlement de politiques inappropriées.

Il y a 40 ans, Fred Brooks écrivait à ce propos: "Écris-en un à jeter, tu le feras de toute façon." Rien n'a changé........

Est-ce faux? Est-ce une évolution naturelle ou est-ce que je me suis entraîné dans une ornière?

Ça dépend. Cela tend à être une étape commune sur le chemin d'un développeur.

1. Commence à jeter de la merde ensemble, se faire piquer par le cul
2. Commencez à sur-ingénierie de l'enfer de tout, réalisez que YAGNI
3. Installez-vous sur un terrain d'entente pragmatique où les choses faciles sont giflées et les choses difficiles / susceptibles de changer disposent de suffisamment d'ingénierie pour qu'il soit assez facile de travailler avec / de changer.

Ce n'est qu'une ornière si vous restez au numéro 2.

L’une des choses que j’ai toujours à l’esprit est le dicton «L’avenir n’est plus ce qu’il était».

Avec une certaine expérience, il est tentant de croire que l'on peut prédire l'avenir, mais que l'on ne peut pas. Il est facile d’envisager les fonctionnalités que les futurs clients / utilisateurs / ceux qui le souhaitent peuvent vouloir, mais cela ne signifie pas qu’ils vont les vouloir tout de suite. Cela ne signifie pas non plus qu'ils vont vouloir les remplacer par une autre fonctionnalité en conflit. Vous devez donc vraiment limiter le temps que vous passez aujourd'hui à planifier votre avenir. Vous devez surtout limiter le temps que vous passez à construire des objets qui ne seront utiles que dans le futur.

La question que je me pose et qui me maintient au premier plan est la suivante: "À quel point sera-t-il plus difficile de créer cette fonctionnalité plus tard que de créer un support pour cette fonctionnalité maintenant?" Habituellement, la réponse est que l’effort futur est à peu près le même ou peut-être deux fois plus que ce que ce serait de le faire maintenant. Dans ce cas, parce que je ne peux pas prédire l'avenir, je n'ai aucun problème à ne pas le construire maintenant. Si la réponse est au moins 10 fois supérieure, je commencerai par vous demander dans quelle mesure les gens pensent probablement que nous aurons besoin de cela au cours des deux prochaines années. Même dans ce cas, à moins d’un accord général, je me contenterais de veiller à ce qu’il ne soit pas nécessaire d’annuler les choses que nous accomplissons aujourd’hui pour atteindre cet objectif à l’avenir.

Par exemple, j'ai travaillé sur quelques projets où nous avons passé beaucoup de temps à résumer le fait que nous utilisions plus tard Hibernate comme accès à des données. (Je n’avais jamais vu le projet construit sur Hibernate cesser de l’utiliser, c’était donc une perte de temps au départ, mais mettons cela de côté.) Même s’il était raisonnable de vouloir changer plus tard, car nous utilisions également un modèle d’objet d’accès aux données; il n’aurait pas été plus difficile d’intégrer la possibilité de changer d’Hibernate et de le changer en même temps que nous avions besoin de le faire. Face à une situation comme celle-ci à présent, je différerais cette flexibilité jusqu'à ce que nous en ayons vraiment besoin.

À moins que vous ne planifiiez de manière stratégique pour une grande entreprise, il ne vaut même pas la peine de penser à des problèmes d'architecture à plus de deux ou trois ans, car la technologie évolue si rapidement. La fonctionnalité que vous envisagez de créer peut être disponible gratuitement en open source d'ici deux ou trois ans. L'analyse coûts-avantages aura presque certainement changé.

Limitez-vous à la construction d'un système qui répond à vos besoins actuels, dont vous êtes fier et sur lequel vous serez heureux de travailler dans quelques mois, quelles que soient les modifications apportées. Vraiment c'est le mieux que vous puissiez faire.

Voici mon processus personnel d'élimination des conceptions délirantes qui (dans leur première version) peuvent s'avérer peu pratiques et nuire à un projet du point de vue commercial.

1. Identifiez l' épicentre : Pensez à votre projet comme à un stand de hot-dogs, l'épicentre étant les hot-dogs. Vous pouvez sortir toutes les autres épices / vinaigrettes / légumes de votre stand et pouvoir toujours vendre des hot dogs. Quel est le but principal de votre logiciel? Isolez tous les autres ajouts et / ou valeurs ajoutées et concentrez-vous d'abord sur l'épicentre.
2. Répétez-vous: "le faire plus tard, c'est le faire mieux" : voyez où cela a du sens et ajoutez un petit mot "pour plus tard". Si vous le faites bien et si vous pensez à son utilisation dans le monde réel, vous vous retrouverez avec le même design, mais priorisé dans une feuille de route.
3. Diminish-Decouple-Discard : quelle que soit la conception du module que vous avez, rendez-le aussi simple / essentiel / pur / universel que possible (parfois, cela peut être accompli sans même supprimer certaines fonctionnalités). Lorsque vous ne pouvez pas le simplifier davantage, commencez par découpler les éléments qui pourraient vivre par eux-mêmes et avoir une raison d'être. À la fin, si vous avez encore de la graisse, vous pourrez simplement la couper.
4. Séparez le "code de la bibliothèque" du "code de production" : il y aura toujours du code qui ne pourra pas être réutilisé, mais cela ajoutera toujours du bruit à la conception. Ce code est celui qui contient les règles de gestion. Vous constaterez que certaines règles métier sont parfois plus faciles et plus rapides à modifier ( extrêmement importantes ) qu'avec une conception robuste. Vous trouverez le code sur lequel vous pouvez compter et le code dont le client a besoin pour changer ou réimplémenter à l'avenir. Vous voudrez que ceux-ci soient gardés aussi séparés que possible.

Et BTW, l’étape 0 est: "devenez fou avec le design". Cela m'aide à le sortir de mon système et à trouver souvent de nouvelles implications, des exigences cachées et même des fonctionnalités émergentes.

J'ai pris 1 & 2 de Rework .

Ecrivez les tests. Vous avez terminé lorsque tous les tests sont réussis: pas avant, et certainement pas longtemps après au cours d'une phase épique d'ingénierie excessive. Avoir une série de tests pour le code que vous écrivez vous donnera un observateur indépendant et impartial vous indiquant quand vous pouvez arrêter.

Quand vous êtes jeune, vous ne voyez pas le risque (peut-être la raison pour laquelle les politiciens débutants sont effrayants), mais à mesure que vous vieillissez, vos mauvaises expériences vous paralysent à chaque occasion (peut-être la raison pour laquelle les hauts responsables politiques stagnent). Adoptez une approche guidée par le rasoir d'Occam - optez pour la solution qui a le moins de besoins, puis évoluez à partir de là.

Lors de la rédaction et de la conception d'un logiciel, vous devez garder à l'esprit uniquement deux choses: la maintenabilité et l'exactitude.

La correction est le plus important à court terme et peut facilement être prouvée par des tests.

La maintenabilité aidera plus tard dans le développement, mais il est plus difficile à cerner.

Ma stratégie actuelle consiste d'abord à obtenir une preuve de concept monolithique, puis à séparer l'interface utilisateur du modèle (en veillant à ce que le modèle ne sache rien à propos de l'interface utilisateur) une fois que je suis convaincue qu'elle est viable. Si j'attendais trop longtemps cette étape, j'obtiendrais quelque chose d'inattaquable. Si je commence par les couches séparées, je ne peux tout simplement pas commencer car je reste bloqué sur ce que l'interface utilisateur doit savoir sur le modèle.

Quand je suis coincé dans des situations comme celles-ci, j'ai trouvé qu'il est utile de s'imaginer obstinément que je suis un utilisateur final qui utilise le programme hypothétique pour faire quelque chose de raisonnablement trivial. Ensuite, j'essaie de me concentrer sur les points d'entrée programmatiques nécessaires pour soutenir ces actions, en essayant autant que possible d'ignorer d'autres aspects du système. À partir de là, il est souvent possible de construire une (petite!) 'Liste de souhaits' de fonctionnalités du système fini, et d'écrire du code irréaliste qui commence à implémenter cela. Après cet exercice, je commence généralement, et le reste du système commence à devenir plus clair. Il s’agit du point d’entrée - et le point d’entrée de la grande majorité des logiciels est constitué par les actions initiales des utilisateurs finaux avec un programme.

Je pense que c'est un syndrome que les tâches que vous faites sont trop faciles pour vous.

Il y a quelques années, le défi pour vous était d'écrire un code qui accomplira la tâche demandée. C'est ce qui a pleinement engagé votre esprit. Maintenant, votre esprit (votre expérience, etc.) fonctionne plus efficacement et accomplir la même tâche ne nécessite qu'une partie de l'énergie qui était nécessaire auparavant. C'est pourquoi vous vous retrouvez dans cette spirale de pensées profondes. Votre esprit se défend de la routine et se bat pour le défi.

Je pense que vous devriez envisager de changer votre travail. Peut-être devriez-vous apprendre un nouveau langage de programmation.

J'ai eu le même problème il y a 15 ans. Je voulais écrire un code parfait, réutilisable, universel, .... qui rendait la solution beaucoup plus compliquée que nécessaire. Aujourd'hui, je vois cela comme du placage à l'or . Ce qui m'a beaucoup aidé, c'est l'avis d'un collègue:

• si vous avez une idée de ce qui pourrait améliorer les fonctionnalités, rendez-les plus universelles, ... écrivez cette idée dans un fichier texte séparé "ideas.txt" mais ne l'implémentez pas maintenant .
• continuer à mettre en œuvre les tâches urgentes.
• au bout de six mois, passez en revue votre "ideas.txt" et analysez lequel de ces changements aurait réellement profité au projet.

C'est simplement une paralysie par analyse. Cela arrive à beaucoup de gens dans beaucoup de domaines. Vous pouvez le traverser.

La réponse est: JUSTEZ AVEC CELA ;-)

Je publie sur un forum de remise en forme et maintes fois, les gens écrivent sur différentes routines, en essayant de trouver celle qui leur convient le mieux. Nous leur disons donc de commencer l’entraînement et de le travailler au fur et à mesure. Vous voulez devenir plus fort, faire des exercices de force, puis peaufiner les choses au fur et à mesure.

Lorsque vous avez un programme important et que votre cerveau travaille en temps supplémentaire, commencez par coder pour les cas simples. Au départ, le programme doit être lancé, puis recevoir des entrées, etc.
Votre défi est de laisser les choses faciles à mettre à jour et à refactoriser plus tard, mais le code NE DOIT PAS être plus compliqué que nécessaire.

Rappelez-vous qu'à l'avenir, il est correct de refactoriser le code pour répondre aux nouvelles priorités. Vous ne pouvez pas tous les prédire à l'avance, alors n'essayez pas.

Code pour la tâche suivante - UNIQUEMENT. Le code est simple et bien, il est donc facile de le refactoriser si vous en avez besoin. Assurez-vous que le programme fonctionne. Répéter.

Étant donné que vous vous retrouvez "coincé" dans votre réflexion sur les scénarios de cas d'utilisation possibles pour les utilisateurs finaux, il convient de prendre en compte la possibilité de publier une API et de s'attendre à ce que des inconnus l'utilisent. Une fois qu'une API est publiée, vous devez continuer à la prendre en charge, même si vous réalisez plus tard à quel point votre première version est mauvaise, ou vous devez casser le code de tout le monde, peut-être inconnu de vous, qui a écrit contre, risquant ainsi de vous aliéner. eux pour tous les temps futurs.

La solution standard consiste à publier en précisant que l’API peut être modifiée à tout moment, de quelque manière que ce soit, jusqu’à ce que vous compreniez ce que vos utilisateurs ont besoin et que les utilisateurs d’API font.

Dans cette solution, je pense est votre propre solution. Ecrivez juste quelques petites choses qui font une ou deux choses, peut-être les font-elles simplement, tout en gardant la compréhension pour vous que tout ce que vous ferez peut changer dans le futur.

Il n’est pas possible d’obtenir que tout soit correct, voire même dans TOUT cas, lorsque vous débutez, car le design est vraiment un voyage de découverte; c'est la dernière à émerger, pas la première chose à faire.

Vous ne pouvez pas concevoir une API tout de suite et ne jamais avoir à la casser à vos consommateurs. Vous comprenez pourquoi. De même, vous ne pouvez pas écrire de logiciel et ne pas avoir à tout jeter et à recommencer avec une nouvelle approche.

Je ne pense pas que vous ayez un problème en ce sens que vous avez accidentellement évolué pour devenir quelque chose de moins créatif, productif ou souhaitable. Je pense que vous avez des normes élevées que vous appliquez par inadvertance à votre situation - une erreur courante en pensant que tout le monde fait.

L’expérience ne compte jamais contre vous à moins que vous ne deveniez un cynique je-sais-tout, tout-fait-tout, et cela ressemble vraiment à l’opposé de votre situation.

J'ai quelques images que je garde en tête quand je vais gros. On est de jouer avec Lego. Je l'ai mis ensemble et l'ai démonté à volonté. Ce que je commence à faire peut ne pas être ce que je finis par faire. Je surfe et je profite des possibilités qui me viennent à l’esprit au fur et à mesure, en recréant souvent mes objectifs sur-le-champ en un éclair d’inspiration… c’est la créativité.

L’autre image est une analogie que j’ai entendue et qui décrit une véritable science. Vous êtes à tâtons dans une pièce sombre pour un chat noir qui peut ne pas être là. C'est déconcertant seulement si vous vous considérez comme un échec pour ne pas avoir trouvé ce chat. Il n'y a pas d'autre moyen de trouver des chats noirs. C'est la seule activité qui les localise. Tout le reste est déjà une forme de ce que vous recherchez prétendument.

Tu n'en sais pas trop. tu n'en sais pas assez! Et vous ne l'avez compris que récemment.

Ne pensez pas à vos choix de conception comme quelque chose que vous devez obtenir "correctement", car il n'y a pas de "correct" - il existe de nombreux "inconvénients", mais il existe également des compromis (en termes de vitesse d'exécution, de temps pour terminer le codage). tâche, extensibilité, etc.). Le code que vous écrivez, s'il est bien conçu, aura toujours des forces et des faiblesses.

L'objectif devrait être d'arriver à un point où la compréhension de ces forces et faiblesses dans le contexte de l'utilisation et de la maintenance actuelles et futures n'est pas considérablement plus difficile que l'écriture de code.

Donc, n'évitez pas les pensées profondes, mais souvenez-vous que vous avez besoin d'expérience, et pas seulement de pensée, pour devenir un maître dans ce type de conception. Pensez jusqu'à ce que vous ayez atteint un point où vous n'êtes pas sûr d'un choix en particulier, puis mettez en œuvre ce que vous espérez être le meilleur, essayez-le et apprenez comment cela s'est passé.

Pratiquez le codage. Proposez des exercices ou trouvez-les en ligne et essayez de les terminer correctement le plus rapidement possible. Lorsque vous accélérez, ajoutez des considérations telles que la maintenabilité et les performances. Vous réaliserez qu'il est rafraîchissant de coder des choses qui ne seront pas produites et que cela vous aidera peut-être à sortir de votre peur du codage.

Codez pendant votre temps libre, comme vous le faisiez il y a 10 ans, avec moins de soucis et juste du plaisir.

Devenez chef d'équipe et dirigez les jeunes développeurs, qui sont maintenant dans le même état d'esprit que vous l'étiez il y a 10 ans.

Non, vous n'en savez pas encore assez.

Enrichissez vos connaissances par exemple par ces règles simples:

• KISS: Restez petit et simple.
• YAGNI: Tu n'en auras pas besoin.
• Pire c'est mieux: certaines solutions pires sont meilleures en termes de maintenabilité.

Ne pas trop d'ingénieur. Soyez prêt au changement en ayant des compétences en refactoring, mais ne codez pas tous les changements possibles dans le code. Si vous constatez qu'avec le temps, une classe ou une fonction devient trop grosse, changez-la. Diviser et conquérir. Utilisez des interfaces, utilisez plus de fonctions. Si vous sentez que vous avez trop divisé (c’est-à-dire que cela est devenu plus sophistiqué, mais moins lisible), annulez votre dernière modification.

En résumé: Faites en sorte que votre code soit suffisamment flexible, mais pas plus. Au lieu de cela, faites votre auto-flexible, achetez un livre sur le refactoring.

Deux choses:

1. Il ne suffit pas de savoir beaucoup. Vous devez avoir des opinions sur ce qui mérite d'être mis en œuvre. Personnellement, je considère TDD comme une béquille permettant une mauvaise architecture. Étant donné la grande quantité d’opinions populaires qui m’oppose contre moi, j’ai probablement tort, mais j’interroge vraiment la question de savoir si TDD doit être implémenté en JavaScript, parce que déboguer n’a jamais été un mal de tête énorme, ce ne serait pas la première fois que l'opinion populaire au sein de la communauté du développement serait vue comme viciée des années plus tard. Donc, apprendre à être un con arrogant. Au moins à l'intérieur. Vous vous trompez peut-être, mais au moins vous vous engagez à faire des choses qui vous conviennent au lieu de trop penser à des choses qui pourraient ne pas l'être.

2. On dirait que vous commencez avec micro. Commencez par macro. Tout d'abord, les outils dont vous avez besoin pour effectuer les tâches que votre application doit effectuer. Cette partie devrait venir assez facilement. Commencez ensuite par les problèmes d’architecture et d’interface. La façon dont la plomberie se connecte et ce à quoi elle se connecte ne devrait vraiment être que des éléments fragiles au-dessus de tout ce que vous pouvez simplement balayer de côté et remplacer par un caprice. De même avec les détails de la façon dont les choses sont faites. Bien emballés, ceux-ci peuvent être remplacés / modifiés facilement.

mais chaque fois que j'essaye de l'attaquer, je finis par me perdre dans mes pensées

Il n'y a rien de mal. Vous avez seulement remarqué qu'il est temps d'améliorer votre processus: dans ce cas, votre processus de réflexion.

Beaucoup de gens se perdent dans l'analyse ou se détournent d'autres façons sans même s'en rendre compte. Vous avez remarqué que vous pouvez modifier votre processus de réflexion pour rester sur la bonne voie.

Il existe de nombreuses solutions à ce problème, et la meilleure que j'ai vue ci-dessus consiste à imposer une contrainte de temps. Avant de commencer, décidez combien de temps (1 heure?) Vous allez consacrer à l’analyse et à la réflexion. Définir une minuterie.

Puis, lorsque le minuteur s’éteint, lancez le codage. Si vous pensez encore trop longtemps aux choses, prenez une décision immédiate. Quoi que vous décidiez à ce moment, c'est la bonne décision. Vous pouvez toujours apporter des modifications et des améliorations ultérieurement.

De plus, notre environnement change constamment. Nous avons souvent besoin de mettre à jour notre code pour gérer les nouvelles exigences, les nouvelles technologies, les nouveaux matériels, les mises à jour de la langue et du système, etc.

Oui, cette horreur de codage se produit même pour moi. Être frappé de débordement de pile. Codage en détail pour une petite application. Mais lorsqu'il s'agit d'un projet externalisé, il ne prend pas beaucoup de temps à cause des contraintes de temps. Et je pense aussi que travailler avec un nouveau groupe de personnes peut surmonter cela.

Vous n'êtes pas assez impitoyable

http://playswithfire.com/blog/2012/02/19/you-are-not-ruthless-enough/

Edit: Le but de cet article est de prêter attention aux petits détails lors de l’élaboration, mais j’ai trouvé qu’il était utile d’aborder toute tâche simple ou complexe avec une attitude impitoyable afin de trouver la solution la plus efficace possible et de faire le travail correctement.