I don't want to work alone anymore

Few months ago we decided to focus more on pair programming. We were doing it from time to time before, but after few conversations with far more experienced people, I spoke with the team and we agreed that it's worth to try doing more pair programming.

If there were so many people, who found pair programming as a one of the greatest technique they have ever experienced, it should be worth to spend some more time to improve it in our Scrum. What bad could happen either way?

After those few months, I can say that was really good idea to invest more time and improve this technique in our team. Right now almost half of our user stories are implemented in pairs and everyone loves it. Why?

more efficient knowledge spreading

If you are programming alone and you reach the place with unknown mechanism, functionality, module or domain part, you need help. If there is a documentation you can search for answer. It can be less or more time consuming, everything depends on the way how the documentation looks like and how accure it is. Hopefully it won't be missleading, because of lack of updates. Of course you also need to know what you are looking for, know what questions should be asked to get the right answer.

If there is no documentation (unfortunately it's really often situation, even in big projects), you'll need to ask for help of one of your team member. I know that many people at this moment spend some time on their own to do small investigation, because they think it's possible to find answers without interrupt anyone. Sometimes they succeed, sometimes not. If so, they wasted some time, because the answer could take one minute of time of someone, who already knows the problem.
If they won't succeed (or did not try) they will have to interrupt someone else work to get answer. And, depends on interruptions time, it costs more or less time.

When programmers work in pairs there is no such a problem (maybe not completly, but it's occure much less often), because usually in pair there is one more experienced programmer whose knowledge is higher and enough (in most of the cases) to explain most of the mysteries, which software have, no matter if those are about technical stuff or domain. No interruptions, no waste of time. You got a question? Doubts? Just ask developer who is working with you. You will get better answer, more accurate and definately up to date and if there will be more question, there will be no problem to dig deeper until you will know everything what is needed.

less bugs in code

Two heads are better than one, so if two programmers are sitting on the code, there is less chance to do something wrong, because one of you can notice something that other one missed. It's bigger chance to avoid huge bugs in code, because more often you will notice that you go in the wrong direction before you will go to far.

better quality and more efficient code

Two people means more experience, more written line of code, more problems solved and it directly lead to better solutions for current problems, better design for current functionality and so on.
I noticed that in pairs developers removes code smells, before they will really start to stink.

Of course, heated discussions happens, but it's also good. It's much better to have those discussions before implementation than after it. You just saving your and your teammates time. When there is not a single line of code to protect, it's much more easier to agree with your oponent and look for the best solution.

you won't let yourself for interrupters

Smartphones, social networks, blogs, forums, mail clients and so on. There is many interrupters around us and when we are left alone, we often takes small brakes, because of new post, comment or e-mail. It's only "quick look" and that's it, isn't it?

I don't want to discuss whether we should turn off all of them or not and when we should look at them. I just want to say, that if you're working in pairs those interrupters aren't so danger for you anymore. You are just more focus on working with other developer and you got no time for "quick look" at new post on twitter.

less downtimes

It sometimes happens, that you just got no idea how to do thing, how to even start and you go back and forth and have hope that you will finally find a solution. Or at least something, which let you to move on.

Those stops are shorter when you are working in pairs. I will write it one more time - two heads are better than one and brain storms are sometimes more productive then thinking alone in silence. And it's less possible that two persons will have their short creative impotence at the same time.

you don't want to be a single any more

I know that people, who are against pair programming are telling that it's just waste of time and money. Two programmers are working on the same issue at the same time? They could do twice more if they would work separately! It's not true, for real, our development is faster when we start do more pair programming, programmers becomes better and better and it's really visible.

I know that it can look weird that 2 on 1 are better than 2 on 2, but remeber about time saved on interruptions, on code reviews, on those researches and investigations. Time you get, because programmers increased the knowledge in more efficient way. Software is more maintainable, because of higher code quality. It's better, because solutions which programmers delivered aren't good one, those are one of the best solutions possible.

Maybe it's worth to try?