Voir la source de Programmation en binôme

[[Fichier:Programmation en binôme.jpg|vignette|Programmation en binôme|upright=1.5]]

La '''programmation en binôme '''(de l'anglais ''pair programming''), parfois appelée '''programmation par pairs''' ou '''binômage''', est une méthode de travail dans laquelle deux développeurs travaillent ensemble sur un même poste de travail. La personne qui rédige le code est appelée conducteur (''{{langue|en|texte=driver}}''). La seconde personne, appelée observateur (''{{Langue|en|texte=observer}}''), assiste le conducteur en décelant les imperfections, en vérifiant que le code implémente correctement le design et en suggérant des alternatives de développement. Les rôles s'échangent régulièrement pendant la séance de programmation<ref>{{harvsp|McDowell|Werner|Bullock|Fernald|2003|p=1|id=Impact}}</ref>. La programmation en binôme fait partie des bonnes pratiques de l'[[extreme programming]].

== Bénéfices ==
[[Fichier:Pair Programming 3.jpg|vignette|Deux programmeurs en binôme]]

=== Qualité et productivité ===

Un des freins à l'adoption de la programmation en binôme en entreprise est l'idée que deux personnes travaillant sur un même projet constituent un gaspillage de ressources humaines<ref>{{harvsp|Cockburn|Williams|2000|p=1|id=CostsBenefits}}</ref>. Plusieurs études se sont intéressées à la productivité relative des binômes face aux programmeurs seuls<ref name="ReferenceA">{{harvsp|Lui|Chan|2006|p=2|id=PPproductivity}}</ref>. Pour éviter l’ambiguïté entre temps passé et temps total par programmeur, {{lien|Kim Man Lui}} définit une mesure de l'effort relatif consenti par un binôme (de l'anglais ''relative effort afforded by pairs'', abrégé en REAP) de la façon suivante<ref name="ReferenceA"/> :
<math>\textstyle\frac{(ElapsedTimeOfPair) \times 2 - (ElapsedTimeOfIndividual)}{ElapsedTimeOfIndividual}</math>
où <math>\scriptstyle ElapsedTimeOfPair</math> représente le temps passé par un binôme et <math>\scriptstyle ElapsedTimeOfIndividual</math> le temps passé par un programmeur seul.

Équation en français: <math>\textstyle\frac{(\textstyle TempsPass\acute eADeux) \times 2 - (TempsPass\acute eSeul)}{\textstyle TempsPass\acute eSeul}</math>
où <math>\scriptstyle \textstyle TempsPass\acute eADeux</math> représente le temps passé par un binôme et <math>\scriptstyle \textstyle TempsPass\acute eSeul</math> le temps passé par un programmeur seul.

Une valeur nulle de REAP indique qu'un binôme utilise exactement la moitié du temps nécessaire à un programmeur seul pour réaliser la même tâche. Une valeur de REAP comprise entre 0 et 100 % indique qu'un binôme réalise une tâche plus rapidement mais nécessite davantage d'[[wikt:heure-homme|heures-hommes]]. Une première étude réalisée en 1998 rapporte une valeur de 59,4 %<ref>{{harvsp|Nosek|1998|p=2|id=Case}}</ref>. Une autre étude complète ces résultats en indiquant qu'après une période d'ajustement, ce taux descend à 15 %<ref>{{harvsp|Williams|Kessler|Cunningham|Jeffries|2000|p=4|id=Strengthening}}</ref>. {{Référence nécessaire|La programmation en binôme est donc particulièrement utile lorsqu'il est nécessaire de réduire le délai de mise sur le marché d'un logiciel.}}

La programmation en binôme permet également une détection plus rapide des [[Bug (informatique)|bugs]], notamment par l'application continue de la [[revue de code]] par l'observateur<ref>{{harvsp|Cockburn|Williams|2000|p=6|id=CostsBenefits}}</ref>. De manière générale, un binôme conçoit des applications de meilleure qualité qu'un programmeur seul<ref>{{harvsp|Dybå|Arisholm|Sjøberg|Hannay|2007|p=4|id=2Heads}}</ref>. Cette différence s'explique par la nécessité pour un binôme de s'accorder au préalable sur la conception de l'application à produire en proposant un raisonnement justifié<ref>{{harvsp|Li|Kraemer|2014|p=4|id=SocialEffects}}</ref>. La programmation en binôme amène alors à des applications passant davantage de [[Test (informatique)|tests]]<ref>{{harvsp|Williams|Kessler|Cunningham|Jeffries|2000|p=5|id=Strengthening}}</ref> et ayant des fonctionnalités implémentées avec moins de lignes de code<ref>{{harvsp|Cockburn|Williams|2000|p=5|id=CostsBenefits}}</ref>.

Économiquement, le surcoût en personnel induit par la programmation en binôme est compensé par la hausse de qualité de l'application produite. Plus un défaut est décelé tard et plus il est coûteux de le corriger. Ainsi, {{Pas dans la source|la correction tardive des défauts supplémentaires d'une application développée par un programmeur seul est quinze à soixante fois plus coûteuse}}<ref>{{harvsp|Cockburn|Williams|2000|p=4|id=CostsBenefits}}</ref>.

=== Communication ===

La programmation en binôme est une activité sociale qui nécessite d'apprendre à travailler avec les autres. Elle favorise ainsi la communication au sein d'une équipe en encourageant les développeurs à parler entre eux<ref>{{harvsp|Zarb|2012|p=1|id=Understanding}}</ref>. En outre, elle permet d'améliorer les compétences communicationnelles qui sont généralement peu travaillées pendant l'apprentissage de l'informatique. Cette pratique a également pour effet de renforcer les liens entre les développeurs et de créer un esprit d'équipe<ref>{{harvsp|Ally|Darroch|Toleman|2005|p=3|id=Framework}}</ref>.

De plus, la programmation en binôme améliore le plaisir des programmeurs et la confiance dans leur travail. De nombreux sondages attestent que plus de 90 % des développeurs préfèrent programmer en binôme plutôt que seuls<ref>{{harvsp|Williams|Kessler|Cunningham|Jeffries|2000|p=6|id=Strengthening}}</ref>.

=== Apprentissage ===
==== Milieu universitaire ====
L’utilisation de la programmation en binôme appliquée dans le milieu universitaire permet une amélioration globale des notes des étudiants les plus faibles<ref>{{harvsp|McDowell|Werner|Bullock|Fernald|2003|p=3|id=Impact}}</ref>, sans pour autant diminuer les notes des plus forts<ref>{{harvsp|Braught|Wahls|Eby|2011|p=17|id=CSClassroom}}</ref> ; de plus, il permet une meilleure intégration des femmes et des minorités au sein des cursus informatiques<ref>{{harvsp|Braught|Wahls|Eby|2011|p=2|id=CSClassroom}}</ref>.

La mise en place de binômes au sein d'un cours à l'université améliore également la qualité du travail effectué. De plus, le travail en binôme permet un échange plus aisé entre les étudiants<ref>{{harvsp|Zarb|Hughes|Richards|2014|p=4|id=Industry}}</ref>, mais également avec le professeur<ref>{{harvsp|Radermacher|Walia|Rummelt|2012|p=1|id=Improving}}</ref>, voire de réduire les différences pédagogiques entre les professeurs<ref>{{harvsp|Braught|Eby|Wahls|2008|p=5|id=Individual}}</ref>.

==== En entreprise ====
Au sein d'une entreprise, le développement en binôme encourage un [[transfert de connaissances]] techniques entre les membres de l'équipe, notamment lorsqu'un développeur considéré comme novice travaille avec un expert. Le novice peut non seulement apprendre de nouvelles technologies grâce à l'expert, mais aussi apprendre de bonnes pratiques ou découvrir de nouveaux logiciels utiles au développement<ref>{{harvsp|Cockburn|Williams|2000|p=7|id=CostsBenefits}}</ref>.

== Indicateurs de non-performance ==
La plupart des développeurs sont conditionnés pour travailler seul et l'adoption de la programmation en binôme est parfois délicate. Si la transition s'effectue généralement avec succès<ref>{{harvsp|Williams|Kessler|2000|p=2|id=Kindergarten}}</ref>, il existe quelques indicateurs qu'un binôme ne fonctionne pas :
* Silence : la programmation en binôme nécessite de programmer à voix haute et de partager son point de vue avec son partenaire. Un silence persistant indique un manque de collaboration.
* Désengagement : un des membres se désintéresse du projet et vaque à ses occupations.
* Effacement : lorsqu'un membre est plus expérimenté qu'un autre, le novice se contente d'observer l'expert réaliser la majorité des tâches de développement<ref name="AgilePP">
{{Lien web
 |langue       = en
 |url          = http://www.agilesherpa.org/agile_coach/engineering_practices/pair_programming/
 |titre        = Agile Pair Programming
 |consulté le = 11 décembre 2014
 |archiveurl   = https://web.archive.org/web/20110528215714/http://www.agilesherpa.org/agile_coach/engineering_practices/pair_programming/
 |archivedate  = 28 mai 2011
 |brisé le    = 
}}</ref>.
* Problèmes relationnels : les deux membres du binôme ne s'entendent pas et ne souhaitent pas travailler ensemble<ref name="GuideAgile">
{{Lien web
 | langue          = en
 | url             = http://guide.agilealliance.org/guide/pairing.html
 | titre           = Guide to Agile Practices
 | consulté le     = 11 décembre 2014
}}</ref>.

== Programmation à distance ==
La programmation en binôme peut également être établie à distance<ref name="ReferenceB">{{harvsp|Schenk|Prechelt|Salinger|2014|p=2|id=Distributed}}</ref>. Dans ce cas, des outils dédiés au [[travail collaboratif]] sont souvent mis en place, en vue notamment de partager l’affichage (Mikogo) ou le [[code source]] (XPairtise<ref name="XPairtise">{{Lien web
 | langue          = en
 | url             = http://xpairtise.sourceforge.net/
 | titre           = XPairtise - A Distributed Pair Programming Plug-in For Eclipse
 | consulté le     = 9 janvier 2015
}}</ref>, Saros<ref name="Saros">{{Lien web
 | langue          = en
 | url             = http://www.saros-project.org/
 | titre           = Real-Time Distributed Software Development
 | consulté le     = 9 janvier 2015
}}</ref>, Cloud9), de communiquer à distance ([[Skype]]), ou encore d'exécuter des instructions sur une machine distante ([[Secure Shell|SSH]])<ref name="PPaDistance">
{{Lien web
 | url             = http://www.occitech.fr/blog/2014/04/pair-programmer-a-distance-facilement/
 | titre           = Pair-programmer à distance facilement
 | date            = 4 avril 2014
 | consulté le     = 11 décembre 2014
}}</ref>.

La communication au sein du binôme peut être perturbée par plusieurs éléments. Différents problèmes techniques tels qu'une coupure réseau ou des messages d’erreur dans un logiciel peuvent faire perdre du temps au binôme<ref name="ReferenceB"/>. De plus, le manque de [[communication non verbale]] rend parfois l'échange plus difficile. Cependant, des outils de dessin, la sélection de code ou le curseur peuvent compenser ces problèmes de communication<ref name="PPaDistance"/>. Enfin, on note également certains avantages, comme les modifications mineures de code sans perturber le binôme<ref>{{harvsp|Schenk|Prechelt|Salinger|2014|p=7|id=Distributed}}</ref>.

La programmation en binôme à distance modifie les rôles définis par la programmation en binôme classique. En effet, avoir deux écrans affichant le même code source rend l’observateur souvent plus actif. Deux situations peuvent être constatées :
* soit les membres du binôme continuent à travailler ensemble sur la même tâche, auquel cas le rôle de l’observateur est conservé, celui-ci se contentant de modifications mineures du code ;
* soit chaque membre travaille sur une tâche différente. Dans ce cas, le travail commence par une phase de discussion avant une phase de développement en solo<ref>{{harvsp|Schenk|Prechelt|Salinger|2014|p=6|id=Distributed}}</ref>.

== Articles connexes ==

* La [[programmation en groupe]] qui est une extension à toute une équipe de la programmation en binôme<ref>{{Lien web|langue=en-US|titre=What is Mob Programming? {{!}} Agile Alliance|url=https://www.agilealliance.org/glossary/mob-programming/|date=2019-01-11|consulté le=2020-04-16}}</ref>.

== Références ==
{{Références|colonnes=4}}

== Bibliographie ==
* {{Article
 | langue                 = en
 | id                     = Impact
 | auteur1                = Charlie McDowell 
 | auteur2                = Linda Werner
 | auteur3                = Heather E. Bullock
 | auteur4                = Julian Fernald
 | titre                  = The Impact of Pair Programming on Student Performance, Perception and Persistence
 | périodique             = Proceedings of the 25th International Conference on Software Engineering
 | mois                   = 5
 | année                  = 2003
 | pages                  = 602-607
 | doi                    = 10.1109/ICSE.2003.1201243
 | lire en ligne          = http://users.soe.ucsc.edu/~charlie/pubs/icse2003.pdf
 | consulté le            = 11 décembre 2014
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = CostsBenefits
 | auteur1                = [[Alistair Cockburn]]
 | auteur2                = Laurie Williams
 | titre                  = The Costs and Benefits of Pair Programming
 | périodique             = Proceedings of the First International Conference on Extreme Programming and Flexible Processes in Software Engineering (XP2000)
 | volume                 = 43
 | numéro                 = 5
 | mois                   = 5
 | année                  = 2000
 | lire en ligne          = http://collaboration.csc.ncsu.edu/laurie/Papers/XPSardinia.PDF
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = PPproductivity
 | auteur1                = Kim Man Lui
 | auteur2                = Keith C.C. Chan
 | titre                  = Pair programming productivity: Novice–novice vs. expert–expert
 | périodique             = International Journal of Human–Computer Studies
 | volume                 = 64
 | numéro                 = 9
 | mois                   = 9
 | année                  = 2006
 | doi                    = 10.1016/j.ijhcs.2006.04.010
 | lire en ligne          = http://www.cs.utexas.edu/users/mckinley/305j/pair-hcs-2006.pdf
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = Case
 | auteur1                = John T. Nosek
 | titre                  = The case for collaborative programming
 | périodique             = Communications of the ACM
 | volume                 = 41
 | numéro                 = 3
 | mois                   = 3
 | année                  = 1998
 | doi                    = 10.1145/272287.272333
}}
* {{Article
 | langue                 = en
 | id                     = 2Heads
 | auteur1                = Tore Dybå
 | auteur2                = Erik Arisholm
 | auteur3                = Dag I.K. Sjøberg
 | auteur4                = Jo E. Hannay
 | auteur5                = Forrest Shull
 | titre                  = Are Two Heads Better than One? On the Effectiveness of Pair Programming
 | périodique             = IEEE Software
 | volume                 = 24
 | numéro                 = 6
 | mois                   = 11
 | année                  = 2007
 | doi                    = 10.1109/MS.2007.158
}}
* {{Article
 | langue                 = en
 | id                     = SocialEffects
 | auteur1                = Zhen Li
 | auteur2                = Eileen Kraemer
 | titre                  = Social effects of pair programming mitigate impact of bounded rationality
 | périodique             = Proceedings of the 45th ACM technical symposium on Computer science education
 | mois                   = 3
 | année                  = 2014
 | doi                    = 10.1145/2538862.2538968
}}
* {{Article
 | langue                 = en
 | id                     = Understanding
 | auteur1                = Mark Zarb
 | titre                  = Understanding communication within pair programming
 | périodique             = Proceedings of the 3rd annual conference on Systems, programming, and applications: software for humanity
 | mois                   = 10
 | année                  = 2012
 | doi                    = 10.1145/2384716.2384738
}}
* {{Article
 | langue                 = en
 | id                     = Framework
 | auteur1                = Mustafa Ally
 | auteur2                = Fiona Darroch
 | auteur3                = Mark Toleman
 | titre                  = A framework for understanding the factors influencing pair programming success
 | périodique             = Proceedings of the 6th international conference on Extreme Programming and Agile Processes in Software Engineering
 | année                  = 2005
 | doi                    = 10.1007/11499053_10
 | lire en ligne          = http://core.kmi.open.ac.uk/download/pdf/11034646.pdf
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = Strengthening
 | auteur1                = Laurie Williams
 | auteur2                = Robert R. Kessler
 | auteur3                = Ward Cunningham
 | auteur4                = Ron Jeffries
 | titre                  = Strengthening the Case for Pair Programming
 | périodique             = IEEE Software
 | volume                 = 17
 | numéro                 = 4
 | mois                   = 7
 | année                  = 2000
 | doi                    = 10.1109/52.854064
 | lire en ligne          = http://collaboration.csc.ncsu.edu/laurie/Papers/ieeeSoftware.PDF
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = CSClassroom
 | auteur1                = Grant Braught
 | auteur2                = Tim Wahls
 | auteur3                = L. Marlin Eby
 | titre                  = The Case for Pair Programming in the Computer Science Classroom
 | périodique             = Transactions on Computing Education
 | volume                 = 11
 | numéro                 = 1
 | mois                   = 2
 | année                  = 2011
 | résumé                 = http://dl.acm.org/citation.cfm?id=1921607.1921609
 | consulté le            = 11 décembre 2014 
}}
* {{Article
 | langue                 = en
 | id                     = Industry
 | auteur1                = Mark Zarb
 | auteur2                = Janet Hughes
 | auteur3                = John Richards
 | titre                  = Evaluating industry-inspired pair programming communication guidelines with undergraduate students
 | périodique             = Proceedings of the 45th ACM technical symposium on Computer science education
 | mois                   = 3
 | année                  = 2014
 | doi                    = 10.1145/2538862.2538980
}}
* {{Article
 | langue                 = en
 | id                     = Improving
 | auteur1                = Alex Radermacher
 | auteur2                = Gursimran Walia
 | auteur3                = Richard Rummelt
 | titre                  = Improving student learning outcomes with pair programming
 | périodique             = Proceedings of the ninth annual international conference on International computing education research
 | mois                   = 9
 | année                  = 2012
 | doi                    = 10.1145/2361276.2361294
}}
* {{Article
 | langue                 = en
 | id                     = Individual
 | auteur1                = Grant Braught
 | auteur2                = L. Marlin Eby
 | auteur3                = Tim Wahls
 | titre                  = The Effects of Pair-Programming on Individual Programming Skill
 | périodique             = Proceedings of the 39th SIGCSE technical symposium on Computer science education
 | volume                 = 40
 | numéro                 = 1
 | mois                   = 3
 | année                  = 2008
 | doi                    = 10.1145/1352322.1352207
}}
* {{Article
 | langue                 = en
 | id                     = Kindergarten
 | auteur1                = Laurie A. Williams
 | auteur2                = Robert R. Kessler
 | titre                  = All I really need to know about pair programming I learned in kindergarten
 | périodique             = Communications of the ACM
 | volume                 = 43
 | numéro                 = 5
 | mois                   = 5
 | année                  = 2000
 | doi                    = 10.1145/332833.332848
 | lire en ligne          = http://www.cs.princeton.edu/courses/archive/fall10/cos126/assignments/pairs-kindergarten.pdf
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}
* {{Article
 | langue                 = en
 | id                     = Distributed
 | auteur1                = Julia Schenk
 | auteur2                = Lutz Prechelt
 | auteur3                = Stephan Salinger
 | titre                  = Distributed-pair programming can work well and is not just distributed pair-programming
 | périodique             = Companion Proceedings of the 36th International Conference on Software Engineering
 | mois                   = 6
 | année                  = 2014
 | doi                    = 10.1145/2591062.2591188
 | lire en ligne          = https://arxiv.org/pdf/1311.6249.pdf
 | consulté le            = 11 décembre 2014 
 | format                 = pdf
}}

{{Palette|Qualité logicielle}}

{{Portail|informatique}}

[[Catégorie:Programmation informatique]]
[[Catégorie:Méthode de développement logiciel]]
[[Catégorie:Méthode agile]]