La meilleure façon de planifier la programmation pour les petites équipes? [fermé]

Je suis le directeur d'une petite organisation en démarrage. Nous avons actuellement deux programmeurs (un expérimenté, un moins expérimenté) qui construisent une plate-forme d'application Web.

Jusqu'à présent, l'un des plus grands défis est le processus de planification. Les programmeurs sont généralement chargés de planifier leur propre travail, mais nous continuons à dépasser leurs délais auto-imposés. Par exemple, une tâche qui, selon eux, prendra 2 jours finit par prendre 8 jours.

Pour moi, il est difficile de les soutenir dans la planification, car je n'ai pas le savoir-faire technique pour estimer avec précision la durée d'une certaine tâche.

Avez-vous une idée:

1. Quelle est la raison de cela, est-ce commun pour les programmeurs?
2. Que puis-je faire pour les aider à planifier? Existe-t-il des méthodes ou des outils utiles aux programmeurs en petites équipes?

Les techniques générales sont un peu de bon sens, la chose importante à savoir est qu'elles ne nécessitent pas beaucoup d'expertise technique.

Le point de départ de la planification est d'identifier le problème exact qui doit être résolu et d'avoir une exigence claire et sans ambiguïté. Si vous ne l'avez pas, vos estimations seront incorrectes. Le fait de documenter cela dans une sorte de spécification de fonctionnalité avant que quiconque ne commence à écrire du code signifie que toutes les questions à poser auront été posées avant le début du codage. Il s'agit d'un gain de temps étonnamment efficace. Revenir en arrière et clarifier les exigences brise le flux en tant que programmeur et attendre des réponses peut bloquer les progrès.

Une fois que vous avez identifié l'exigence, vous devez identifier les tâches de travail impliquées dans sa résolution. Il s'agit d'un exercice classique de division et de conquête - toute tâche qui peut être décomposée doit être décomposée davantage.

Dans une équipe plus grande, vous pouvez utiliser l'estimation poker pour obtenir une estimation basée sur l'expérience de toutes les personnes impliquées. Cela ne fonctionne pas aussi bien dans une équipe plus petite, mais il est toujours utile d'obtenir une estimation indépendante de vos deux développeurs et peut-être d'en inclure une de vous-même - votre manque d'expertise spécifique peut être utile ici car en vous expliquant ce que la tâche implique de leur point de vue, l'équipe de développement comprendra probablement mieux le problème.

Avec une équipe plus petite, cela peut aider à obtenir une estimation du meilleur / attendu / pire cas pour chaque tâche, ce qui vous donne une plage de valeurs, mais si vous obtenez beaucoup d'estimations de dépassement, vous pouvez incliner vers le pire des cas jusqu'à ce que vos développeurs apprendre à estimer plus précisément.

Dans une petite boutique, les développeurs finissent souvent par doubler d'administrateurs système, d'équipe de support et même de testeurs (bien que de toutes les choses qu'ils pourraient faire, le test soit celui que vous devriez essayer d'éviter à tout prix), vous devez donc en tenir compte. Calculez combien de temps vos développeurs passent réellement à travailler sur de nouvelles fonctionnalités et intégrez-les à vos estimations. Si une tâche est estimée à 2 jours mais que vos développeurs ne sont capables de travailler sur de nouveaux développements que 60% du temps, vous aurez besoin de 4 jours pour qu'elle soit terminée. Vous pourriez également être en mesure d'aider à cela en contrôlant le pipeline d'autres tâches dont ils ont besoin pour gérer de sorte que les tâches d'administration ou de support non urgentes puissent être regroupées quelque peu plutôt que d'être gérées de manière ponctuelle. Beaucoup de programmeurs (y compris certainement moi-même sur celui-ci) ne sont pas de bons gestionnaires de temps, donc tout ce que vous pouvez faire pour prêter main forte à cet égard vous sera utile. Les tâches simples sont toujours plus faciles pour les programmeurs que les tâches multiples. Bloquer le temps pendant la journée peut également vous aider.

Gardez une trace - chaque fois que vous avez une session de planification, enregistrez les estimations et les chiffres réels. Vous pouvez ensuite utiliser ceci a) comme un guide pour savoir combien gonfler leurs estimations pendant la planification et b) pour les aider à affiner leurs compétences d'estimation. À la fin de chaque itération (ou l'équivalent que vous avez), toute l'équipe devrait revoir le travail qui a été fait et comprendre pourquoi cela a pris plus de temps que prévu afin que cela puisse être incorporé dans les estimations futures. Cela doit être une tâche irréprochable - vous semblez avoir la bonne attitude ici, mais cette réponse peut prendre environ un certain temps, donc je ferai l'observation. Si quelqu'un dit "J'ai fait une erreur ici", vous pouvez transformer cela en "qu'est-ce que vous auriez pu faire mieux", mais dire aux gens qu'ils ont été trop lents ou ont mal tourné ne fera qu'empirer les choses.

Je ne connais pas de solution miracle pour ce type de problème, mais le principal facteur est la communication - qui est en fait plus facile avec une équipe plus petite - et l'utilisation des commentaires pour affiner vos compétences collectives.

Quelle est la raison de [leur estimation de 2 jours sur 8 jours], est-ce courant pour les programmeurs?

C'est, si:

• Il n'est pas vraiment clair ce qu'ils sont censés faire, donc ils prennent plus de temps pour bien faire les choses (et ils devraient alors le dire, ne pas deviner combien de temps cela prendra)
• Ils ne sont pas familiers avec la tâche à accomplir (alors ils devraient le mentionner et inclure la recherche dans l'estimation)
• L'intégration de la tâche terminée avec le produit plus volumineux prend plus de temps que prévu (ce qui pourrait signifier que l'architecture du produit est inférieure)
• Le développeur aime réinventer la roue, et ce faisant, il bute sur des problèmes qui ont été résolus par d'autres, disponibles gratuitement dans une bibliothèque
• Des changements sont introduits par le propriétaire du produit pendant la mise en œuvre de la tâche, nécessitant une approche différente et le rétablissement du travail déjà effectué
• Les développeurs ne travaillent pas dans un environnement productif (donc à la maison, ils pensent que cela prendrait deux jours, mais au travail, ils en auront besoin de huit pour compenser toutes les distractions)

Pour nommer quelques choses.

Il est peut-être préférable de demander à vos développeurs pourquoi ils pensent que leurs estimations sont loin. :-)

Vous ne seriez pas le premier à essayer de trouver la meilleure façon de planifier le temps de développement. Cela est en partie dû au fait qu'il est difficile de quantifier quelque chose que vous ne pouvez pas réellement voir être construit, et en partie à cause du mois-homme mythique , qui est un contraste direct avec l'idée intuitive que si vous avez 2 programmeurs, vous devriez être en mesure de développer deux fois plus vite que si vous aviez 1 programmeur.

Comme vous l'avez probablement déjà réalisé, c'est beaucoup plus compliqué que cela. Une approche pour estimer le temps de développement consiste à arrondir un groupe de personnes hautement qualifiées pour ce qui concerne le développement de logiciels et leur demander d'estimer le temps qu'il faudrait pour terminer un projet (en expliquant le plus en détail possible). Vous prenez le plus élevé de toutes les estimations et vous le doublez . Oui, vous avez bien lu. Vous doublel'estimation la plus élevée et vous aurez une estimation raisonnablement précise. Je sais, car avec le temps, c'est ainsi que j'ai pu dire avec précision à mes patrons combien de temps il me faut pour faire quelque chose. Je recueille les opinions de mes collègues programmeurs et les miennes et double l'estimation la plus élevée. Si cela semble trop élevé, considérez que le test de nouvelles fonctionnalités est crucial et envisagez des corrections de bugs potentiels par la suite, et cela semblera plus raisonnable.

Dans ma propre expérience personnelle en tant que programmeur, je peux vous dire que cela aide à décomposer les projets en étapes. Combien de temps faut-il pour atteindre le jalon 1, puis du jalon 1 au jalon 2, puis du jalon 2 au jalon 3, etc.? Lorsqu'elle est décomposée comme ceci, la réponse est généralement beaucoup plus précise que d'essayer d'estimer l'ensemble du projet dans son intégralité. Curieusement, si vous résumez les estimations de toutes ces étapes, elles seront généralement plus importantes que l'estimation originale sur l'ensemble du projet (si le programmeur est honnête avec lui-même de toute façon), ce qui m'amène à penser que le détail est la clé ici.

Peut-être que vous manquez du savoir-faire technique, mais vous devriez toujours essayer de suivre à un niveau plus général. Les programmeurs n'ont aucun problème avec la répétition. Ce sont les rebondissements qui occupent tout le temps à développer un programme. Donc, très probablement, plus vous souhaitez inclure de fonctionnalités, plus le programme deviendra compliqué, et en supposant que cette nouvelle fonctionnalité n'a aucune influence sur les sections du code précédemment implémentées, le développement sera linéaire en fonction de la quantité de travail à être terminé. Très probablement, les nouvelles fonctionnalités influencent fortement les sections précédemment implémentées et donc le développement implique non seulement d'implémenter les nouvelles fonctionnalités mais de réparer l'ancien code, ce qui rend le temps de développement exponentiel.

Mon conseil serait de, sans dire aux programmeurs comment faire leur travail, essayer de comprendre comment le programme fonctionne à un niveau général et vous devriez bientôt pouvoir voir comment de nouvelles fonctionnalités modifieraient ce comportement et fourniraient ainsi une estimation raisonnable du temps qu'il faudrait pour le faire. Combinez cela avec leurs estimations (le double du plus élevé) et vous commencez à avoir une meilleure idée de la façon d'estimer le temps de développement.

J'espère que ça aide!

L'une des raisons pour lesquelles les estimations sont souvent éloignées est que l'estimation est en fait assez difficile et nécessite de changer l'expérience et les connaissances sur le système. Le plus souvent, il est utile de diviser les grandes étapes en plus petites.

Maintenant, vous avez de nombreuses possibilités, je vais en mentionner deux:

• Planification de poker
• PERT (Technique d'évaluation et d'examen des programmes)

Planification de poker

Cela fonctionne assez bien dans les petites équipes agiles.

Extrait de wikipedia:

• Un modérateur, qui ne jouera pas, préside la réunion.
• Le chef de produit fournit un bref aperçu. L'équipe a la possibilité de poser des questions et de discuter pour clarifier les hypothèses et les risques. Un résumé de la discussion est enregistré par le chef de projet.
• Chaque individu dépose une carte face cachée représentant son estimation. Les unités utilisées varient - elles peuvent être d'une durée de jours, de jours idéaux ou de points d'histoire. Pendant la discussion, les nombres ne doivent pas du tout être mentionnés par rapport à la taille de l'entité pour éviter l'ancrage.
• Chacun appelle ses cartes simultanément en les retournant.
• Les personnes ayant des estimations élevées et des estimations basses reçoivent une boîte à savon pour justifier leur estimation, puis la discussion se poursuit.
• Répétez le processus d'estimation jusqu'à ce qu'un consensus soit atteint. Le développeur qui était susceptible de posséder le livrable dispose d'une grande partie du «vote de consensus», bien que le modérateur puisse négocier le consensus.
• Un sablier est utilisé pour s'assurer que la discussion est structurée; le modérateur ou le chef de projet peut à tout moment retourner le sablier et quand il est épuisé, toute discussion doit cesser et une autre partie de poker est jouée. La structure de la conversation est réintroduite par les boîtes à savon.

Les éléments importants ici sont la clarification, la discussion, l'appel simultané de l'estimation, de sorte qu'aucun biais n'est introduit, et le consensus.

PERT

Il est souvent difficile de donner une estimation exacte. Ce qui est plus facile, c'est de donner une probabilité. PERT utilise 3 valeurs pour l'estimation:

• temps le plus optimiste pour terminer (si moins de problèmes surviennent que prévu)
• le temps le plus pessimiste pour terminer (si tout va mal - à l'exclusion des catastrophes majeures)
• le temps le plus probable pour terminer (si tout se passe comme prévu) <- c'est ce que vos développeurs estiment le plus probable en ce moment

En pondérant ces trois estimations, vous obtenez une estimation plus fiable.

t_expected = (t_opt + 4 * t_likely + t_pes) / 6

Et / ou vous pouvez utiliser ces trois valeurs pour construire une distribution de probabilité qui peut refléter encore plus l'incertitude du monde réel. La distribution bêta et la distribution triangulaire sont des choix importants. En utilisant cela, vous pouvez maintenant appliquer des statistiques comme «quelle est la probabilité de terminer à la date x compte tenu des estimations actuelles» ou «si je veux une certitude de 95%, à quel moment cela sera-t-il terminé».

En fait, PERT comprend plus que ces aspects mentionnés ici, que j'ai omis par souci de concision.

C'est un fait que si vous ne conservez pas les mesures historiques, vous ne pouvez même pas vous rapprocher de donner des estimations raisonnables avec un degré de précision raisonnable. Et demander à une autre entreprise / personne combien de temps cela leur prendra n'aidera pas non plus. Le problème est que chaque entreprise et développeur a sa propre façon de faire. Ainsi, chaque entreprise aura différentes durées pour effectuer exactement la même tâche. Chaque développeur aura différentes durées pour effectuer exactement la même tâche.

Votre meilleur plan d'action est de commencer à suivre le temps et de trouver en quelque sorte comment classer le degré de difficulté de la tâche. Certaines entreprises utilisent des lignes de code, certaines utilisent des fonctionnalités, d'autres se contentent de faire preuve d'intuition. De plus, vous devez également prendre en compte si cela est similaire à quelque chose que les développeurs ont déjà construit ou à quelque chose de nouveau, comme une nouvelle technologie, une nouvelle fonctionnalité jamais construite auparavant par l'équipe, etc. système de temps, puis la complexité augmente généralement un peu.

À moins que vous ne collectiez de vraies données, peu importe le nombre de fois où vos développeurs vous donnent des estimations, ils tireront juste des chiffres de leur derrière chaque fois que vous leur demanderez. Oui, la collecte de données réelles est pénible et au début, elle ne fournit pas beaucoup d'informations utiles, mais au fil du temps, elle commence vraiment à fournir des estimations raisonnablement précises.

Je voudrais également souligner que les estimations ne sont généralement bonnes que dans l'ensemble et non pour des mesures à court terme. Par exemple, le développeur estime 2 jours mais cela prend 8. Eh bien, le développeur n'a pas tenu compte de la configuration d'un environnement de test et du développement d'un simulateur ou qu'il y avait une technologie entièrement nouvelle qu'ils devaient apprendre ou qu'ils étaient bloqués sur un bug ils ne pouvaient pas comprendre ou la fonctionnalité nécessitait une refactorisation du système existant. Vous ne pouvez pas toujours prévoir ce genre de choses pour de petites tâches. Cependant, au cours d'un projet entier, ces 6 jours supplémentaires peuvent être éliminés par d'autres tâches prenant 6 jours de moins.

J'ai été un développeur unique sur quelques petits projets par moi-même et j'ai une certaine expérience industrielle en travaillant avec une grande équipe. J'ai remarqué que les techniques utilisées par une grande entreprise ne fonctionnent pas nécessairement pour une petite équipe. À un moment donné, je faisais plus de planification et de documentation que d'écrire du code. Je vous suggère d'essayer de trouver d'abord un bon moyen de travailler en essayant différentes techniques (les autres réponses fournissent de très bonnes informations) et des outils, cela vous coûtera du temps et des efforts mais vous en bénéficierez plus tard. Voici quelques outils / techniques que j'ai trouvés utiles:

-Pivotal Tracker - Excellent programme pour garder une trace des histoires et encourage la ventilation des tâches, il s'éclaircit rapidement lors de la saisie des histoires et déduit automatiquement la vitesse. https://www.pivotaltracker.com/ .

-Gdocs pour la documentation car il est facile d'avoir plusieurs utilisateurs éditant et discutant en même temps.

-Dans une entreprise pour laquelle je travaillais, nous avions une réunion pour chaque histoire que nous avons lancée, cette réunion devait inclure un programmeur principal car il serait mieux à même de juger du temps qu'une tâche prendrait. Il serait également mieux à même de juger de la partie difficile d'une tâche.

En résumé, je crois que la clé du travail en petites équipes est d'avoir un régime de planification solide, rapide et fluide. De plus, toute difficulté avec l'histoire peut être identifiée tôt afin que la planification d'une tâche garde cela à l'esprit (cela pourrait conduire à construire quelque chose différemment).

J'espère que cela t'aides