As I've noted before, I came to BSD from System V, the "professional" UNIX. When I did, I came with the expectation that free operating systems were toys, less professional. As we've all discovered, that's not the case: even in my first article about BSD, in the June 1992 issue of iX, I wrote that BSD/386 Beta 0.3.1 was more stable than the Interactive UNIX System V I had been running up to then. Still, the development methodology is different, and we're still learning about it. There's no doubt about the quality of the software, but how about the environment in which we develop it. Are we being "professional"? Do we want to? One thing we expect of "professionals" is their social behaviour: they should treat each other with respect.
This is a delicate topic, especially at present. I should make clear here that, although I am a member of the FreeBSD core team, the opinions I express here are my own. All the information presented here is freely available elsewhere.
Since then we've learnt a lot about running projects on the Internet, and the relationship between the BSD projects is now much more relaxed. I like to think that Daemon News has helped contribute to a sense of communality.
That doesn't mean that people within the project always treat each other with respect, though. Over the last several months I've seen some things happen which I find worrying.
Some people are just plain hard to get on with. They have personality problems which make them arrogant or aggressive. It's not surprising that more clever, successful people are arrogant than are stupid, ineffectual people, and we have enough clever, successful people on the project for arrogance to be a problem. On the other hand, of course, developing software can often be frustrating, and that can promote aggression. In addition, the main means of communication in the projects are electronic, and we've repeatedly seen how some people have difficulty expressing themselves in electronic form. Let's look at the problems that occur:
This kind of issue is usually harmless until somebody insists on continuing. It's disrespectful of the other participants, of which there may be many: for example, the FreeBSD-questions mailing list has over 2000 members, many of which are themselves distribution lists. Normally this is an unintentional disrespect, but we've seen some flames on the lists as a result.
It doesn't seem like that any more. Yes, people still talk tech stuff, but there's a certain underlying feeling of hostility there. It almost seems as if some FreeBSD developers use IRC as a tool for flaming, and some with operator privileges use them to throw other people off the channel.
Much of this opinion is subjective, of course, and I certainly have no intention of giving examples. I'm not the only one who sees things this way: there have been a number of messages in the FreeBSD lists recently complaining of the same problem. Gradually a subliminal feeling of hostility has grown up in the project. Why is this?
How should we deal with the problem? Years ago, the NetBSD core team removed one of their number from the team. One result was the OpenBSD project. While there's still a noticeable amount of tension as the result of this decision, the results haven't all been negative: without it, the OpenBSD project in this form might never have developed. At one level, though, it seems to point to the fact that like personalities work better together, and that this might be a good solution for such problems.
What can we do about the issue? Obviously the FreeBSD project has got too big for voluntary self-control, and I suspect it's only a matter of time before the other BSDs follow suit. It's interesting to note that this kind of problem is more common in volunteer organizations, and I've seen a number of such organizations (not necessarily software projects) disintegrate as a result of interpersonal conflicts. It doesn't happen in any well-run company: one of the first tenets of personnel management is that trouble-makers need to go, no matter what their technical merits. In badly-run companies, financial considerations tend to limit the damage it can do.
Things are a little different in the developer community. We can't just throw out developers because they're abusive. Or can we? The FreeBSD project has a Big List of Rules for developers, and it includes the possibility of expulsion from the project in this case. In the past the core team has been extremely reluctant to use this "Big Stick": it's not good practice to throw out volunteers.
But what alternative is there? I suspect that as free software projects grow, it will become increasingly necessary. It's important to keep expulsion as a last-ditch resort, but it's important to keep it. In general, as projects get larger, they become require more discipline and rules than the original group of "amateurs" who started the project. In this respect they resemble commercial companies.
At the beginning of this month, the FreeBSD core team finally decided to expel a member of the development team, Matt Dillon. We didn't take this decision lightly: Matt has been a significant contributor to the FreeBSD project, but his personality has been disruptive. Little of this is evident outside the project, and we have been roundly criticized for doing so. As stated in the link, for the sake of the people involved we keep the details confidential. It's possible that this is a mistake, but it's our current policy.
Not all feedback was negative. We also received a lot of positive feedback. Interestingly, the positive feedback was in private messages, whereas the negative feedback was mainly public. Less surprisingly, the positive feedback came from developers who had worked with Matt.