Estimation des coûts de temps dans la base de code héritée
Récemment, j'ai commencé à travailler sur un projet où une très ancienne application monolithique est en cours de migration vers une architecture basée sur des microservices.
La base de code héritée est très désordonnée ('code spaghetti') et souvent une fonction apparemment simple (par exemple nommée "multiplyValueByTen") se révèle plus tard comme "des milliers de lignes de code de validation impliquant 10 tables sur 3 différents schémas ".
Maintenant, mon patron me demande (à juste titre) d'estimer combien de temps cela prendrait pour écrire la fonctionnalité X dans la nouvelle architecture. Mais j'ai du mal à arriver à une estimation réaliste; souvent, je sous-estime énormément la tâche pour les raisons que j'ai mentionnées ci-dessus et je m'embarrasse parce que je ne peux pas terminer à temps.
La chose sensée peut sembler vraiment entrer dans le code, noter chaque branche et appels à d'autres fonctions, puis estimer le coût en temps. Mais il y a vraiment une minuscule différence entre documenter l'ancien code et écrire réellement la nouvelle version.
Comment dois-je aborder un scénario comme celui-ci?
Bien que je comprenne parfaitement comment fonctionne le refactoring de code hérité, ma question n'est pas de savoir "comment refactoriser/réécrire?" mais de donner une réponse réaliste à "combien de temps faudrait-il pour refactoriser/réécrire la partie X?"
Lisez "Clean Coder" de Bob Martin (et "Clean Code" pendant que vous y êtes). Ce qui suit est de mémoire mais je fortement vous suggère d'acheter votre propre copie.
Ce que vous devez faire est une moyenne pondérée de trois points. Vous faites trois estimations pour chaque travail:
- un meilleur scénario - en supposant que tout se passe bien (a)
- le pire des cas - en supposant que tout va mal (b)
- la supposition réelle - ce que vous pensez qu'il faudra probablement (c)
Votre estimation est alors (a + b + 2c)/4
- Non, ce ne sera pas précis. Il existe de meilleures façons d'estimer, mais cette méthode est rapide, facile à comprendre et atténue l'optimisme en vous faisant considérer le pire des cas.
- Oui, vous devrez expliquer à votre responsable que vous n'êtes pas familier avec le code et qu'il est trop imprévisible pour vous de faire des estimations fermes et précises sans passer beaucoup de temps à enquêter sur le code à chaque fois pour améliorer l'estimation (proposez de le faire mais disons que vous avez besoin de n jours juste pour donner une estimation ferme du nombre de jours qu'il faudra). Si vous êtes un "JuniorDev", cela devrait être acceptable pour un manager raisonnable.
- Vous devez également expliquer à votre responsable que vos estimations sont moyennées, basées sur le meilleur des cas, le pire des cas et le cas probable et leur donner vos chiffres qui leur donnent également les barres d'erreur.
- Ne négociez PAS sur une estimation - si votre manager essaie d'utiliser le meilleur des cas pour chaque estimation (ils sont idiots - mais j'en ai rencontré des comme ça) et ensuite vous intimide/vous motive à essayer de respecter la date limite, eh bien, ils vais être déçu parfois. Continuez à expliquer la justification des estimations (meilleur cas, pire cas et cas probable) et continuez de vous rapprocher de la moyenne pondérée la plupart du temps et vous devriez être OK. De plus, pour vos propres besoins, conservez une feuille de calcul de vos estimations et ajoutez vos chiffres réels lorsque vous avez terminé. Cela devrait vous donner une meilleure idée de la façon d'ajuster vos estimations.
Modifier:
Mes hypothèses quand j'ai répondu à ceci:
- L'OP est un développeur junior (basé sur le nom d'utilisateur choisi). Les conseils donnés ne sont donc pas du point de vue d'un chef de projet ou chef d'équipe susceptible de pouvoir réaliser des estimations plus sophistiquées en fonction de la maturité de l'environnement de développement.
- Le gestionnaire de projet a créé un plan de projet comprenant un assez grand nombre de tâches dont la livraison prend plusieurs mois.
- Le PO est invité à fournir un certain nombre d'estimations pour les tâches qui lui sont assignées par son chef de projet qui souhaite un nombre raisonnablement précis (pas une courbe de probabilité :)) à alimenter dans le plan de projet et à utiliser pour suivre les progrès.
- OP n'a pas de semaines pour produire chaque estimation et a été brûlé auparavant en donnant des estimations trop optimistes et veut une méthode plus précise que de mettre le doigt en l'air et de dire "2 semaines, sauf si le code est particulièrement obscur auquel cas 2 mois ou plus".
La moyenne pondérée sur trois points fonctionne bien dans ce cas. Il est rapide, compréhensible pour les non-techniciens et sur plusieurs estimations, il devrait faire la moyenne de quelque chose qui s'approche de la précision. Surtout si OP prend mon avis sur la tenue des registres des estimations et des chiffres réels. Lorsque vous savez à quoi ressemblent un "pire cas" et un "meilleur cas" du monde réel, vous pouvez introduire les chiffres réels dans vos estimations futures et même ajuster les estimations pour votre chef de projet si le pire des cas est pire que vous ne le pensiez.
Faisons un exemple concret:
- Dans le meilleur des cas, par expérience, le plus rapide dont j'ai fait un vraiment simple était une semaine du début à la fin (5 jours)
- Le pire des cas, par expérience, il y a eu ce temps où il y avait des liens partout et ça a fini par me prendre 6 semaines (30 jours)
- Estimation réelle, cela me prendra probablement 2 semaines (10 jours)
5 + 30 + 2x10 = 55
55/4 = 13,75, c'est ce que vous dites à votre PM. Vous arrondissez peut-être jusqu'à 14 jours. Au fil du temps (par exemple, dix tâches), il devrait être moyen.
N'ayez pas peur d'ajuster la formule. Peut-être que la moitié des tâches finissent par des cauchemars et seulement dix pour cent sont faciles; vous faites donc l'estmate a/10 + b/2 + 2c/5. Apprenez de votre expérience.
Remarque, je ne fais aucune hypothèse sur la qualité du PM. Un mauvais PM donnera une courte estimation au comité de projet pour obtenir l'approbation, puis intimidera l'équipe de projet pour essayer d'atteindre le délai irréaliste auquel ils se sont engagés. La seule défense est de garder un enregistrer afin que vous puissiez être vu donnant vos estimations et se rapprocher d'eux.
Ce pourrait être le bon moment pour introduire une approche quasi-agile. Si, au lieu d'estimer en termes d'heures/jours, vous avez attribué une échelle de type fibonacci et donné à chaque tâche une valeur basée sur sa taille:
- 0 - instantané
- 0,5 - victoire rapide
- 1 - changement simple
- 2 - quelques changements simples
- 3 - plus difficile
- 5 - nécessitera une réflexion
- 8 - beaucoup de travail
- 13 - Un gros morceau de travail qui doit probablement être décomposé
- 20 - Un gros morceau de travail qui doit absolument être décomposé
Ensuite, une fois que vous avez estimé un tas de tâches comme celle-ci, vous y travaillez. Dans un environnement agile, vous développez la "vitesse" qui est une mesure du nombre de points que vous atteignez, disons, une semaine. Une fois que vous avez fait quelques semaines de test et d'apprentissage (vous pouvez le vendre à votre manager dans le cadre du processus - "J'aurai besoin de quelques semaines de test et apprendre à comprendre le processus d'estimation"), vous serez plus confiant dans le nombre de points que vous pouvez transmettre chaque semaine et vous pouvez donc traduire votre estimation de points plus rapidement en temps.
https://stackoverflow.com/questions/9362286/why-is-the-fibonacci-series-used-in-agile-planning-poker
Ce n'est pas vraiment agile car cela n'impliquerait pas les cérémonies, mais j'ai eu l'idée du PO qu'il était seul. Espérons que cette approche pourrait donner des estimations plus confiantes.
La première chose que vous faites est de commencer à collecter des données sur le temps qu'il vous faut pour faire quoi que ce soit maintenant. Plus vous avez de données sur les performances de votre équipe, mieux c'est. Ça va être partout, mais ne vous inquiétez pas pour le moment. C'est la vérité et vous devez montrer à votre patron la réalité.
Ensuite, vous allez acheter quelques livres.
- Estimation logicielle: démystifier l'art noir par Steve McConnell
- Travailler efficacement avec Legacy Code par Michael Feathers
Le livre de McConnell va vous dire de commencer à collecter des données, puis d'expliquer comment les utiliser pour obtenir des estimations plus précises. Donnez toujours une estimation de 3 points! Toujours. Assurez-vous de mettre en évidence les parties du livre qui parlent de la qualité médiocre du code qui fera exploser vos estimations. Montrez-les à votre patron.
Expliquez que si des estimations précises sont importantes pour l'entreprise, vous devrez commencer à appliquer les choses que vous apprenez du livre de Feather. Si vous voulez aller rapidement, en douceur et de manière prévisible, vous devrez commencer à refactoriser le code et à l'intégrer dans un faisceau de test. J'ai été là où tu es. Le temps de développement est complètement imprévisible car vous n'avez aucune idée de ce que vous pourriez éventuellement casser, non? ... Ouais. Mettez-le dans un harnais de test. Un serveur CI pour exécuter ces tests ne pouvait pas faire de mal non plus.
Enfin, expliquez à votre patron que les choses vont encore être un peu imprévisibles pendant un certain temps. Probablement quelques années, mais ce développement deviendra plus facile au quotidien et les estimations deviendront plus précises à mesure que vous aurez plus de données et que le code s'améliorera. Il s'agit d'un investissement à long terme pour l'entreprise. J'ai vécu cela récemment, il a fallu près de 2 ans pour devenir principalement prévisible.
Je sais que j'ai parlé davantage d'améliorer le code que d'estimer, mais la dure vérité est que vos estimations seront moche jusqu'à ce que vous puissiez apprivoiser la base de code héritée. En attendant, utilisez les performances historiques pour évaluer le temps que cela prendra. Au fil du temps, vous devrez prendre en compte si vous avez déjà mis le code en conformité avec vos spécifications.
Maintenant, mon patron me demande à juste titre une estimation du temps qu'il faudrait pour écrire la fonctionnalité X dans la nouvelle architecture. Mais j'ai du mal à arriver à une estimation réaliste; souvent, je sous-estime la tâche pour les raisons que j'ai mentionnées ci-dessus et je m'embarrasse parce que je ne peux pas terminer à temps.
Vous pensez peut-être dans la case de soumettre une estimation. Je dois travailler en code hérité, et lorsque je fais une estimation plus formelle, j'en fais généralement deux ou trois :
- Estimation primaire - en supposant que je doive passer un peu de temps à creuser mais l'architecture permet les changements que nous voulons
- Estimation angélique - suppose que tout est transparent/facile à trouver et je n'ai qu'à apporter des modifications mineures (c'est celle que je laisse parfois de côté ... surtout si je sais qu'il n'y a que des démons dans une base de code particulière)
- Abyssal Estimate - suppose que la structure fondamentale du code hérité est incompatible avec la fonctionnalité demandée et je devrai faire un remaniement majeur pour faire fonctionner les choses
Les trois estimations tiennent compte de la solidité de la fonctionnalité en elle-même, de toute expérience que j'ai eue avec cette base de code générale et de mon intuition sur le changement (que j'ai trouvé peut être assez précis)
Après la publication de ces estimations, je tiens à jour mon gestionnaire à laquelle il semble que nous ayons affaire. S'il s'avère que nous examinons une caractéristique abyssale, nous devrons peut-être la sacrifier - c'est arrivé. Si votre patron ne peut pas accepter qu'il existe des caractéristiques abyssales pour un morceau donné de code hérité, alors je leur souhaite bonne chance, car ils auront une vie très difficile et frustrante.
Lorsque j'ai été confronté à ce genre de problème, je me suis appuyé sur la fourchette de mes estimations. Je me suis contenté de dire à mes patrons "il est difficile de faire de bonnes estimations spontanées sur cette base de code. Si vous en demandez une, ce sera une estimation très large." J'ai donné "3 jours à 3 ans" comme estimation une fois. Inutile de dire que ce n'était pas une estimation populaire, mais c'est ce que j'ai donné.
La clé de tout cela est un accord selon lequel je mettrai à jour mes estimations au fur et à mesure de l'avancement des travaux. Donc, si on me dit "Mettre en œuvre XYZ, combien de temps cela prendra-t-il?" ma réponse pourrait être "quelque part entre un jour et 4 mois. Cependant, si vous me laissez réellement regarder le code pendant quelques heures, je peux réduire l'incertitude dans cette fenêtre." Je vais ensuite regarder le code et revenir avec "2 à 4 semaines". Ce n'est toujours pas une fenêtre idéale, mais au moins c'est quelque chose qui peut être géré.
Il y a quelques clés à cela:
- Convainquez le patron que ces estimations sont mieux traitées comme une conversation parce que vous en apprendrez plus à quoi ressemble la tâche pendant que vous la travaillez. C'est l'occasion pour votre patron d'avoir des informations qu'il n'aurait pas s'il ne demandait qu'une seule estimation.
- Offrez des options sur la façon d'aller de l'avant avec la vitesse de développement du code commercial par rapport à l'amélioration des estimations. Donnez-leur un bouton supplémentaire qu'ils peuvent tourner. Parfois, les patrons savent qu'une tâche doit simplement être accomplie, et ils n'ont besoin que d'une estimation approximative. D'autres fois, ils exécutent les avantages et les inconvénients d'une tâche, et la capacité d'affiner les estimations est précieuse.
- Si possible, je proposerai également des bonus de synergie. Il y a souvent des améliorations architecturales qui auraient des avantages pour de nombreuses tâches. Si j'ai 10 tâches qui prennent toutes "1 à 2 mois maintenant, mais qui prendraient 2 semaines avec la mise à niveau X", il est plus facile de vendre les 20 semaines nécessaires à la mise à niveau X.
Si j'ai un patron qui n'est pas à l'aise de recevoir une gamme qui est mise à jour au fur et à mesure, je vais lui donner un numéro unique et ma méthodologie. Ma méthodologie est une combinaison d'une règle de base, m'a-t-on dit en tant que jeune développeur, et loi de Hofstader .
Estimez combien de temps vous pensez que la tâche devrait prendre, puis quadruplez ce nombre et donnez-le comme estimation.
et
La loi de Hofstadter: "Cela prend toujours plus de temps que prévu, même si vous tenez compte de la loi de Hofstadter."
La chose sensée peut sembler vraiment entrer dans le code, noter chaque branche et appels à d'autres fonctions, puis estimer le coût en temps. Mais il y a vraiment une minuscule différence entre documenter l'ancien code et écrire réellement la nouvelle version.
Ceci est la solution à votre problème. Vous ne pouvez pas estimer si vous n'avez aucune exigence. Dites à votre patron que vous devrez le faire avant de pouvoir commencer à coder. Après quelques fonctions et modules, vous découvrirez peut-être qu'ils ont tous été codés de manière cohérente (dans ce cas, mal), vous avez donc une base de référence pour déterminer les estimations futures. Assurez-vous simplement d'ajuster votre estimation si vous découvrez que le codage empire.
Je sais que votre patron veut une estimation, mais sans savoir comment ces informations sont utilisées, nous ne savons pas à quel point vos estimations doivent être exactes. Ayez une conversation avec lui et découvrez-le. S'il a juste besoin d'un nombre pour donner à son patron, vous pouvez gonfler légèrement les estimations et fournir un nombre. Pour les clients qui attendent de payer pour votre code jusqu'à ce que cela soit fait, assurez-vous de savoir si les dates d'échéance des lignes fixes vont générer des revenus importants.
Dans une situation comme celle-ci, je ne pense pas qu'il soit possible de donner de bonnes estimations. Le problème de base est que souvent une grande partie de cette tâche consiste à déterminer exactement ce qui doit être fait.
Je gère des cas comme celui-ci en donnant une estimation basée sur ce que cela semble impliquer mais avec le cavet que des surprises sont probables. Bien que je n'aie pas eu à faire face à beaucoup de code hérité, j'ai eu de très mauvaises surprises concernant la saisie - j'ai vu quelques heures se transformer en quelques semaines et une fois en c'est impossible (après fouilles considérables, j'ai compris que je n'avais pas assez de données dans un certain cas, retour à la planche à dessin.) Heureusement, mon patron comprend quand je donne de telles estimations.