Peter Hancock has an interesting post about rotating developers from project to project. While I agree with a lot of what he says, I don't think this is always a good thing. Maybe it's because I am coming at it from a consulting point of view, but losing a developer on a team is a tough thing to explain to clients. Not because they don't have faith that we can bring on another solid developer, but because developers gain domain knowledge as they work get into the details of the project.

Clients don't like to lose developers with domain knowledge, especially if it's not their decision. It's nearly impossible to tell a client that you're pulling a key piece of the development team to replace them with a new developer. It just doesn't fly. Yeah, their technical differences may be negligible, but the domain specific knowledge leaves with the first developer.

There's another peice to "hot swapping" developers. Certain people work better together than others. Ideally, this wouldn't be true, but everyone has personalities, and eventually, you'll come across two that conflict. You can force them to work together and say "get over it" but even if they appear to be working together, their productivity is most likely not what it could be. On the other hand, certain developers work better together - they just "get" each other. There's not a lot that needs to be done to communicate between them - they just know what the other one expects. In this case, productivity goes up.

And while I understand the idea of spreading the knowledge around, I think having a more productive team is a worthwhile trade off. I also think that developers can get the knowledge from other teams in other ways - lunch 'n' learns, demos, hallway conversations, etc. Yeah, it's not as in-depth as having them on your team, but most of the time it's enough to pique the interest of a developer. That's how I first got into continuous integration. I'd never been on a project with it before, but I talked to team that did have it (and saw the orb), and decided that it would be a pretty good idea to see what this CI thing was all about. I learned it on my own, rather than bringing someone from that team onto our project.

Had we just brought someone onto our project, they would have set it all up. We would all benefit, but I'm not sure the knowledge transfer would have happened anyway. On the other hand, because I didn't have someone to do it for me, I had to figure it out.

Maybe it has to do with the motivation of the developers. Are they happy where they are at, or are they always striving to learn more? If they're striving to learn more, they will.