Comment gérer une méthode non encore implémentée qui sera réalisée par un co-programmeur?

45

C'est une question sur la façon de travailler en équipe.

Récemment, j'ai travaillé sur mon premier projet de programmation plus important (~ 80 classes, Java) avec une équipe de 6 personnes, bien que seulement 4 d'entre nous travaillions continuellement sur le code. Nous avons distribué le travail à faire très tôt et, à un moment donné, j'ai dû appeler une méthode qui n'avait pas encore été mise en œuvre par l'un de mes co-programmeurs. Comment est la façon recommandée de traiter avec cela?

Les options que j'ai vues, bien que je n'aime pas vraiment l'une d'entre elles:

  1. Ecrire moi-même //TODOet revoir cette ligne de code ultérieurement pour vérifier si la méthode a été implémentée entre-temps.

  2. Demander au membre de l'équipe correspondant de le mettre en œuvre maintenant .

  3. Lancer une exception personnalisée runtimeException avec une description claire de ce qui n'a pas encore été implémenté. (Au moins, nous n'avons pas à chercher longtemps pour savoir ce qui manque.)

  4. En ajoutant la méthode nécessaire à leur classe et en leur écrivant un //TODOdans le corps du message, vous pouvez également leur envoyer un message rapide à propos de cette modification. (Maintenant ce n'est plus mon problème, mais cela peut causer des conflits de fusion gênants s'ils travaillaient sur cette méthode entre-temps)

  5. Définir des classes abstraites ou des interfaces pour tout avant d'écrire le code qui fait le travail. (Cela ne fonctionnait pas très bien car ces interfaces étaient souvent changées)

teamwork lucidbrot
la source
51
Je pense que le flux de travail où vous avez besoin d'une méthode écrite par quelqu'un d'autre n'est pas la bonne. Vous travaillez sur une fonctionnalité. Si cette fonctionnalité nécessite une méthode, vous l'implémentez. Si deux personnes doivent implémenter une fonctionnalité unique, elles s'appairent soit, soit s'intègrent et communiquent si souvent que cela ressemble presque à une association.
Euphoric
8
@Euphoric Plusieurs fois, j'ai rencontré une situation dans laquelle une toute nouvelle fonctionnalité devait être développée dans un délai relativement court. L'interface utilisateur, la logique métier et les couches d'API devaient donc être scindées en différentes tâches sur lesquelles travailler simultanément, sinon la date limite ne pourrait jamais être respectée. C'est précisément à cet endroit qu'une personne travaillant sur l'interface utilisateur ne devrait déclarer les méthodes d'accès aux données et les commandes à BL comme des interfaces et laisser les autres personnes travailler sur la mise en œuvre, tout en travaillant uniquement sur l'interface utilisateur.
Andy
15
@DavidPacker Ce que vous décrivez n'est pas le seul moyen de résoudre ce problème. Les tranches verticales, l'intégration fréquente, les petites fonctionnalités sont toutes de meilleures solutions que les tranches horizontales, chaque personne travaillant sur une pièce distincte.
Euphoric
3
@Euphoric, je ne peux pas être plus d'accord avec vous. Dans la mesure du possible, nous choisissons de supprimer la nouvelle fonctionnalité complexe des parties non critiques (à savoir celles qui ne feraient qu'améliorer l'UX mais ne sont pas nécessaires tout de suite). Malheureusement, parfois les options que vous avez mentionnées, ni la suppression de fonctionnalité, sont impossibles. Les entreprises disent, les développeurs font. Par conséquent, même si vos arguments sont solides, il est également probable que quelqu'un rencontrera et rencontrera une situation dans laquelle un type de travail doit être scindé pour répondre aux besoins de l'entreprise.
Andy
2
Qu'en est- il de parler de lui à la façon dont il veut gérer?
Aganju

Réponses:

5

C'est une question intéressante et la réponse pourrait être plus facile que vous ne le pensez.

En termes simples, écrivez des tests qui valident vos hypothèses. Peu importe que vous réalisiez l’implémentation ou que vos collègues programmeurs

La longue réponse.

Chacune des options que vous avez répertoriées est quelque peu passive et vous oblige à revenir au code le cas échéant (le cas échéant) tôt ou tard.

  • Les commentaires doivent être lus et traités par votre homologue responsable de la mise en œuvre. Votre code ne peut pas être compilé entre-temps. Si vous vérifiez un tel état dans un référentiel de code, votre pipeline d'intégration continue ne fonctionnera pas et il est de toute façon douteux ... de ne jamais vérifier en code erroné
  • Les exceptions à l'exécution semblent meilleures, mais restent toxiques, car votre collègue programmeur pourrait supposer que la mise en œuvre a déjà été effectuée sans vérification, laissant ainsi le système dans un état instable. Si la méthode n'est pas déclenchée si souvent, cela pourrait conduire à un code de production cassé ... mauvaise pratique également ... ne jamais vérifier les exceptions "non implémentées"
  • Il est également décourageant d’ attendre que vos collègues programmeurs mettent en œuvre les méthodes ou un stub. Cela casse votre flux de travail et celui de vos collègues programmeurs. Que se passe-t-il s'ils sont malades, lors d'une réunion, d'une pause-café, voulez-vous passer votre temps à attendre? ... n'attends pas quelqu'un si tu n'es pas obligé
  • implémenter les méthodes manquantes définitivement le meilleur moyen d'aller de l'avant. Mais que se passe-t-il si votre implémentation ne satisfait pas le cas d'utilisation dans son ensemble et que vos collègues programmeurs doivent le modifier ou le modifier? Comment vous et eux vous assurez-vous qu'il est toujours compatible avec votre destination? La réponse est facile à nouveau. Rédigez des tests qui vérifient, décrivent et documentent vos intentions. Si les tests se brisent, il est facile de s'en rendre compte. Si des modifications de cette méthode doivent être apportées, cela casse votre fonctionnalité ... vous la voyez immédiatement. Vous avez tous les deux une raison de communiquer et de décider quoi faire. Diviser la fonctionnalité? Modifiez votre implémentation, etc ... ne contrôlez jamais dans du code qui n'est pas suffisamment documenté par les tests

Pour atteindre un niveau de test suffisant, je vous suggère d’examiner deux disciplines.

  1. TDD - développement piloté par les tests - cela vous permettra de décrire votre intention et de la tester suffisamment. Il vous donne également la possibilité de simuler ou de simuler des méthodes et des classes (également en utilisant des interfaces) qui ne sont pas encore implémentées. Le code et les tests seront toujours compilés et vous permettront de tester votre propre code indépendamment du code de vos collègues programmeurs. (voir: https://en.wikipedia.org/wiki/Test-driven_development )

  2. ATDD - développement basé sur des tests d'acceptation - ceci créera une boucle externe (autour de la boucle TDD) qui vous aidera à tester la fonctionnalité dans son ensemble. Ces tests ne vireront au vert que lorsque l'ensemble de la fonctionnalité sera mise en œuvre, vous donnant ainsi un indicateur automatique lorsque vos collègues auront terminé leur travail. Très chouette si vous me demandez.

Mise en garde: Dans votre cas, je n’écrirais que des tests d’acceptation simples et je n’essaierais pas d’intégrer trop le côté commercial, car ce serait trop pour commencer. Rédigez des tests d'intégration simples qui rassemblent toutes les parties du système requises par la fonctionnalité. C'est tout ce qui est requis

Cela vous permettra de placer votre code dans un pipeline d'intégration continue et de produire une implémentation extrêmement fiable.

Si vous souhaitez approfondir ce sujet, consultez les liens suivants:

Jesko R.
la source
103

Demandez des talons.

Ou écrivez-les vous-même. Dans les deux cas, vous et vos collègues devez vous mettre d'accord sur les interfaces et sur la manière dont elles sont destinées à être utilisées. Cet accord doit être relativement solidifié pour que vous puissiez développer contre les talons - pour ne pas dire, afin que vous puissiez créer vos propres simulacres pour vos tests unitaires ...

svidgen
la source
25
^^ ceci. Si vous utilisez correctement les interfaces, vous ne devriez pas avoir besoin de l'implémentation tant que l'autre type n'a pas fini de les écrire.
Robert Harvey
13
Et pour compléter le commentaire de Robert, si vous n'utilisez pas correctement les interfaces dans un projet spécialement conçu pour être partagé entre plusieurs personnes, eh bien, vous allez passer un mauvais moment ...
corsiKa
1
C'est dommage que Java n'ait pas de fichiers d'en-tête. Dans le monde C / C ++, vous pouvez élaborer vos API et écrire tous vos en-têtes en premier. Un manque d'implémentation devient alors un problème pour l'éditeur de liens. (Légère simplification, l’ABI doit également rester constante pour que ce soit simplement une question d’éditeur de liens).
Wes Toleman
16
@WesToleman Curieusement, l'une des choses que je préfère à propos de Java est qu'il ne possède pas de fichiers d'en-tête. Les "interfaces" mentionnées par Robert et corsiKa remplissent parfaitement ce rôle. Vous travaillez d’abord sur vos API, écrivez les interfaces et un manque d’implémentation concrète n’est pas un problème pour le compilateur.
GrandOpener
1
@WesToleman Cela vous convient-il? À mes oreilles, cela ressemble beaucoup à un style de chute d’eau, et j’imagine que vous devez mettre à jour l’interface davantage lorsque vous réalisez que vous avez mal géré ce "paramètre important"?
netigger
6

Dans votre cas, je parlerais au membre de l'équipe responsable de cette fonction. Il se peut qu’ils soient en mesure de donner la priorité au développement de cette fonction afin que vous puissiez commencer à l’utiliser plus tôt.

Je voudrais éviter votre quatrième option. Vous avez écrit tout votre code et, comme vous le dites, vous ne considérez plus que c'est votre problème. Votre collègue écrit ensuite l'implémentation de la fonction et ne considère plus que c'est leur problème. Qui va réellement vérifier que le code que VOUS avez écrit fonctionne correctement?

Pete
la source
Vous devriez demander l' API pour cette fonction, ce qui devrait donner lieu à une ou plusieurs interfaces. Ce serait peut-être une bonne idée de le faire ensemble, car vous devrez utiliser cette interface pour pouvoir concevoir les scénarios de test initiaux en fonction de vos entrées. La mise en oeuvre réelle peut alors intervenir plus tard (modifications API éventuelles comprises)
Thorbjørn Ravn Andersen