Quand fonctionne la programmation par paires? Quand l'éviter?
Plutôt que de programmer des paires servilement tout le temps, nous utilisons la programmation de paires de manière sélective dans notre équipe. Je pense que cela fonctionne mieux dans les circonstances suivantes:
- Accélérer les nouveaux membres de l'équipe sur un projet (au lieu de les laisser parcourir la documentation ou le code par eux-mêmes).
- Faire travailler ensemble des personnes juniors et seniors (aide à montrer certaines des compétences et des astuces des développeurs les plus expérimentés, et cela permet parfois aux vieux chiens d'apprendre de nouvelles astuces).
- Lorsque quelqu'un essaie de détecter un défaut, il est souvent utile de l'appairer avec une nouvelle paire d'yeux.
Quand utiliser le programme Pair et pourquoi?
Quand éviter la programmation par paires? Pourquoi?
ne recherche compilée par Laurie Williams indique que la programmation par paires fonctionne mieux sur les équipes industrielles lorsque
- Les paires travaillent sur les spécifications, la conception et complexes tâches de programmation - les expériences indiquent qu'aucune amélioration de la qualité n'est montrée lors du travail sur tâches simples dans une paire, mais il peut y avoir des améliorations de vitesse. Notez également que la "programmation" par paire comprend souvent des activités autres que l'écriture de code.
- Chaque individu dans un jumelage a à peu près le même niveau d'expertise - tandis que la programmation par paires est idéale pour la formation, les paires sont plus engagées lorsqu'elles sont à peu près sur le même niveau.
- Les rôles tournent régulièrement - la rotation régulière aide à garder le copilote actuel engagé car les individus ont tendance à contribuer le plus lorsqu'ils conduisent ou sentent qu'ils sont sur le point de conduire.
- Les paires tournent régulièrement - les équipes ont exprimé leur confort à connaître les différentes parties du système qu'elles construisent. La rotation des paires aide au transfert de connaissances, ce qui réduit certains risques dans le projet. Dans un milieu universitaire, les paires sont souvent attribuées, mais dans l'industrie, elles sont généralement auto-affectées souvent lors des stand-up. Dans les deux cas, la paire est plus efficace lorsque les deux individus sont des participants volontaires qui voient la valeur de l'activité de pairage.
Dans mon expérience personnelle, j'ai constaté que mon XP équipe consacre environ 60% de notre programmation de paires de temps de développement en moyenne. Le reste du temps est consacré au développement individuel. Il n'est pas rare de jumelez-vous pour créer une conception initiale, travaillez seul sur la conception pendant quelques heures, puis revenez ensemble pour terminer les parties délicates ou difficiles du code.
J'ai également constaté que la programmation par paire est plus efficace dans des blocs d'environ 1,5 à 2,5 heures. Tout ce qui est beaucoup moins a tendance à nécessiter trop de frais généraux pour la configuration tandis que beaucoup plus et les paires ont tendance à devenir grincheuses et fatiguées. Grincheux et fatigué signifie que vous ne communiquez pas bien et que des défauts peuvent se glisser dans le système.
La programmation en binôme a fonctionné pour moi dans très, très peu de situations.
Où la programmation par paire échoue pour moi
La courte histoire est que la programmation en binôme ne fonctionne pas pour moi comme principal moyen de développer un logiciel. Je peux jumeler le programme pendant une journée, ou peut-être une semaine, surtout si nous nous concentrons sur un problème particulier. Mais après ça? J'ai fini. Pain grillé. Je ne veux voir personne, parler à personne et j'ai besoin d'au moins quelques jours dans une grotte jusqu'à ce que je sois à nouveau apte à la compagnie humaine.
C'est une histoire triste, mais ce qui est drôle, c'est que je suis tellement plus heureux maintenant de la façon dont ça s'est terminé. Je suis heureusement employé sur un contrat où je travaille à domicile ou dans un café, et je me suis fait de nouveaux amis et j'ai exploré plus de San Francisco que je n'aurais jamais cru possible. J'ai un vélo et un ordinateur portable, et tant que je respecte mes délais et vérifie régulièrement le code, mon temps m'appartient.
Je vais énumérer les gros problèmes que j'ai avec la programmation par paire à l'avance et vous donner les détails et les anecdotes plus tard.
- Mise au point partagée.
- Aucune expérimentation.
- Pas de notes élevées.
- Pas de fierté de propriété.
- Pas de fuite...
... J'ai demandé à mes collègues s'ils avaient vu ce que j'ai vu, si je manquais quelque chose, quelque chose - je ne voyais pas comment cela pouvait fonctionner, comment les gens pouvaient continuer à le faire. Ils ont dit que j'allais bien, qu'il fallait juste du temps pour s'installer et s'adapter. Que c'était difficile pour tout le monde au début.
Finalement, je me suis repliée sur moi-même. Entre les maux de tête aveuglants, l'insomnie et le besoin écrasant et insatisfait d'écrire du code, j'ai cessé de répondre à l'entrée. Je pouvais regarder un écran sans rien voir. Quelqu'un pourrait me parler de façon inattendue et je ne les entendrais pas. Je remplissais les exigences par cœur de mon travail, mais je n’étais pas là. J'avais utilisé tout ce que je venais de faire pour la journée. J'ai commencé à vérifier mon iPhone lorsque mon autre partenaire tapait.
Enfin - un peu moins de trois mois plus tard, et pour la première fois - j'ai été licencié pour ne pas être une équipe en forme lors de la programmation en binôme.
Pas seul
J'ai écrit cela non seulement pour le comprendre, mais aussi pour pouvoir en parler. Il y avait une présomption que la programmation en binôme fonctionne pour la plupart des gens et est beaucoup plus facile et plus rapide que la programmation en solo. Cela peut être le cas ou non, mais comme pratique à long terme, la programmation par paires ne fonctionne pas pour moi. Il y a beaucoup d'autres personnes pour qui la programmation en binôme ne fonctionne pas non plus. Nous comptons aussi ...
Mon équipe a fait de la programmation en binôme depuis sa création, bien avant d'y travailler, dans le cadre d'une boutique de style essentiellement "programmation extrême". La programmation par paire est l'état par défaut ; les gens ne vont vraiment au singleton que s'il y a un nombre impair, ou parfois pour des enquêtes, en particulier celles qui impliquent de jouer avec du matériel hostile et d'essayer de le faire fonctionner.
"Junior/senior" n'est pas la seule voie à suivre. "Intermédiaire/junior" est utile; cela aide le gars de niveau intermédiaire à synthétiser les connaissances qu'il a acquises en le forçant à le communiquer à quelqu'un d'autre. "Intermédiaire/Intermédiaire" met au défi deux personnes qui travaillent ensemble pour partager leurs connaissances, communiquer et travailler en équipe. Et même si vous avez deux gars vraiment seniors, il y a de fortes chances qu'ils aient des domaines d'expertise différents et puissent proposer des approches différentes. Les aspects de partage des connaissances ne s'arrêtent pas une fois que quelqu'un est vaguement "au courant" d'un projet. Au contraire, la programmation par paires est la quintessence d'une organisation apprenante . Les nouvelles techniques et les meilleures pratiques se répandent rapidement.
La programmation par paire permet également de maintenir la qualité du code (moins de défauts) et la santé mentale du code (il ne fait pas seulement ce qu'il a l'intention de faire, mais fait ce qu'il devrait ... idéalement sans descendre dans un lapin de plusieurs semaines en faisant la mauvaise chose, ou deux bonnes choses différentes qui entreront en conflit d'une manière extravagante). Cela aide les programmeurs à maintenir leur concentration: ici, au cœur de la Silicon Valley, la maison de la semaine de travail de 80 heures, nous pouvons travailler pendant seulement 40 heures par semaine parce que nous faisons un codage intense huit heures par jour, en changeant les choses les uns avec les autres. (En outre, si vous étiez plus long à faire de la programmation en binôme, vous feriez probablement flip out. Ou du moins vous épuiseriez.) Ceci est idéal pour l'équilibre travail/vie privée, et il aide également votre organisation lorsque il est important d'avoir un délai d'exécution rapide (délai d'exécution à faible latence, en particulier).
Ce n'est pas tout, complètement, 100% pêches et crème; Je trouve que la programmation par paires est parfois un obstacle à mon application de processus cérébraux intuitifs qui sont utiles sur certains problèmes. Plus récemment, sur une tâche de fuite de mémoire, j'ai passé du temps avec et sans paires; sans un, je me sentais plus libre de jouer et d'essayer des expériences sans vraiment savoir exactement comment expliquer ce que je faisais à un moment donné. Il y a aussi quelques avantages à travailler en singleton, à pouvoir partir sur une tangente et faire certains refactorings sauvages (évalués dans la méthodologie XP) sur un coup de tête.
Mais, tout compte fait, les avantages l'emportent de loin sur les coûts, et le jumelage a très bien fonctionné pour nous: de la phase de démarrage à l'acquisition par une plus grande entreprise et à notre intégration ultérieure. (En parlant de cela, la programmation en binôme nous a aidés à maintenir une continuité de culture grâce à l'expansion et malgré un petit roulement).
(Nous développons une application logicielle en Perl, ~ 4000 $ - 40 000 $ prix courant.)
Je n'ai jamais travaillé dans une configuration de "programmation par paire" et pourtant je peux affirmer avoir fait partie des trois circonstances que vous avez énumérées. Le scénario que vous mentionnez semble plus "une programmation régulière" avec des phases d'aide/de formation. N'avons-nous pas fait tout cela avant que la "programmation par paires" ne se concrétise? La programmation en binôme, je suppose que cela nécessiterait une approche plus engagée où le processus de partage au sein d'une équipe ne s'arrête pas à la minute où vous vous attaquez à la tâche ou au problème immédiat. Mais c'est ce que je "pense" et non ce que je "sais".
Personnellement pour la programmation en binôme, j'aimerais travailler dans une équipe où j'ai la chance d'apprendre et de partager mes connaissances. Une équipe déséquilibrée où tout le monde avec qui vous travaillez a des kilomètres d'avance sur vous, ou bien au-dessous du pair peut devenir assez inintéressante assez rapidement. De plus, j'aurais peur de travailler avec des gens qui sont dans leurs croyances et difficiles à convaincre.
Nous expérimentons la programmation Pair dans notre équipe depuis quelques mois. Je pense que c'est assez utile lorsque vous travaillez sur quelque chose de nouveau (nouvelle technologie, nouvelle fonctionnalité, etc.) car vous pouvez rapidement faire rebondir des idées avec une autre personne de l'équipe et les faire valider/invalider. En outre, un examen par les pairs côte à côte permet d'éviter les bogues.
Un autre coéquipier a essayé d'utiliser la programmation par paire avec un test pour faire de l'ATDD et ils étaient assez satisfaits des résultats (selon ses calculs, une augmentation de 20% du coût de développement a conduit à une diminution d'environ 50% du temps de test)
Bonne nuit
plusieurs fois, nous avons débattu des pratiques de programmation extrême et de la programmation par paires. Dans le passé, nous sommes en mesure de comprendre que la programmation est une activité solo car les programmeurs avaient besoin de concentration et d'isolement. Les programmeurs à cette époque étaient dans la zone, un état mental où ils pouvaient se concentrer efficacement sur le code et prendre des décisions agréables et créatives.
La programmation par paire semble également risquée si vous supposez qu'un programmeur s'interrompt. D'un autre côté, il est plus difficile d'interrompre deux programmeurs travaillant ensemble. Sur la programmation Solo par exemple, il sera plus facile d'être interrompu, donc il est presque impossible à un programmeur solo de rester dans la "zone".
La qualité du code en est une autre lorsque la date limite approche à grands pas. Les gens seront toujours pressés, qu'ils soient programmeurs en binôme ou programmeur solo: ils n'appliqueront pas certaines bonnes pratiques et oublieront simplement les tests unitaires.
Je m'en tiendrai à la programmation par paires. Parce que quand il s'agit de risques, quand un programmeur est parti, vous aurez toujours un autre gars pour documenter le processus et enseigner à tous les autres comment cela fonctionne.
Travailler sur n'importe quoi de complexité non triviale a tendance à être un bon candidat pour la programmation par paires afin que plusieurs personnes comprennent le code plutôt qu'un seul développeur connaissant une partie de la base de code. Un autre cas est celui où quelqu'un souhaite transférer certaines compétences. Un exemple ici peut être d'avoir quelqu'un qui est vraiment bon en tests unitaires avec quelqu'un qui n'est pas aussi familier avec le concept et aide ainsi à prendre une habitude initiale sur quelque chose.
Quant à savoir où éviter la programmation par paires, grognez les tâches de travail qui sont simples où il serait préférable de diviser le travail en deux groupes et de laisser chaque développeur faire une partie du travail séparément pour faire le travail. Certaines tâches peuvent simplement nécessiter un peu de frappe mais ne sont pas si grandes qu'il vaut la peine de passer quelques heures à essayer de trouver une meilleure façon de le faire, comme cela pourrait être fait si chaque développeur adopte une approche par force brute pour quelques-uns heures.