Comment dois-je planifier et démarrer un projet?

Chaque fois que je démarre un projet, je décide à des moments cruciaux de changer complètement les classes de base et de me laisser entraîner dans des erreurs obscures. J'essaie de planifier à l'avance et je commence généralement sur un bon pied, mais j'y vais un autre jour et je décide de le faire «d'une autre manière».

Existe-t-il une norme, en quelque sorte, lors du démarrage d'un projet, comme le mappage de classes et le démarrage de tests unitaires? Qu'est-ce qu'une bonne convention lors de la planification et du démarrage d'un projet moyen?

Le dernier projet et commencé était un simulateur de mouvement de projectile - je sais, prévisible.

Lorsque vous planifiez, ne planifiez pas toutes les choses possibles à propos de l'application à l'avance. Planifiez par étapes. Quelle est la fonctionnalité minimale absolue dont vous avez besoin pour commencer à utiliser l'application? Commencez par là.

Lorsque vous démarrez votre projet, codez uniquement la fonctionnalité minimale absolue. Lorsque vous le codez, assurez-vous d'écrire du bon code propre avec une encapsulation intelligente . Cela minimisera les erreurs résultant de modifications ultérieures.

Répétez cette fonctionnalité minimale jusqu'à ce que vous en soyez satisfait. Commencez ensuite à ajouter de nouvelles fonctionnalités et améliorations, une à la fois. Encore une fois, concentrez-vous sur l'écriture d'un code propre et propre avec une encapsulation intelligente.

Si vous planifiez par étapes et écrivez du code propre, cela minimisera le nombre de changements que vous devez réellement apporter. Au moment où vous avez terminé d'écrire cette première fonctionnalité, vous devriez avoir adopté les modèles sur lesquels reposera la fondation de votre application. S'il y a des problèmes avec cette fondation, vos prochaines fonctionnalités devraient rapidement révéler le problème. Il sera plus facile de voir comment les pièces s'intègrent ensemble. Les modifications que vous apportez devraient, à ce stade, entraîner des perturbations minimes.

Il semble que votre planification n'aide pas. Ce n'est pas surprenant car vous n'avez pas suffisamment d'expérience pour faire un plan réalisable. La solution est simple. Arrêtez de planifier autant. Acceptez simplement que vous allez écrire et réécrire le code au fur et à mesure. C'est ok, car le code est gratuit, sauf pour votre temps. Si vous écrivez une application d'interface utilisateur, commencez simplement avec une fenêtre vide et ajoutez un peu à la fois jusqu'à ce que vous ayez terminé. Lorsque vous aurez plus d'expérience, vos projets iront plus vite. S'inquiéter parce que vous changez de code, c'est comme un étudiant en musique qui s'inquiète de toutes les notes perdues dans la pratique.

Personne ne sait vraiment quel sera le meilleur design tant qu'il n'en aura pas codé une certaine quantité. Par conséquent, le secret d'une bonne conception est de reconnaître que votre premier brouillon est inévitablement sous-optimal, et prévoyez de réécrire des portions plus petites plus tôt et plus fréquemment . Au lieu de supprimer un programme presque complet, réécrivez des lignes ou des fonctions ou des classes dès que vous reconnaissez leurs lacunes.

Les bons programmeurs expérimentés ne réussissent généralement pas non plus au premier brouillon. Ce qui vient avec l'expérience, c'est la capacité de reconnaître un mauvais design plus tôt et la possibilité de réécrire plus rapidement.

D'après mon expérience, ce problème disparaît lorsque vous avez plus d'expérience - vous avez une idée de ce qui fonctionne et de ce qui ne fonctionne pas. De plus, une bonne encapsulation peut réduire les coûts de changement de conception. Plus vos modules sont encapsulés étroitement, moins il est coûteux de les changer plus tard. Considérez cela comme une excellente motivation pour garder vos classes séparées.

http://nathanmarz.com/blog/suffering-oriented-programming.html

Cela résout votre problème. Il a commencé par s'assurer simplement que le logiciel était possible, le prototyper et le créer. Ensuite, il commence à prendre le code et à le décomposer. Ensuite, il l'optimise.

La conception d'une application comporte deux aspects. La première consiste à décider de ce que votre application peut faire. La seconde consiste à concevoir comment le faire. Les changements dans ce qu'il fait sont assez importants et en fonction de la maturité de l'application (et du changement de direction de l'application), il vaut mieux les aborder comme une réécriture plutôt que de retravailler.

Le deuxième aspect est le comment. À l'aide de tests unitaires et de pratiques de développement agile, vous pouvez minimiser l'impact de la modification de la façon dont une fonction spécifique est accomplie par le refactoring. Une partie de l'apprentissage de l'utilisation de ces techniques consiste à pratiquer la pratique.

Je donnerai les conseils que j'ai donnés maintes et maintes fois. Choisissez un projet pour animaux de compagnie. Écrivez-le au mieux de vos capacités. Apprenez quelque chose de nouveau et appliquez ce que vous avez appris pour améliorer votre approche du développement de ce projet.

Par exemple, commencez par une liste Todo. Faites simple ... ne vous inquiétez même pas du stockage de la base de données au début. Faites-le fonctionner. Maintenant, commencez à construire sur cette base. Peut-être que vous voulez apprendre MVVM et WPF ... vous savez déjà comment implémenter la liste de tâches en mémoire, vous avez donc un problème de moins à résoudre. Maintenant, vous voulez faire en sorte que plusieurs utilisateurs puissent charger leurs listes de tâches à partir d'une base de données. Vous avez résolu dans la mémoire et la présentation séparée, vous pouvez donc vous concentrer sur l'apprentissage de l'accès aux données. À partir de là, vous pouvez étendre l'application pour avoir un modèle de domaine plus complexe (par exemple, passer d'une liste Todo à une solution de gestion de projet), une interface Web, ou même la faire fonctionner sur un appareil mobile. La clé pour faire ce travail est de choisir quelque chose qui est réalisable par vous que vous pouvez marquer des progrès et que vous pouvez grandir au fil du temps.

D'après mon expérience, la conception du système prend souvent aussi longtemps ou plus longtemps que le codage réel. Lorsque vous dites «planifier à l'avance», que planifiez-vous réellement? Peut-être aller à la vieille école et utiliser l'une des méthodologies de conception éprouvées. Ou allez à la vieille école et écrivez le pseudo-code avant d'écrire le code réel.

Je pense que vous devez vous demander pourquoi changez-vous les choses à des moments cruciaux plutôt que de vous en tenir au plan d'origine. Le plan d'origine était-il défectueux? Ou avez-vous eu un moment perspicace qui a montré une meilleure façon de faire les choses. Était-ce réellement meilleur ou juste différent?

À mesure que vous gagnez en exp, vous devrez réécrire / gratter et recommencer, moins souvent. Notez le problème que vous essayez de résoudre. Notez les descriptions vagues des cours dont vous pensez avoir besoin, notez comment les élèves devront interagir. Faites-vous une idée de la façon dont tout va fonctionner, puis codez. Ne passez pas des tonnes de temps à écrire chaque propriété, méthode de vos cours. À ce stade, vous essayez d'avoir une vue de 50K pieds de ce que vous êtes censé faire. Une fois que vous avez commencé à coder si vous avez besoin d'écrire plus de détails, allez-y. Sinon, commencez simplement à coder.

La raison pour laquelle vous trouvez cela si difficile est que vous avez une idée, mais vous n'avez pas vraiment une idée complète de ce que vous voulez qu'elle fasse. Si vous faites votre propre projet et que vous n'avez pas de client pour vous dire ce qu'il veut, alors c'est à vous d'être votre propre client. Mettez-vous à la place du client et commencez à créer une liste de souhaits impossible.

En d'autres termes, lorsque vous commencez Ne concevez rien !!! .

Une fois que vous avez une grande liste de choses que vous voulez que le système fasse, hiérarchisez tout et décidez quelles seront les fonctionnalités minimales pour faire fonctionner un système de base. Cela peut être une seule fonction de base, ou un écran entier, mais cela doit être quelque chose que vous ressentez - car le client sera suffisamment utile pour tester.

Donc, liste de souhaits de fonctionnalités + priorités de base = exigences .

Une fois que vous avez tout cela, faites une conception de très haut niveau. Asseyez-vous et réfléchissez à ce dont votre système aura besoin pour que les premières priorités soient opérationnelles. Changez d'avis si vous le souhaitez, mais c'est ici que vous souhaiterez peut-être ajouter du code ou une configuration système pour en savoir plus sur ce qui est possible. Allez assez loin pour valider votre idée de base d'un design.

C'est-à-dire: MAINTENANT, vous pouvez satisfaire les envies de vos concepteurs .

Une fois cela fait, vous commencez à implémenter vos fonctionnalités. Créez pour chaque fonctionnalité une spécification fonctionnelle de base. Cela pourrait être aussi simple qu'une collection d'instructions de fonctionnalités. Cartes d'histoire si vous le souhaitez. Cela vous permet de développer un peu votre idée dans votre esprit et de créer un ensemble d'instructions qui deviendront la spécification sur laquelle vous testerez et construirez votre implémentation.

Pleure Havoc, laisse glisser les chiens de ... Code !!

De là, implémentez vos tests pour correspondre à vos spécifications, puis pour chaque test, écrivez votre code. Construisez, "relâchez", puis répétez avec la fonctionnalité suivante jusqu'à ce que vous décidiez que le projet est suffisamment complet.

Cela se résume vraiment à l'expérience, mais cette approche que j'ai trouvée est une formule simple pour vous aider à vous concentrer sur ce qui doit être fait, plutôt que de vous enfermer dans un cycle sans fin de procrastination en raison d'essayer de faire trop de choses du tout une fois que.

Après avoir fait les bases telles que définir les objectifs du projet, obtenir votre liste d'exigences et verrouiller toutes les interfaces des systèmes externes.

Ensuite, vous devez faire un cas d'utilisation ou une "histoire" pour chaque interaction avec l'utilisateur. Des volumes ont été écrits sur ce qui fait un "bon" cas d'utilisation ou une histoire et il existe de nombreuses variantes. Les cas d'utilisation sont l'outil de conception le plus efficace que j'ai rencontré. Ils aident à récupérer les fonctionnalités manquantes tout en éliminant les exigences inutiles et à dépouiller votre conception de ses éléments essentiels. Comme je l'ai dit, les méthodologies varient mais la plupart des praticiens s'accordent sur: -

• texte anglais concis et clair.
• "Goal Driven" fonctionne mieux, c'est-à-dire que "Monkey gets a grape" est meilleur que "Monkey Pushes red button".
• interdire la terminologie technique. Pas de "pulldowns", de "zones de texte". Un bon cas d'utilisation doit être indépendant de toute technologie d'interface. Vous devriez pouvoir prendre un cas d'utilisation pour un système basé sur HTML et l'utiliser pour un système activé par la voix sans aucune modification du cas d'utilisation lui-même. (c'est très difficile à faire mais ça vaut le coup!).
• Essayez de réduire le nombre de mots de votre première version de 50%, débarrassez-vous des étapes inutiles et du verbiage.

Alors vous êtes prêt à spécifier vos principales classes:

UML - Universal Modeling Language. Est l'outil standard pour concevoir des classes. Vous spécifiez les membres publics et les méthodes de chaque classe et les liez ensemble dans un modèle graphique clair et concis.

En conjonction avec des diagrammes de séquence, des modèles de données, vous pouvez vérifier et améliorer votre conception avant tout codage.

Concentrez-vous sur le résultat que vous souhaitez obtenir et pesez les gains potentiels de l'apprentissage / de la mise en œuvre de nouvelles implémentations avec le risque d'emprunter une route qui vous ramène à la case départ.

Dans le cas où vous vous retrouvez à la case départ, tout n'est pas perdu car vous avez acquis de l'expérience.

Si vous avez une échéance (il semble que vous programmiez peut-être pour le plaisir), c'est vraiment difficile. Si vous continuez dans un sens, vous risquez d'utiliser des méthodes obsolètes au fil du temps. Si vous continuez dans l'autre sens, vous risquez les conséquences d'une production de sortie à un rythme plus lent (un rythme variable plus lent selon les résultats de vos aventures d'apprentissage).

J'avais l'habitude de me frayer un chemin à travers le travail, de faire avancer les choses rapidement année après année, puis un jour, j'ai réalisé que je devenais non courant dans mes compétences.