Pair programming is one of the most fun and productive activities in an engineering team. I am a huge fan of pairing sessions and am a believer that every engineering team should adopt them if they haven’t yet. But that does not mean that every pairing sessions is good. If you have frequently participated in pairing sessions, then you will most likely have experienced at least one session that wasn’t great. Perhaps one that you felt went on forever without an ending. Otherwise, one that you think was completely useless. Or one that you didn’t think was necessary.
Although pair programming as a concept has a lot of benefits, if the actual pairing sessions are not executed properly then they will be the complete opposite — unproductive, not fun, mentally exhausting, and discouraging. In this article, I go over 5 things that you can do to make future pairing programming sessions more effective.
One of the most important things that you should start a session with, or even do beforehand, is discussing the scope of the session. What is the starting point? What are we trying to achieve? What is the goal? When do we end? What do we include in or exclude from this session? All these questions are important to consider and answer with your partner before starting any coding.
With these questions answered, you will have clear guidelines for the pairing session. It makes it easier to stay on track, stay focused, know whether something should be done in this session, and know whether you are done. This way both participants will know what to expect and avoid being sidetracked by unnecessary topics.
Nobody likes a pairing session that goes on like there is no tomorrow without any ending in sight. Not only are long sessions physically exhausting, but also mentally exhausting, productivity diminishing, and creativity diminishing. To avoid this, you must make sure to take breaks regularly when doing pairing sessions. Humans only have a limited attention span, therefore properly taking breaks during pairing sessions is essential for keeping the effectiveness high.
During pairing sessions, it is common to be assigned either of two roles, namely the navigator or the driver. The navigator is the developer giving instructions to the other, therefore more often than not leading the sessions. On the other side of the navigator is the driver, which is the developer who is responsible for receiving the instructions and executing them.
In reality, these roles might not be as clear-cut. My pairing sessions are often discussion like, where the both of us are constantly inputting information and bouncing ideas of each other. But in some way or another, there will be a form of driver and navigator roles present. The person sharing the screen would be the driver, while the person watching is the navigator.
No matter how thoroughly you adhere to these roles, it’s important to remember to switch between roles regularly. The worse thing is being stuck in a certain role and not receiving the chance to switch it up. I have experienced people being mentally fatigued for the day by being on the receiving end of instructions for way too long. Switching roles regularly is great for a change of pace and also make you view the topic of the session from a different perspective.
In the end, pair programming is something that happens between two developers. This means that all things considered, communication will play a role. Thus for a pairing session to go smoothly, communication must be handled properly.
The most important aspect of this is that the participating developers should be actively communicating with one another. This could be about the scope of the sessions, the pace, potential mistakes, progress, and other things. When one participant is not actively communicating, the session is basically one developer doing their usual business while another developer is spectating. This is not an effective pairing session.
Thus every participant of a pairing session must be actively trying to communicate to make a pairing session effective and worth everyone’s time.
Continuing on the previous point of communication is handling feedback. As mentioned, active communication plays a crucial role in making a pairing session effective. One of the most important forms of communication is giving feedback to one another. In the end, this is also the most worthwhile aspect to pairing sessions, namely clashing with each other and becoming more refined by learning from it.
But for this to happen, two things are necessary from every developer. Namely that you as a participant of a pairing session provide feedback to the other if the opportunity occurs and in particular can handle feedback properly. We have already discussed the former utilizing active communication. The latter is what is crucial for this tip, as receiving feedback is useless if you can not handle it properly. Handling feedback well starts with accepting that you are not perfect and being open to feedback
Pair programming as a concept bears tremendous potential for providing a team with a lot of value in terms of productivity, business value, and quality. To help you reap these results, this article goes over 5 ways that will help you make pair programming sessions more effective. This starts with discussing the scope of a session so everyone is on the same level of understanding. Then, during pairing sessions, it’s important to take breaks and switch roles regularly so everyone stays fresh. Lastly, the key to effective pairing sessions is active communication and being open to feedback since those create the best learning moments.