Lets start with someone being on a different level. This is the obvious one and easy one to explain. Simply put, for the person who's more senior, it can be frustrating. You have two choices, slow down and teach the other person, or leave them behind and forge ahead doing work while they watch. Of course, you can only do the latter when you're at the keyboard.
The first approach is better since you bring up the level of the other person; the second approach isn't even really pairing. But, the first approach is problematic. Eventually, you get burned out of teaching. Especially if the person just seems slow, or stubborn. You could get rid of those people of course. There is a way to solve this though, switch pairs frequently. That isn't something that hasn't been said and done before of course. I'm just reiterating it because we don't switch nearly enough at NYSE.
In deadline situations however, it might just be better to take the reigns and plow ahead.
Onto the next problem, pairing with someone who's not on the same page as you. This could be in any way imaginable. Here are some examples:
- They are old and lame, and you're young and cool
- They like using Debuggers (lame), you like writing Unit Tests (cool)
- They like checked exceptions, you like unchecked
- They chew gum with their mouth open and you just want to smash them
- A bunch of others
There is another problem I've noticed with Pairing and Legacy Code. Much of the time, you have to look through the code slowly to figure it out. Either person might want to look at different parts of the code. Its frustrating to have ideas about what the code is doing, and if you're not at the keyboard so you can't look at that area. It seems that its almost better to split up, review the code, then come back together to do the work. This presents other problems though. Sometimes while trying to figure out the code, you'll want to write tests, and refactor. But that is actually contributing to the work. I'm not articulating my thoughts exactly as I want to. If you split up and do work you aren't pairing. Thats not good. Ugh. I guess the whole point of that is that its difficult to pair and read legacy code.
Lets really quick review how to fix the problems:
- Switch Pairs regularly
- Communicate a lot
- Teach people to bring them up a level
- Don't worry about plowing ahead with a huge deadline looming