I think my problem with collective code ownership is that people confuse it with collective code responsibility. Everyone is responsible for the code, yes. To me this means that everyone on the team should be able to look at any code on the project and figure out what is going on and be able to update and maintain it. There are many things that need to be done in order for the team to be collectively responsible for the code base, and maybe I’ll talk about that some other time. Collective code ownership on the other hand, just leads to problems. Everyone should not be hacking the same files at the same time, making random changes without talking to other people and just generally confusing the situation by doing whatever the heck they please. People can, and should, work together on applications, components, modules etc, but when it gets down to the file level, exactly one person should be in control in a given time span (and I mean a time span > a week). Ownership can change over time and there should be other people who can pick up the ownership on a moments noticed should someone disappear off the face of the earth, but this is a matter of responsibility, not ownership. Simultaneous ownership just leads to a big mess and dilutes the knowledge that each person has of a particular piece of code. The details of every piece of code in the system should be well understood by at least one person on the team. However, it is impossible for everyone on the team to know everything about all the code in any significant system to a useful level of detail. There must be single authorities, ergo there must be single ownership.
(BTW, a good side effect of single ownership is nicely defined interfaces between components.)