What is Pair Programming?

Advantages, Challenges,
Tutorials & More
STACKIFYJUNE 22, 2017BUILDBETTER, DEVELOPER TIPS, TRICKS &
RESOURCES LEAVE A COMMENT
Developers do their best work when they’re inspired and empowered, as we discussed
recently in this post. That means equipping your developers with the tools and
resources they need to be more efficient, blending agility with accuracy to build better
products, faster. There are several tactics for achieving these goals, many of which
work well in tandem. Application performance monitoring, for instance, helps you take a
proactive approach to monitoring rather than responding to issues only after they’ve
reached your users. Another method for boosting efficiency is pair programming, Let’s
take a look at pair programming advantages, concept, and challenges of pair
programming.

Definition of Pair Programming

As the name implies, pair programming is where two developers work using only one
machine. Each one has a keyboard and a mouse. One programmer acts as the driver
who codes while the other will serve as the observer who will check the code being
written, proofread and spell check it, while also figuring out where to go next. These
roles can be switched at any time: the driver will then become the observer and vice
versa.

It’s also commonly called “pairing,” “programming in pairs,” and “paired programming.”

Pair Programming Advantages

There are several compelling reasons you should consider this strategy:

 Two heads are better than one. If the driver encounters a hitch with the code,
there will be two of them who’ll solve the problem.
 More efficient. Common thinking is that it slows down the project completion time
because you are effectively putting two programmers to develop a single program,
instead of having them work independently on two different programs. But studies
have shown that two programmers working on the same program are only 15%
slower than when these programmers work independently, rather than the
presupposed 50% slow down.
 Fewer coding mistakes. Because there is another programmer looking over your
work, it results in better code. In fact, an earlier study shows that it results in 15%
fewer bugs than code written by solo programmers. Plus, it allows the driver to
remain focus on the code being written while the other attends to external matters or
interruption.
 An effective way to share knowledge. Code Fellows talks about how it could help
programmers learn from their peers in this blog post. It would allow programmers to
get instant face-to-face instruction, which is much better than online tutorials and
faster than looking for resources on the Internet. Plus, you can learn things better
from your partner, especially in areas that may be unfamiliar to you. Developers can
also pick up best practices and better techniques from more advanced
programmers. It can also facilitate mentoring relationships between two
programmers.
 Develops your staff’s interpersonal skills. Collaborating on a single project helps
your team to appreciate the value of communication and teamwork.

In sum, it helps your programmers learn from each other while coming up with programs
and applications with better code quality and fewer bugs.

Alistair Cockburn of Humans and Technology and Laurie Williams of the University of
Utah – Computer Science Department have come up with a bullet list of benefits:

 Fewer mistakes are introduced into your code because a lot of errors are caught as
they are being typed. This level of continuous code reviews gives rise to fewer bugs
in your code.
 You have shorter and tighter code.
 Two people can solve the problems that crop up along the way faster and quicker.
 Your developers learn more about things that are specific to the applications that
they are working on as well as software development in general, best practices, and
other areas.
 You have more people who know how the new program works. This means that if
one of the pair leaves the company, it will not kill the project.
 Your team develops better interpersonal and social skills. Team members can learn
to communicate with each other, work together, and share information.
 Your team members are more satisfied.
Why is Programming in Pairs Better than Code Reviews?
Code reviews are a process wherein another programmer takes a look at your code to
find something that needs improvement or find defects in it. It combines testing with
quality control to ensure that everything in your code is good. This helps you ensure that
your code is improved.

However, it is challenging to find somebody to review your code because people may
not want to look at another’s code and understand their reasoning just for the sake of
checking its quality. Most of the time, code reviews happen when somebody else tries
to add some functionality to your code, or fixes bugs. But by then, you, as the original
programmer, might not even be around to appreciate the code review.

With pairing, it is like having somebody review your code instantly and regularly. It is a
higher form of code reviews. Two people have to be there and understand the program
being written. And if one sees problems with the other’s code, then it can be instantly
corrected. You also have fewer chances of having bugs written into your code. Code
reviews are not as proactive as you have to wait until the code is completed — bugs
and all — before somebody could take a look at and correct it.

Challenges of Pairing
The common problems observed when it comes to pair programming include the
following:

 The pair should be equally engaged and be participative for the duration of the task.
Otherwise, there would be no benefits.
 People who have not tried it may think that it will double the cost because you are
putting two programmers on one project. However, this is a misconception that
needs to be clarified. On top of the fact that pairing, done right, will only result in
15% slowdowns in terms of the individual output, it actually speeds up the coding
process and ensures better quality code, which lessens the chances that the
program would have to be redone.
 Pair programming should also be a programming out loud process, where the pair is
verbally detailing what it is doing.
 It’s not something that you can force your team to do. It’s highly social and
interactive, so you should be able to detect pairs that may have problems with each
other, such as clashing personalities or even problems with personal hygiene.

How to Effectively Pair Your Programmers

The best way to approach pairing is to partner two programmers and have them share a
computer. Make them work together to architect, code and then test their codes in a
genuine sense of a partnership. While the ideal setup would include two programmers
who are equally skilled (expert – expert or novice – novice), you can also use pair
programming for training and educational purposes (expert – novice).

The pair should be able to decide how to split the work, and it is advisable that they
should switch roles often.