web-dev-qa-db-fra.com

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

Il s'agit d'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'était pas encore implémentée par l'un de mes co-programmeurs. Comment est la manière recommandée de gérer cela?

Options que j'ai vues, bien que je n'aime vraiment aucune d'entre elles:

  1. Je m'écris un //TODO et en revoyant cette ligne de code plus tard pour vérifier si la méthode a été implémentée entre-temps.

  2. Demander au membre de l'équipe correspondant de l'implémenter maintenant.

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

  4. Ajouter la méthode nécessaire à la classe leur et leur écrire un //TODO dans le corps du message, peut-être aussi leur envoyer un message rapide sur ce changement. (Maintenant, ce n'est plus mon problème, mais cela peut provoquer des conflits de fusion ennuyeux s'ils travaillaient sur cette méthode entre-temps)

  5. Définir des classes abstraites ou des interfaces pour tout avant d'écrire réellement le code qui fait le travail. (Ne fonctionnait pas trop bien car ces interfaces étaient souvent modifiées)

teamwork
45
lucidbrot

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

Autrement dit, écrivez des tests qui valident vos hypothèses. Ce n'est pas grave si vous faites la mise en œuvre ou vos collègues programmeurs

La réponse longue.

Toutes les options que vous répertoriez sont quelque peu passives et nécessitent que vous revenez et revisitez le code (le cas échéant) tôt ou tard.

  • 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 cet état dans un référentiel de code, votre pipeline d'intégration continue ne fonctionnera pas, et c'est une mauvaise pratique de toute façon ... ne vérifiez jamais le code cassé
  • Exceptions d'exécution semblent meilleurs, mais sont toujours toxiques, car votre collègue programmeur pourrait supposer que l'implémentation a déjà été effectuée sans vérification, laissant le système dans un état instable également. Si la méthode n'est pas déclenchée si souvent, cela pourrait conduire à un code de production cassé ... aussi une mauvaise pratique ... ne jamais archiver les exceptions "non implémentées"
  • En attente de vos collègues programmeurs pour l'implémentation des méthodes ou un stub est également intimidant. Il casse votre flux de travail et le flux de travail de vos collègues programmeurs. Que se passe-t-il s'ils sont malades, lors d'une réunion en g, à la pause-café, voulez-vous passer votre temps à attendre? ... n'attendez pas quelqu'un si vous n'êtes pas obligé
  • implémentez les méthodes manquantes certainement la meilleure façon d'aller de l'avant. Mais que se passe-t-il si votre implémentation ne satisfait pas l'intégralité du cas d'utilisation et que vos collègues programmeurs doivent le modifier ou le changer? Comment vous et eux assurez-vous qu'il est toujours compatible avec votre destination? La réponse est à nouveau facile. Rédigez des tests qui vérifient, décrivent et documentent vos intentions. Si les tests échouent, il est facile de le remarquer. Si des changements dans cette méthode doivent être effectués pour casser votre fonctionnalité ... vous le voyez immédiatement. Vous avez tous les deux une raison de communiquer et de décider quoi faire. Partager la fonctionnalité? Changer votre implémentation, etc ... ne jamais archiver de code qui n'est pas suffisamment documenté par des tests

Pour atteindre un niveau suffisant de tests, je vous suggère de jeter un œil à deux disciplines.

  1. TDD - développement piloté par les tests - cela vous assurera 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 piloté par les tests d'acceptation - cela créera une boucle externe (autour de la boucle TDD) qui vous aidera à tester la fonctionnalité dans son ensemble. Ces tests ne deviendront verts que lorsque l'ensemble de la fonctionnalité sera implémentée, vous donnant ainsi un indicateur automatique lorsque vos boursiers auront terminé leur travail. Assez bien si vous me demandez.

Mise en garde: dans votre cas, je n'écrirais que des tests d'acceptation simples et n'essaierais pas de faire entrer trop de choses dans l'entreprise, car ce serait trop pour commencer. Écrivez des tests d'intégration simples qui rassemblent toutes les parties du système dont la fonction a besoin. C'est tout ce qu'il faut

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

Si vous souhaitez aller plus loin dans ce sujet, consultez les liens suivants:

5
Jesko R.

Demandez des talons.

Ou écrivez-les vous-même. Quoi qu'il en soit, vous et vos collègues devez vous mettre d'accord sur les interfaces et la façon dont elles doivent être utilisées. Cet accord doit être relativement solidifié pour que vous puissiez développer contre des talons - sans parler, afin que vous puissiez créer vos propres simulacres pour vos tests unitaires. .

103
svidgen

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

J'éviterais votre quatrième option. Vous avez écrit tout votre code, et comme vous le dites, vous ne le considérez plus comme votre problème. Votre collègue écrit ensuite l'implémentation de la fonction, et ne considère plus que ce soit leur problème. Qui va réellement tester que le code que VOUS avez écrit fonctionne correctement?

6
Pete