I wonder if the type of work you are doing has anything to do with it. Web projects are typically mostly about UX design, architecture, security, and scalability. Very few of these tasks are "unsolved" -- you can do pretty much anything you want to on the Web with some code reuse and good architecture. Therefore, the knowledge sharing of pair programming might work here, since the main goal of a web development project is to have everybody on the same page in terms of best practices, architecture, etc.
Now, if you're writing novel code, new algorithms, working with big data, or writing performance or security critical software, then I can see how the heads-down approach might be more effective. For these projects, maybe understanding the whole system is less critical than, say, programming your component to be 100% optimized.
I do work on writing novel code, that is multithreaded, and sensitive to performance. Maybe that is better suited to solo development. That's a separate issue from personality. Some people seem to thrive with more collaborative forms of development, some wither. I'm struck by that distinction every time there is an HN discussion of pair programming.
Yes, exactly. Unfortunately, every so often you get these companies that take on a process as "part of their core culture", when culture should be about principle, not process.
By taking a practice as a core value, they are implicitly stating that it is the One True Way to do things, which means that anyone NOT doing it the One True Way is doing it wrong (to the point that they refuse to hire anyone unwilling to toe the line). I wonder how these people would feel entering a company whose One True Way is waterfall development? Because up until a decade and a half ago, that WAS the One True Way.
One thing you should definitely be careful of (not sure if you do this or not) is requiring adherence to a process that demonstrably doesn't work for a sufficiently large percentage of the population. As another poster pointed out, they select against people who don't like to pair program, which cuts out a large percentage of the (good) developer population, thus fostering monoculture.
Agreed. The "open dev time" idea is attractive, and I can imagine developers getting excited about it, (or at least developers who enjoy doing side projects). But it doesn't seem to address kstenerud's point.
In our interview process, we want developers who like writing software, and want to improve. Asking about side projects, software topics they're researching on their own, languages they're playing with, seems to be a useful thing to focus on. Or at least, I tend to like candidates with good answers to those questions. That's a monoculture I think I'd actually like.
This hits on a latent suspicion of mine, which is that at its core pair programming is really just a way to make tedious programming jobs less tedious. Granted, I say that as someone who also spends most his time working on complex multithreaded performance-critical code and development of new algorithms, and I'm partial enough to that kind of work to have some uncharitable bias.
I tend to think that design by committee, even with a committee of two, reliably produces inferior results. So when really novel work is necessary a much better way to put two people on the same task is to have them both take a crack at it independently and then come back together to see what works best. Sometimes competition is the best form of collaboration.
Well, I'm glad that you find writing algorithms not tedious, because I surely don't want to be doing that! Architecture and good software tooling are what really tickle my fancy. It's good there are people with interests along the levels of abstraction.
I agree, I dislike "design by committee". However, sometimes you get to work with those magical, rare people who are both seasoned architecture gurus and have very good social and speaking skills. Working with these kinds of people is an absolute joy -- I will learn more in an hour of watching a skilled developer program than I will from a month of reading online material.
OP here. I strongly disagree with the assertion that pair programming isn't helpful in sensitive or mission critical applications.
Braintree's core product is a payment processing gateway. If we go down, get hacked, or introduce serious bugs, our customers can't run their businesses. As I said in the article, we pair for almost everything, and we find it helps us write great software that stays up and stays secure.
I didn't mean to actually lay out categories where one style is more effective than another -- I don't have that experience. I was simply proposing a framework to think about the differences between development teams and how that might affect the effectiveness of pair programming. Obviously, "web" projects have significant security and performance requirements, which could definitely benefit from pair programming in your context.
I should have focused on the distinction between the size of companies -- that seems like a more accurate framework. I suppose I meant "performance" in the sense of low-level algorithm efficiency rather than high-level scalability and reliability. A misuse of the term on my part.