In this blog, we are going to see one of the interesting agile software development technique called “Pair Programming”. There are many agile software development techniques followed around the globe and Pair Programming is one amongst them. Let’s get in to the topic.
What is Pair Programming?
Pair Programming is one of the agile software development technique in which two programmers work together in a single workstation. There two programmers shall have two roles in this technique:
• Driver
• Observer
One of the programmers in the pair will write the code, whom we call as the “Driver”. The other, who observes, navigates, and reviews the code as it is typed in, is called the “Observer” or “Navigator”. The roles will be switched often between them.
Why we go for Pair Programming?
These are some of the reason which I feel are valid enough to opt for Pair Programming:
1. Whenever a new member is getting introduced in a team, we will make them a part of Pair Programming technique, so that they will understand the project flow better. In terms of project understanding, you will be able to see the significant difference between the team member who is part of a pair and a team member who has trained himself with the help of documents or code.
2. Having a senior member and a junior member as a pair will be mutually beneficial. Seniors will be able to pick up some new tricks/ideas while the juniors will learn a lot of new skills from the seniors.
3. Quality of the code will improve considerably since the pairs are switching roles often. This also enables them to track down any defects that arise, easily.
When does Pair Programming fail?
These are some of the factors which I personally feel can attribute to the failure of Pair Programming:
1. Lack of communication between the Driver & Navigator
2. Only one of them focuses on the task and the other cares not about the task
3. Lack of collaboration
4. Unwillingness to share the credits
5. Fear of exposing gaps in knowledge
Personal Experience in Pair Programming:
In Agira, we always have programmers of different hierarchies in our projects. Whenever a new member pitches in, we will engage them into a pair with a senior. Initially they will sit with the senior programmer who does the bug fixing and interact with them in order to understand the project and what the programmer really does to fix the bug.
As the days go by, we will start assigning small issues to them. They will, by now, know how to fix it since they have had a good knowledge on the project and on bug fixing due to this technique. At a later stage, we will start assigning the feature tickets and then, assign a junior pair to them.
This will help the employee to groom their technical, collaboration and interpersonal skills. This technique has worked for us in most of the projects. It might not work for all due to some of the reasons that I have mentioned in the earlier section.
Conclusion:
All techniques have pros and cons. We need to try them out to identify which one suits our needs. I have been involved in trying various techniques and we identified Pair Programming as the solution that suits us better than most others. Therefore we opted it. Now it’s your turn to try it out. Happy Reading!!!
