Lorsque je commence à écrire du code à partir de zéro, j'ai une mauvaise habitude d'écrire rapidement tout en une seule fonction, tout le temps pensant "Je le rendrai plus modulaire plus tard". Ensuite, quand la plus tard, j'ai un produit de travail et toutes les tentatives de résolution de cela signifie créer des fonctions et avoir à comprendre ce que je dois passer.
Cela fait pire parce qu'il devient extrêmement difficile de redéfinir les cours lorsque votre projet est presque terminé. Par exemple, je fais habituellement une planification avant que je commence à écrire du code, puis lorsque mon projet est terminé, je me suis rendu compte que j'aurais pu rendre les classes plus modulaires et / ou que j'aurais pu utiliser l'héritage. Fondamentalement, je ne pense pas que je faisais assez de planification et je ne reçois pas plus d'un niveau d'abstraction.
Ainsi, à la fin, je suis coincé avec un programme avec une grande fonction principale, une classe et quelques fonctions d'assistance. Inutile de dire que ce n'est pas très réutilisable.
Quelqu'un a-t-il quelqu'un ayant le même problème et avoir des conseils pour surmonter cela? Une chose que j'avais à l'esprit était d'écrire la fonction principale avec le pséduocode (sans beaucoup de détails mais suffisamment pour voir quels objets et fonctions dont ils ont besoin). Essentiellement une approche descendante.
Est-ce une bonne idée? Toute autre suggestion?
8 Réponses :
"Premièrement, nous faisons nos habitudes, puis ils font de nous."
Cela semble appliquer pour les bonnes et les mauvaises habitudes. Sonne comme un mauvais a pris de vous.
La pratique étant plus modulaire à l'avance jusqu'à ce que ce soit "juste comme je fais des choses."
Oui, la solution est facile, bien que cela prend du temps pour s'y habituer. Ne jamais prétendre qu'il y aura un "plus tard", où vous vous asseyez et je me refactore. Continuez au lieu de cela, continuez à ajouter de la fonctionnalité à votre code (ou tests) et pendant cette phase, effectuez de petits refacteurs incrémentiels. Le "plus tard" sera fondamentalement "toujours", mais caché dans la phase où vous faites quelque chose de nouveau à chaque fois.
Je trouve la discipline de discipline de refacteur rouge-vert TDD Works WORDERS.
Ma règle de base est que quelque chose de plus de 20 lock doit être propre. EME, chaque projet se situe sur quelques «juste-un-à-la-épreuve», qui n'ont jamais été destinés à se retrouver dans un code de production. Comme cela semble inévitable, même 20 lignes de code de la preuve de concept devraient être clairs, car ils pourraient finir par être l'une des fondations d'un grand projet.
Mon approche est de haut en bas. J'écris et seulement commencer à écrire toutes ces fonctions plus tard. (Généralement, ils sont De cette façon, j'évite aussi Doit à commenter les algorithmes: les noms de fonction sont suffisamment explicatifs. en ligne et entrent dans l'espace de noms non nommé. Parfois, ils se révèlent être un-liners, puis je pourrais les éliminer plus tard.)
Vous avez à peu près identifié le problème. Ne pas avoir assez de planification. Passez un peu de temps à analyser la solution que vous allez développer, cassez-la en morceaux de fonctionnalité, identifiez comment il serait préférable de les implémenter et d'essayer de séparer les couches de l'application (UI, logique commerciale, couche d'accès aux données, etc. ).
Pensez en termes d'OOP et de refacteur dès que cela a du sens. C'est beaucoup moins cher que de le faire après que tout soit construit.
Écrivez la fonction principale minimale, avec presque rien de là. Dans la plupart des programmes d'interface graphique, des programmes de jeux SDL, du GL Open GL ou de tout type d'interface utilisateur, la fonction principale ne devrait être rien de plus qu'une boucle de consommation d'événement. Il doit y avoir, ou il y aura toujours de longues étendues de temps où l'ordinateur semble insensible et que le système d'exploitation pense que le fait de la fermer peut-être, car il ne répond pas aux messages.
Une fois que vous avez obtenu votre boucle principale, verrouillez-la rapidement, seulement pour être modifié pour les corrections de bugs, pas de nouvelles fonctionnalités. Cela peut simplement finir par déplacer le problème à une autre fonction, mais avoir une fonction monilithique est plutôt difficile à faire dans une application basée sur des événements de toute façon. Vous aurez toujours besoin d'un million de petites manuelles d'événements.
Peut-être que vous avez une classe monolithique. Je l'ai fait ça. Principalement la manière de faire face à cela est d'essayer de conserver une carte mentale ou physique des dépendances et de noter où il y a ... Disons-nous, des perforations, des fissures où un groupe de fonctions ne dépendent pas explicitement d'un état ou de variables partagés avec autres fonctions dans la classe. Là, vous pouvez tourner cette grappe de fonctions dans une nouvelle classe. Si c'est vraiment une classe énorme et vraiment emmêlé, j'appellerais qu'une odeur de code. Pensez à repenser une telle chose à être moins énorme et interdépendante.
Une autre chose que vous pouvez faire est que vous codez, notez que lorsqu'une fonction augmente à une taille où elle ne s'intègre plus sur un seul écran, c'est probablement trop grand, et à ce stade commencer à penser à la façon de la casser. en plusieurs fonctions plus petites.
Le refactoring est beaucoup moins effrayant si vous avez de bons outils pour le faire. Je vois que vous avez taqui votre question comme "C ++" mais la même chose vaut pour une langue. Obtenez une IDE où extrayant et renommer des méthodes, extraire des variables, etc. est facile à faire, puis apprenez à utiliser efficacement cet IDE. Ensuite, les «petits refactorings incrémentiels» que Stefano Borini mentionne moins décourageant.
Votre approche n'est pas nécessairement mauvaise - une conception plus modulaire plus modulaire pourrait finir comme sur-ingénierie.
Vous avez besoin de refacteur - c'est un fait de la vie. La question est quand? Trop tard, et le refactoring est une tâche trop grosse et trop sujette à risque. Trop tôt, et cela pourrait être trop ingénierie. Et, au fil du temps, vous devrez refroidir à nouveau .. Et encore. Cela ne fait que partie du cycle de vie naturel des logiciels.
Le truc est de refacteur bientôt, mais pas tôt. Et fréquemment, mais pas trop fréquemment. Combien de temps et à quelle fréquence? C'est pourquoi c'est un art et non une science :)
J'ai récemment demandé à une quotetion similaire concernant la planification du projet, mais nos problèmes sont légèrement différents. Peut-être que certaines réponses peuvent vous être utiles. Stackoverflow.com/questions/1100819 / ...
Je me récompense du chocolat.