This site uses tracking cookies used for marketing and statistics. Privacy Policy

Pair Programming - The Good, The Bad, And The Ugly

September 14th, 2018

In an organization, always two minds are better than one. This means teamwork is more productive than work done by an individual. But when it comes to promotion, those two minds only will clash with each other. The same is the concept of Pair Programming.

What is Pair Programming?

Pair programming (sometimes also called peer programming) is a delicate subject. While some turn red with their love for it, others turn red with anger. It is basically a growing software development technique in which two programmers work on a single code block. One writes, and the other one observes. So, there are undoubtedly different approaches and practices to co-operate and finish it. Generally, the one who writes is called Driver. Whereas the observer is called Navigator. The Driver focuses on writing and thinks about the current task. It is usually a part of a big task. Whereas Navigator focuses on detecting bugs & problems, structure, and what to focus on next.

This type of division is to keep a steady development flow and help share knowledge across the team. There has to be fine coordination between both the Driver and the Navigator. Numerous studies show the tremendous advantages of Pair Programming - increased output and a quality product being two of them. Pair programming enhances the learning for both the participants.

According to Kent Beck, “Pair programming keeps each other on task. Brainstorm refinements to the system. Clarify ideas. Helps when their partner is stuck, thus lowering frustration. Hold each other accountable for the team’s practices.”

The Good

  • When two brains focus on a single code, errors and failures will reduce. Hence coding will be safer.

  • The actual development time might be a bit faster or slower. But with higher quality, you will save time in error fixing and refactoring code.

  • Fewer errors and other issues will reduce the cost and provide us with happier users. Happy users are often equal to more money.

  • With a partner, you’re able to discuss different structures and solutions that would not have come up by yourself. Hence, better coding will be possible.

  • Pairing means more communication. It improves the better spreading of knowledge across the team regarding coding, project, company, workflow, and anything else.

  • It’s a huge benefit for newbies. Juniors often learn much faster when in pair programming with a senior.

  • For a productive collaboration, clear communication is needed. And thus, it provides a better understanding of the task.

  • Experience sharing will benefit all. Pair programming is all about constantly learning and sharing. Yes, even if you’re a senior, you have things you do not know.

  • The confidence level will boost up. Pair programmers often have higher confidence since two brains work together.

  • It’s good to work with different colleagues. You’ll get to know others as well as learn from them.

  • Having a constant dialogue helps you to stay focused on coding.

The Bad

Not everything comes with positive aspects only. There are some drawbacks to everything. Following are the ones for Pair Programming:

  • Not necessarily everyone enjoys working together. Some like to work alone.

  • Pairing at the wrong time can be both time-consuming and inefficient.

  • If one turns out to be a slow thinker or unfocused, it will affect the other person too.

  • More talk and less coding. You might end up explaining things rather than coding.

The Ugly

  • Code ownership conflicts - Since two developers have worked on the code, both can feel that the other person is more responsible.

  • Blame games - If an error occurs, it could turn into a debate on who did it and who should fix it.

When to pair and when not to?

Not all tasks are made to be done by a pair. You should pair, only if it is worth pairing. Decide according to the requirements. Pairing up for wrong tasks can lead to complications. Also, pair according to the nature of the work. For a difficult task, check if either a solo senior or a pair of juniors are required. Or maybe it’s touching a core feature, so having a senior-junior combination might be an opportunity to strengthen the skills and knowledge.

Pair Combinations

Driver-Navigator Roles

Generally, pair programming has been popularized through the driver-navigator technique. It can be senior-senior, senior-junior, or junior-junior. And both should be open to switching roles as and when required. But, in this style of pair programming, the Navigator instantly loses his interest. It occurs when either the person in charge of writing isn’t communicating well. Effective communication is the key for making this type of programming work. Sadly, this level of interaction isn’t inherent in a fresh pair.

Strong & Traditional Pairing Techniques

In this approach, the Driver does nothing that the Navigator did not direct him to. As explained by Llewellyn, “For an idea to go from your head to the computer, it must go through someone else’s hands.”

Whenever the Driver requires intervention in the idea, he must hand over the system to his partner and take his position. This approach completely engages the Navigator. The traditional approach required the Navigator to ask for the system to provide his input or implement his idea.

Ping-Pong Pairing

One more pair programming pattern frequently employed by developers is the ping-pong pairing. In this approach, the Driver drafts a test for behavior and requests the Navigator to apply the behavior. Once implemented, the Navigator takes his turn. And the new Driver jot down the next test for the new Navigator to check.

Finding time to refactor both codes and do testing is the biggest challenge with this pattern. Implementing a feature can be complicated, and it will make testing complex too. It’s simpler to carry on a progressive momentum where properties are being applied. But we also need to pay attention to the simplicity of the code so that it can be effortlessly maintained. A similar idea also applies to the testing part. In short Ping-Pong pairing helps professionals keep an eye on both - coding as well as testing the elements.

This was the 360-degree view of Pair Programming. I believe you would have made your opinion on it. By the way, we are a web and mobile app development company called Acquaint Softtech. If you have any problem regarding this, you can reach out to us at info@acquaintsoft.com or +1 773 377 6499 to talk business. Loved this post? Please share then.

Mukesh Ram

Founder and CEO, Acquaint Softtech

I love to make a difference. Thus, I started Acquaint Softtech with the vision of making developers easily accessible and affordable to all. Me and my beloved team have been fulfilling this vision for over 15 years now and will continue to get even bigger and better.

Share this on

Subscribe to new posts

Other Interesting Readings