While reading the morning free software news and blog rolls, I came across this posting by Lennart Poettering bemoaning the state of civility in free software communities. He blames communities and kernel developers (Linus Torvalds specifically, in fact) and laments how he has been on the receiving end of so much negative behavior over the years. I'm glad he's become self-aware of these things because Lennart has been part of the problem he finds himself facing down, part of the bravado-based approach too often seen in free software.
It is not acceptable to threaten people's safety and only marginally more acceptable to "just" be verbally horrible to someone in the day-to-day of co-creation that is free software. Lennart is in the right to call out people who do this and communities who support that kind of behavior.
That said, many of us in the community who are visible and do not shy away from rocking the boat when it makes sense to do so do not receive that kind of response from people. I certainly get my "fair share" of trolls, insults and generally poorly behaved individuals but Lennart's experience is foreign to me and, I suspect, many others in similar positions. The difference? Lennart's approach to dealing with people in the community which has often been less than constructive and open. This does not excuse the people who have been pointing their vitriol and inexcusably bad behavior at Lennart, nor does it place the blame for their actions on Lennart as we are each personally responsible for our actions and words. It is, however, useful for us to look at how these maelstroms are created with honesty and accuracy.
This is the heart of the matter for me: we co-create this environment. None of us are unempowered or simply "acted upon". We may not always like the results, but they are undeniably things we make together, which is why it is referred to as "community". Trying not to overgeneralize too much, I've experienced four types of paths in the free software world each of which result in a different sort of environment. Only one is the one Lennart speaks out against, though two of the other three are not very useful either.
Nobody moves, nobody gets hurt
There are many people who simply don't interact with "the community". They write code, they put out useful technology and interact as little as possible. Sometimes this is because they are just very private or shy people who enjoy a low-key existence and don't feel compelled to do more than this. Others are hoping to avoid the possible negative response that can come from putting yourself out there; we could call this "harm avoidance". This is a very safe approach for the individual and nothing particularly wrong with it, but it does have its negative consequences.
Without communication and togetherness, it is very hard to generate the environment in which software can be effectively co-created. The result are software projects, which may otherwise be great, that are underappreciated, underused and which receive far fewer contributions than they ought to. It isn't good for the software, and this is particularly tragic when the motivation is harm-avoidance.
Getting people and projects out of this mode requires offering them an easy, welcoming and rewarding environment. In other words, not the one Lennart finds himself in. It also requires others reaching out to these people as it is far easier to move beyond "nobody moves, nobody gets hurt" with a little positive encouragement and friendship.
Everybody be nice, or else!
Some communities have adopted the stance that the most important thing in the creation of technology is for everyone to be nice to each other at all times ... or else. This is usually motivated by all the right intentions, though I've seen it used at least once quite non-innocently. Of course everyone should be "nice" and everyone should have the opportunity to work in a "nice" environment. The problem is found in the "or else".
It is really very difficult to discuss issues of design (technical, visual, interaction, etc.) without it being at times uncomfortable: the topic is people's effort and work. They tend to care deeply about their creative efforts and people can have wildly different ideas on what makes for the best approach. This does not make the discussions wrong, it just makes them potentially uncomfortable. Discomfort, however, is not something to be avoided at all costs. Many, if not most, growth experiences in life are accompanied by some discomfort, usually because they involve doing something we aren't familiar with, or good at (yet).
It also diverts the focus from making technology to, well, being nice. The point of a software project is to create software. Being nice is something that ought to happen in the course of that, not the other way around. Communities and individuals who fall into this inversion of priorities make it harder, even impossible, to take on the necessary difficult conversations and tasks. Even worse, sometimes the "be nice" stick becomes a means to simply bully people who they don't agree with; I've seen people set up scenarios where they will stick to their position and anyone who disagrees is "not being nice". It's a sickness, and it happens. This results in the software in question usually failing to deliver rigorous results as the difficult conversations are no longer given room.
Getting people and projects out of this mode requires convincing people of the safety of disagreement and the usefulness of it. That means points of contention must be handled with civility and the rewards that come out of hard work is clearly demonstrated rather than allowed to sink into the background. Usually this is a matter of personal growth of the people in the project, which is never a bad thing either.
Bad Boyz Club
This is the scenario that Lennart finds himself in, where people learn to behave badly because it delivers results and because their role models do it as well. There is not much that I probably need to say here as Lennart did a good job of casting light on it. It's destructive, it's chases people away who have better sensibilities and it is damn hard to fix once a community sinks into it. The best remedy is to simply avoid ever getting there in the first place. Those that enter your community dragging this kind of behavior behind them ought be shown the door (after given a suitable chance to moderate their own actions).
It does share something in common with "everybody be nice, or else!", though: both patterns distract from the actual act of creating great technology together. The focus increasingly becomes on interpersonal behavior rather than making technology. Again, this inversion of priorities, where the behavior ought to be in support of the primary focus of making great technology, takes a toll on the software in question.
This is the healthy path where people focus on technology creation first and foremost and the one we would all do well to get as many free software communities on. In these kinds of environments, social interactions are something that happen as a happy by-product of making great technology together. Requiring responsible adult behavior (including being good to each other) is something that happens in support of that. Very little else gets in the way of the task at hand of making software. Difficult discussions are made easier as the focus is on the end result (the software) rather than everyone sitting on the edge of their seat hoping nothing bad happens. None of it is personal, positively or negatively, and this allows healthy projects which in turn create excellent social groups to be a part of.
Thankfully this is where most of the free software projects I've experienced sit. Most live in this sensible realm that recognizes that the goal is to make awesome technology in an ethical manner. The result is some of the best software we have anywhere and some great communities to go with them. Period.
So while I agree with Lennart that the "bad boyz club" mode is deadly for free software and unjust on the personal level, I disagree with Lennart's claim that free software as a whole is a "sick place to be in" because, quite simply, most of free software doesn't operate as a "bad boyz club".
He is absolutely right that the "bad boyz clubs" need addressing and that they are failing to serve their community members and users; but thankfully it is not the majority case. Yes, even in technology-focused co-creative communities there are occasional instances of people behaving badly, but it's the exception rather than the norm. Thankfully.