Programmation Test Driven Development et paire [fermé]

StackOverflow https://stackoverflow.com/questions/882661

Question

Je suis dans une équipe où je suis en train de convaincre mes coéquipiers d'adopter TDD (comme je l'ai vu travailler dans mon équipe précédente et la configuration est similaire). En outre, ma conviction personnelle est que, au moins au début, cela aide vraiment si les deux TDD et la programmation paire sont effectuées conjointement. De cette façon, les deux développeurs inexpérimentés (en TDD) peuvent aider les uns les autres, discuter de ce genre de tests pour écrire et faire de bons progrès.

Mon manager, d'autre part, estime que si l'on introduit deux nouvelles pratiques de développement dans l'équipe à la fois, il y a une bonne chance que les deux pourraient échouer. Donc, il veut être un peu plus conservateur et d'introduire une.

Comment puis-je le convaincre que ces deux sont complémentaires et non orthogonale. Ou suis-je tort?

Était-ce utile?

La solution

Je ne suis pas sûr que d'avoir plus de gens qui ne savent pas ce qu'ils font en TDD va aider. Il va descendre rapidement dans les deux vous googler le sujet, ou les deux vous disputaient exactement ce que TDD est / n'est pas.

Je pense que vous seriez mieux d'obtenir quelqu'un de l'équipe pour devenir l'évangéliste pour une technique donnée (quelqu'un va et se lit sur TDD, quelqu'un va et se lit sur la programmation paire) et ont ces gens, puis de promouvoir et d'essai ces choses. Oui, les deux peuvent se produire en même temps, mais ils ne doivent pas être utilisés dans toute l'équipe du projet. Vous pourriez avoir un petit groupe de votre équipe n'associez la programmation et ensuite faire rapport sur leurs expériences.

Autres conseils

Paire Progamming est efficace lors de l'apprentissage d'une nouvelle pratique en particulier TDD

Ainsi, vous pouvez avoir à la fois avec un compromis. Pour ce faire, d'une manière agile, progressivement. Prenez la programmation de première paire. Il est le plus facile des deux. Toutes les pratiques après la programmation paire deviendront beaucoup plus facile à apprendre et seront adoptées par l'équipe plus rapidement et avec une plus grande consistentcy. La programmation en binôme est l'un des premiers, sinon la première pratique de engineerring qui devrait être adopté. Assurez-vous qu'il est fait de manière efficace. Voici une description de la façon de faire de la programmation paire.

Programmation Couplé est l'une des pratiques les plus puissants une équipe de développement peut utiliser lors du développement de logiciels. Appariement se produit avec deux développeurs de développer activement une carte histoire en utilisant un seul ordinateur et le clavier. Les gestionnaires craignent que l'utilisation de la programmation jumelé doublera leurs coûts de programmation. À première vue, il est facile de comprendre pourquoi ils pourraient penser que - après tous les développeurs --Deux sont invités à travailler ensemble sur la même tâche. En pratique, cependant, les équipes agiles en utilisant cette technique de développement ont constaté que la légère augmentation des coûts pour le développement initial (15% selon une université de l'Utah étude) sont plus que compensée par une réduction des défauts, un test plus court et moins coûteux le cycle et la réduction du besoin de soutien à la production.

Bien qu'il puisse sembler contre-intuitif que d'avoir des programmeurs couple et de travailler ensemble améliore la productivité, il y a un certain nombre de raisons pour lesquelles cette technique ne fonctionne pas vraiment Voici pourquoi (je crois que le vieux dicton: « Deux têtes valent mieux qu'une. »):

  • Amélioration de la qualité - jumelage encourage la révision du code. Beaucoup d'erreurs se font prendre comme ils sont tapés. programmation Couplé signifie revue de code continu effectué par deux personnes qui se sont engagés à la qualité du code et travaillent ensemble pour identifier et corriger les bugs en tout temps. Une étude réalisée par l'Université de l'Utah a constaté que le nombre final des défauts constatés dans le code a été réduit de 15% en moyenne pour le code écrit par paires.
  • Moins de temps passé « Stuck » - La programmation est difficile. Souvent, les développeurs peinent à trouver une solution et de passer plus de temps qu'ils ne le devraient « coincé ». Avoir un partenaire pour échanger des idées avec et à accepter de demander de l'aide si nécessaire réduit la quantité de temps improductif passé coincé à essayer de trouver une solution.
  • Moins de temps passé sur Distractions -. Un développeur est temps de passer moins de chances sur les appels téléphoniques personnels ou surfer sur le web, ou des vacances e-mail quand il ou elle travaille avec un partenaire
  • Deux perspectives sont appliquées aux problèmes - différents niveaux d'expérience, différents styles de résolution de problèmes, différentes compétences auxiliaires augmentent toutes les chances de résoudre un problème plus rapidement. L'étude réalisée par l'Université de l'Utah a également identifié une meilleure conception globale longueur et code plus court pour le logiciel écrit par paires.
  • Moins peur de l'inconnu - Lors de l'appariement avec un autre développeur, il est plus facile d'aborder un problème ou essayer d'obtenir une poignée sur les nouvelles technologies, que lorsque travaille seul. Ils gagnent également, au fil du temps, une meilleure compréhension de l'application. En fin de compte, le projet se termine avec plusieurs personnes à comprendre chaque pièce du système à la suite d'appariement.
  • moins susceptibles de construire dans la portée - Souvent, les développeurs ajoutent volontairement des fonctions non traitées dans les exigences. Lorsque vous travaillez avec une paire, le second développeur est plus susceptible de garder son / sa partenaire sur la tâche.
  • Amélioration de la dynamique de l'équipe - En raison de l'approche apparié, les gens apprennent à travailler ensemble. Ils parlent plus souvent et l'expérience d'une meilleure circulation de l'information. la dynamique de l'équipe d'améliorer en conséquence. En fait, nous avons constaté que la meilleure expérience d'équipe travaille de concert autour de produire des logiciels que votre client est excité. Tout le monde aime faire partie d'une équipe gagnante.
  • Élimination de Silos de Knoonnaissances -. La connaissance du domaine, la connaissance du code ou pratiques sont rapidement propagées par l'équipe et deux développeurs avec l'autre sur une base de rotation

Une fois que l'équipe est confortable avec appariement, puis prendre le TDD. A destription suit:

Test-Driven Development (TDD) est une pratique de l'ingénierie de développement logiciel composé de courte rafale de développement où un nouveau cas de test couvrant l'amélioration ou une nouvelle fonctionnalité désirée est écrit d'abord, puis le code de production nécessaire pour passer le test est mis en œuvre, et enfin le logiciel est refactorisé pour tenir compte des changements. La disponibilité des tests avant le développement réel assure une rétroaction rapide après tout changement. Les praticiens soulignent que le développement piloté par les tests est une méthode de conception de logiciels, non seulement une méthode de test. développement piloté par les tests est une pratique puissante et un contributeur majeur à la réduction des défauts plus loin dans le cycle de vie. Une nouvelle équipe est fortement encouragé à jumeler avec un praticien d'expérience TDD ou autrement recevoir TDD coaching.e

Développement piloté par les tests exige qu'un test unitaire automatisé, la définition des exigences du code, est écrit avant chaque aspect du code lui-même. Ces tests contiennent des affirmations qui sont vraies ou fausses. L'exécution des tests donne une confirmation rapide du comportement correct que le code évolue et est refactorisé. frameworks de tests basés sur le concept xUnit fournissent un mécanisme pour créer et exécuter des séries de cas de tests automatisés. Développement piloté par les tests du cycle. La séquence suivante est basée sur le livre de développement piloté par les tests par exemple, que beaucoup considèrent comme le texte source canonique sur le concept sous sa forme moderne

  1. Ecrire un test. Dans le développement piloté par les tests, chaque nouvelle carte histoire commence par écrire un test. Ce test échoue, car il est écrit avant que la fonction a été mis en œuvre. Pour écrire un test, le développeur doit comprendre les spécifications et les exigences de la fonction clairement. Cela peut être accompli grâce à une carte Story avec les critères d'acceptation pour préciser quand les exigences ont été rencontrent. Cela pourrait aussi impliquer un invariant, ou la modification d'un test existant. Ceci est une caractéristique de différenciation du développement piloté par les tests par rapport aux tests unitaires d'écriture après le code est écrit:. Il fait l'objet de développeur sur les exigences avant d'écrire le code, une différence subtile mais importante
  2. Exécuter tous les tests et voir si le nouveau échoue. Cela confirme que le harnais de test fonctionne correctement et que le nouveau test ne passe pas par erreur sans nécessiter de nouveau code. Le nouveau test devrait échouer pour la raison attendue. Cette étape teste le test lui-même, dans la négative:. Elle exclut la possibilité que le nouveau test sera toujours passer, et donc sans valeur
  3. Ecrire un code. L'étape suivante consiste à écrire un code qui fera passer le test. Le nouveau code écrit à ce stade ne sera pas parfait et peut, par exemple, passer le test d'une manière inélégante. C'est acceptable parce que les étapes ultérieures permettront d'améliorer et de perfectionner ce. Il est important que le code écrit est conçu uniquement pour passer le test; aucune autre (et donc non testé) la fonctionnalité doit être prédite et « autorisé pour » à tout moment.
  4. Exécuter les tests automatisés et les voir réussir. Si tous les tests passent maintenant, le programmeur peut être sûr que le code répond à toutes les exigences testées. Ceci est un bon point de départ pour commencer l'étape finale du cycle.
  5. code Refactor. Maintenant, le code peut être nettoyé au besoin. En relançant les cas de test, le développeur peut être sûr que refactoring n'endommage pas toutes les fonctionnalités existantes. Le concept d'élimination du double emploi est un aspect important de toute conception logicielle. Cependant, dans ce cas, il applique également à éliminer toute duplication entre le code de test et le code de production-. Par exemple les nombres magiques ou des chaînes qui ont été répétées à la fois, afin de faire passer le test de l'étape 3

Répéter

En commençant par un nouveau test, le cycle est ensuite répété pour faire avancer la fonctionnalité. La taille des étapes peut être aussi petit que le développeur aime, ou d'obtenir plus s'il / elle se sent plus confiant. Si le code écrit pour satisfaire un test ne fait pas assez rapidement le cas, alors la taille de pas peut-être trop grand, et peut-être les étapes testables plus petites devrait être utilisé à la place. Lors de l'utilisation des bibliothèques externes, il est important de ne pas faire des incréments qui sont si petits pour être efficace d'un simple test de la bibliothèque elle-même, à moins qu'il y ait une raison de croire que la bibliothèque est buggy ou n'est pas suffisamment complet de fonctionnalités pour répondre à tous les besoins de la programme principal en cours d'écriture.

Style de développement Il y a différents aspects à utiliser le développement piloté par les tests, par exemple les principes de « Keep It Simple, Stupid » (Kiss) et « yagni » (YAGNI). En mettant l'accent sur l'écriture que le code nécessaire pour passer des tests, des dessins peuvent être plus propre et plus claire que souvent atteint par d'autres méthodes. le développement piloté par les tests exige que le programmeur d'abord échouer les cas de test. L'idée est de faire en sorte que le test fonctionne vraiment et peut attraper une erreur. Une fois que cela est montré, le cycle normal commencera. Cela a été inventé le « développement piloté par les tests Mantra », connu sous le nom rouge / vert / rouge signifie refactor où échouent et vert est passe. le développement piloté par les tests répète constamment les étapes consistant à ajouter des cas de test qui échouent, en passant, et refactoring. Réception des résultats des tests prévus à chaque étape renforce le modèle mental du programmeur du code, renforce la confiance et augmente la productivité

Vous êtes tout à fait exact que paire programmation aidera énormément lors de l'apprentissage quelque chose de nouveau. Je suis d'accord avec vous que vous devez pousser dur pour faire les deux.

Peut-être la meilleure façon de le poser pour votre gestionnaire ne veut pas dire que vous demandez de présenter ces deux nouvelles choses en même temps. Au lieu de cela, suggérez que vous vous sentez la façon la plus efficace de commencer la mise en œuvre TDD est, tout travail achevé, est de prendre seulement deux développeurs comme « l'équipe d'enquête TDD » et les faire travailler ensemble pour obtenir les outils appropriés mis en place, apprendre la techniques, de les tester et comprendre ce que vous devez faire pour les appliquer dans votre environnement. Une fois que vous avez obtenu ce travail, et que deux personnes qui ont un peu d'expérience avec elle, alors les séparer et chacun asseyez-vous avec un autre développeur pour quelques jours pour apporter cet autre développeur à la vitesse sur les nouvelles techniques. Répétez jusqu'à ce que tous les développeurs ont appris TDD.

Vous ne convainquent pas. Dites-lui les raisons pour lesquelles vous pensez que les deux travaillent ensemble, peut-être présenter des données qui confirment cela, et le laisser décider. Si vous avez besoin de convaincre tout le monde que c'est une bonne idée, je parie que personne ne va prendre à trop bien. opposition natual.

Personnellement, j'ai trouvé la programmation paire fonctionne mieux avec un expérimenté et inexpérimenté.

Ie je chercherai une différence de compétences / exp de programmeurs plutôt que d'essayer de faire correspondre régulièrement qualifiés.

les plus expérimentés obtient plus hors de lui d'explication et d'être forcé de structurer les pensées tandis que l'expérience obtient la chance de rebondir idées et ramasser les « meilleures pratiques ».

comme pour TDD, je suis un grand fan. Encore une fois exp aide l'expérience, car il aide vraiment faire ressortir le point de l'essai. -À-dire que vous ne voulez pas tester absolument tout ... il ajoute le focus. Souvent, je trouve que les gens sont en train d'écrire des tests sans se concentrer sur ce qu'ils essaient d'atteindre.

Les tests unitaires sont essentiels imo ... Après tout, certains membres du personnel ne sera pas là dans 2 ans. Comment pouvez-vous modifier le code existant s'il n'y a rien à vérifier sa fonction contre?

Eh bien, selon le gestionnaire, vous pouvez pointer certains arguments dans la littérature XP que ces pratiques sont interdépendantes. Par exemple, si vous ne disposez pas des tests unitaires solides, ne pas factoriser sans pitié.

Je vous suggère de l'aborder progressivement, en ce que le jumelage ne serait que dans le but de déterminer TDD, comme tout effort de collaboration sur un nouveau problème difficile, que « tout le développement de la production se fera par deux. »

Bien que l'on pratique ne nécessite pas l'autre, il est un moyen d'introduire à la fois un peu « sournoise » à la fois.

Commencez par l'objectif de la mise en œuvre TDD en utilisant l'un des cadres xUnit disponibles. Trouver un collègue compatible et demander si pendant environ une heure par jour, ils seraient prêts à travailler avec vous. « Shawn, je suis en train de ce nouvel outil, vous me aider à vous assurer que je fais bien? » fonctionne très bien.

Après quelques jours avec Shawn, répéter avec Susan ...

Faites-le de toute façon. Si le gestionnaire attrape vous appariement, dire les mots magiques « Code Review »
Hypothèse: Il est évident que la paire devrait être assez disciplinés / ciblés et produire du code de travail à la fin de la session

Ecrire des tests qui attirent l'attention sur les bugs existants dans la base de code - puis les montrer à votre patron, je pense qu'il pourrait soudainement d'accord TDD est une bonne idée

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top