Pair programming
Pair programming requires two software engineers to participate in a combined development effort at one workstation.
Each member performs the action the other is not currently doing: While one types in unit tests the other thinks about the class that will satisfy the test, for example.
Pair Programming yields the following benefits, roughly ordered from largest benefit to smallest:
- Increased discipline. Pairing partners are more likely to "do the right thing" and are less likely to take long breaks.
- Better code. Pairing partners are less likely to go down GopherHoles and tend to come up with higher quality designs.
- Resilient flow. Pairing leads to a different kind of MentalStateCalledFlow than programming alone, but it does lead to flow. Pairing flow happens more quickly: one programmer asks the other, "What were we working on?" Pairing flow is also more resilient to interruptions: one programmer deals with the interruption while the other keeps working.
- Improved morale. Pair programming, done well, is much more enjoyable than programming alone, done well. (On the other hand, pair programming done poorly is much less enjoyable than programming alone done poorly.)
- Collective code ownership. When everyone on a project is PairProgramming, and pairs rotate frequently, everybody gains a working knowledge of the entire codebase.
- Mentoring. Everyone, even junior programmers, has knowledge that others don't. Pair programming is a painless way of spreading that knowledge.
- Team cohesion. People get to know each other more quickly when pair programming. Pair programming may encourage team jelling.
- Fewer interruptions. People are more reluctant to interrupt a pair than they are to interrupt someone working alone.
Studies have shown that after training for the "people skills" involved, two programmers are more than twice as productive as one for a given task. According to
The Economist,
- "Laurie Williams of the University of Utah in Salt Lake City has shown that paired programmers are only 15% slower than two independent individual programmers, but produce 15% fewer bugs. Since testing and debugging are often many times more costly than initial programming, this is an impressive result." [1]
See also: Extreme programming
External link