Tag Archives: community management

Women in Open Source – the canary in the coal mine

The other month I had the pleasure watching Angie Byron give the keynote lecture at Open Web Vancouver on Women in Open Source. The synopsis from Open Web Vancouver:

The open source world is rich with opportunities: Working with people of all cultures from all over the world; Collaborating with some of the biggest and brightest minds on the ultimate solutions to complicated problems; Changing the world by providing free tools for organizations such as non-profits, educational institutions, and governments; Building up marketable skills and practical knowledge.

But yet, so many women are missing out. Why is that? And what can we do to change it? This talk will endeavour to answer these questions, as well as provide tips and strategies for women who want to dip their toe into the waters.

I wish I could embed the video on my blog but alas, it is not possible, so I encourage you to wander over to Angie’s blog and watch the video there.

The important lesson about Angie’s talk is that it isn’t just about women. The power and capacity of an open source community is determined by the quantity and quality of its social capital. If a community fails to invest in either – if it turns off or away qualified people because its culture (however unintentionally) discriminates against a gender, race or group – then it limits its growth and potential. The same is true of a community culture that doesn’t allow certain groups to improve their social capital. These may seem like large, intangible questions, but they are not. I’m sure every open source community turns some people off. Sometimes the reasons are good – the fit might not be right. But sometimes, I’m certain the reasons are not good. And the community may never get the feedback it needs because the moderate, productive person who walks away doesn’t create a scene, they may just quietly disappear (or worse they never showed up to begin with).

So Angie matters not just because women are missing out (although this is true, important and urgent). Angie’s talk matters because women are just the canary in the coal mine. Millions of people are missing out – people with ideas and the ability to make contributions get turned away because of a bad experience, because a community’s culture is off putting, too aggressive, not welcoming or not supportive.

For me its opened up a whole new way of thinking about my writing on open source communities. After Angie’s talk I sought her out as I felt we’d been talking about the same things. I’m interested in developing norms, skills and tools within an open source community that allows more people to participate and collaborate more effective, in short how do we think about community management. Angie is talking about developing open source communities that support and engage women. Working towards solving one helps us solve the other. So if you wake up today and notice there are no (other) women on the IRC channel with you… maybe we should both individually and collectively as a community engage in a little introspection and think about what we could change. Doing so won’t only make the community more inclusive, it will make it more productive and effective as well.

How to predict the "Fixability" of a Bugzilla Submission

bugzilla iconMy friend Diederik van Liere has written a very, very cool jet-pack add-on that calculates the probability a bug report will result in a fixed bug.

The skinny on it is that Diederik’s app bases its prediction on the bug reporter’s experience, their past success rate, the presence of a stack trace and whether the bug reporter is a Mozilla affiliate. These variables appear to be strong and positive predictors of whether a bug will be fixed. The add-on can be downloaded here and its underlying methodology is explained in this blog post.

One way the add-on could be helpful is that it would enable the mozilla community to focus its resources on the most promising bug reports. Volunteer coders with limited time who want to show up and and take ownership over a specific bug would probably find this add-on handy as it would help them spend their precious volunteer time on bugs that are likely well thought through, documented effectively and submitted by someone who will be accessible and able to provide them with input if necessary.

The danger of course, is that a tool like this might further enhance (what I imagine is) a power-law like distribution of bug submitters. The add-on would allow those who are already the most effective bug submitters to get still more attention while first time submitters or those who are still learning may not receive as much sufficient attention (coaching, feedback, support) to improve. Indeed, one powerful way the tool might be used (and which I’m about to talk to Diederik about) is to determine if there are classes of bug submitters who are least likely to be successful. If we can find some common traits among them it might be possible to identify ways to better support them and/or enable them to contribute to the community more effectively. Suddenly a group of people who have expressed interest but have been inadvertently marginalized (not on purpose) could be brought more effectively into the community. Such a group might be the lowest hanging fruit in finding the next million mozillians.

Structurelessness, feminism and open: what open advocates can learn from second wave feminists

Just finished reading feminist activist Jo Freeman’s article, written in 1970, called The Tyranny of Structurelessness. She argues there is no such thing as a structureless group, and that structurelessness tends to be invoked to cover up or obscure — and cannot eliminate — the role, nature, ownership and use of power within a group.

The article is worth reading, especially for advocates of open (open-source and openspace/unconference). Occasionally I hear advocates of open source — and more frequently hear organizers of unconferences/openspaces — argue that because of the open, unstructured nature of the process, they are more democratic than alternatives. Freeman’s article is worth reading as it serves as a useful critique of the limits of open as well as a reminder that open groups, organizations and processes are neither structureless, nor inherently democratic. Claiming either is at best problematic; at worst it places the sustainability of the organization or effort in jeopardy. Moreover, recognizing this reality doesn’t make being open less powerful or useful, but it does allow us to think critically and have honest conversations about to what structures we do want and how we should manage power.

It’s worth recognizing that Freeman wrote this article because she did want feminist organizations to be more democratic (whereas I do not believe open source or unconferences need to be democratic), but this does not make her observations less salient. For example, Freeman’s article opens with an attack on the very notion of structurelessness:

“…to strive for a ‘structureless’ group is as useful and as deceptive, as to aim at an ‘objective’ news story, ‘value-free’ social science or a ‘free’ economy. A ‘laissez-faire’ group is about as realistic as a ‘laissez-faire’ society; the idea becomes a smokescreen for the strong or the lucky to establish unquestioned hegemony over others. This hegemony can easily be established because the idea of ‘structurelessness’ does not prevent the formation of informal structures, but only formal ones.”

This is an important recognition of fact, one that challenges the perspective held by many “open” advocates. In many respects, unconferences and some open source projects are reactions to the challenges and limitations of structure — a move away from top-heavy governance that limits creativity, stifles action and slows the flow of information. I have personally (and on many occasions) been frustrated by the effect that the structure of government bureaucracies can have on new ideas. I have seen how, despite a clear path for how to move an idea to action, the process nonetheless ends up snuffing the idea out before it can be acted upon — or deforms it to the point of uselessness.

But I have also experienced the inverse. I’ve personally experienced the struggle of trying to engage/penetrate an open source community. Who I should talk to, how to present my ideas, where to present them — all often have rules (of which, within Mozilla, I was usually informed by friends on the inside — while occasionally I discovered the rules awkwardly, after grossly violating them). Most open source communities I know of — such as Mozilla or Canada25 —  never claimed (thankfully) to be democratic, but there is an important lesson here. Recognizing the dangers of too much (or rather the wrong) structure is important. But that should not blind us to the other risk — the danger outlined above by Freeman for feminists in 1970: that in our zeal to avoid bad structure, we open advocates begin to pretend that there is no structure, or no need for structure. This is simply never the case. No matter what, a group structure exists, be it informally or formally. The question is rather how we can design a flexible structure that meets our needs and enables those whom we want to participate, to participate easily.

The danger is real. I’ve been to unconferences where there are those who have felt like insiders and others who have known they were outsiders. The same risk – I imagine – exists for open source projects. This isn’t a problem in and of itself – unless those who become insiders start to be  chosen not solely on account of their competence or contribution, but because of their similarities, shared interests, or affableness to the current set of insiders. Indeed, in this regard Freeman talks very intelligently about “elites”:

“Elites are not conspiracies. Seldom does a small group of people get together and try to take over a larger group for its own ends. Elites are nothing more and nothing less than a group of friends who also happen to participate in the same political activities. They would probably maintain their friendship whether or not they were involved in political activities; they would probably be involved in political activities whether or not they maintained their friendships. It is the coincidence of these two phenomena which creates elites in any groups and makes them so difficult to break.”

This is something I have witnessed both within an open source community and at an unconference. And this is not bad per se. One wants the organizers and contributors in open projects to align themselves with the values of the project. At the same time, however, it becomes easy for us to create proxies for shared values — for example, older people don’t get unconferences so we don’t ask them, or gloss over their offers  to help organize. Those who disagree with us becomes labelled trolls. Those who disagree sharply (and ineffectively) are labelled crazy, evil or stupid (or assumed to be suffering from asperger’s syndrom). The challenge here is twofold. First, we need to recognize that while we all strive to be meritocratic when engaging and involving people we are often predisposed to those who act, talk and think like us. For those interested in participation (or, for example, finding the next million mozillians) this is of real interest. If an open source community or an unconference does want to grow (and I’m not saying this should always be a goal), it will probably have to grow beyond its current contributor base. This likely means letting in people who are like those already participating.

The second challenge isn’t to make open source communities more democratic (as Freeman wished for the feminist movement) but to ensure that we recognize that there is power, we acknowledge which individuals hold it, and we make clear how they are held accountable and how that power is transitioned.  This can even be by dictate — but my sense is that whatever the structure, it needs to be widely understood by those involved so they can choose, at a minimum, to opt out (or fork) if they do not agree. As Freeman notes, acting like there is no power, no elite or no structure does not abolish power. “All it does is abdicate the right to demand that those who do exercise power and influence be responsible for it.”

In this regard a few thoughts about structure come to mind:

  1. Clarity around what creates power and influence. Too often participants may not know what allows one to have influence in an open setting. Be clear. If, in an open source community, code is king, state it. And then re-state it. If, in an unconference, having a baseline of knowledge on the conference subject is required, state it. Make it as clear as possible to participants what is valued and never pretend otherwise.
  2. Be clear on who holds what authority, why, and how they are accountable. Again, authority does not have to be derived democratically, but it should be as transparent as possible. “The bargain” about how a group is being governed should be as clear to new contributors and participants as possible so that they know what they are signing for. If that structure is not open to change except by an elite, be honest about it.
  3. Consider encoding ideas 1 and 2 into a social contract that makes “the bargain” completely clear. Knowing how to behave is itself not unimportant. One problem with the “code is king” slogan is that it says nothing about behaviour. By this metric a complete jerk who contributes great code (but possibly turns dozens if not hundreds of other coders off of the project) could become more valued then a less effective contributor who helps new coders become more effective contributors. Codifying and enforcing a minimum rule-set allows a common space to exist.
  4. Facilitate an exit. One of the great things about unconferences and open source is the ability to vote with one’s feet and/or fork. This means those who disagree with the elite (or just the group in general) can create an alternative structure or strike up a new conversation. But ensure that the possibility for this alternative actually exists. I’ve been to unconferences where there was not enough space to create a new conversation – and so dominating conveners tortured the participants with what interested them, not the group. And while many open source projects can be forked, practically doing so is sometimes difficult. But forking – either an open source project or a conference conversation – is an important safety valve on a project. It empowers participants by forcing elites to constantly ensure that community members (and not just the elites) are engaged or risk losing them. I suspect that it is often those who are most committed (a good thing) but feel they do not have another choice (a bad thing) who come to act like resentful trolls, disrupting the community’s work.

Again, to be clear, I’m using Freeman’s piece to highlight that even in “open” systems there are structures and power that needs to be managed. I’m not arguing for unconferences or open source communities to be democratic or given greater structure or governance. I believe in open, transparency and in lightest structures possible for a task. But I also believe that, as advocates of open, we must constantly be testing ourselves and our assumptions, as well as acknowledging and debating practises and ideas that can help us be more effective.

Open Source Journalism at the Guardian

crowd sourcedA few months ago I wrote a piece called the Death of Journalism which talked about how – even if they find a new revenue model – newspapers are in trouble because they are fundamentally opaque institutions. This built on a piece Taylor Owen wrote called Missing the Link about why newspapers don’t understand (or effectively use) the internet.

Today Nicolas T.  sent me this great link that puts some of the ideas found in both pieces into practice. Apparently, in the wake of the MP expense scandal in the United Kingdom, the Guardian has obtained 700,000 documents of MPs’ expenses to identify individual claims. Most MPs probably imagined they can hide their expenses in the sea of data, for what newspaper could devote the resources to searching through them all?

No newspaper could, if by “newspaper” you mean only its staff and not its community of readers. The Guardian, interestingly, has taken on this larger community definition and has crowd sourced the problem by asking its readers to download and read one or a few documents and report back any relevant information.

What makes this exciting is it is one example of how – by being transparent and leveraging the interest and wisdom of their readership – newspapers and media outlets can do better, more indepth, cheaper and more effective journalism. Think of it. First, what was once an impossible journalist endeavor is now possible. Second, a level of accountability previously unimaginable has been created. And third, a constituency of traditional (and possibly new) Guardian readers has been engaged – likely increasing their loyalty.

Indeed, in effect the Guardian has deputizing its readers to be micro-journalists. This is the best example to date of a traditional (or mainstream) media institution warming (or even embracing) at least a limited concept of “the citizen journalists.” I suspect that as institutions find ways to leverage readers and citizen journalists and that the lines between journalist and reader will increasingly blur. Actually it will have to.

Why is that?

Because for the Guardian model to work, they had to strike an agreement (a bargain – as Clay Shirky calls it) with their community. I don’t think anyone would have been satisfied to do this work and then simply hand it back to the Guardian without the right to access their work, or the work of other micro-journalists. Indeed, following the open source model, the guardian has posted the results for every document read and analyzed. This means that the “raw data” and analysis is available to anyone. Anyone of these micro-journalists can now, in turn, read the assemblage of document reviews and write their own story about the MPs expenses. Indeed, I’m willing to wager the some of the most interesting stories about these 700,000 pages will not be written by staff of The Guardian but by other parties assessing the raw data.

So what does that make the Guardian? Is it a repository, a community coordinator, an editorial service…? And what does it make those who write those stories who aren’t employed by the Guardian? Caring about, or getting caught up in these terms and definitions is interesting, but ultimately, it doesn’t matter. The fact is that journalism is being reinvented and this is one compelling model of why the new model can tackle problems the old one couldn’t even contemplate.

why collaborative skills matter in open source

For the past several years now I’ve been talking about how community management – broadly defined as enhancing a community’s collaborative skills, establishing and modeling behaviour/culture and embedding development tools and communications mediums with prompts that “nudge” us towards collaborative behaviour – is imperative to the success of open source communities. (For those interested in this, my FSOSS 2008 on the subject has been slidecasted here, and is on on google video here.

Re-reading Shirkly’s latest book, Here Comes Everybody, has re-affirmed my thinking. Indeed, it’s made me more aggressive. Why? Consider these two paragraphs:

This ability of the traditional management structure to simplify coordination helps answer one of the most famous questions in all of economics: If markets are such a good idea, why do we have organizations at all? Why can’t all exchanges of value happen in the market? This question originally was posed by Ronald Coase in 1937 in his famous paper “The Nature of the Firm,” wherein he also offered the first coherent explanation of the value of hierarchical organization. Coase realized that workers could simply contract with one another, selling their labor, and buying the labor of others in turn, in a market, without needing any managerial oversight. However, a completely open market for labor, reasoned Coase, would underperform labor in firms because of the transaction costs, and in particular the costs of discovering the options and making and enforcing agreements among the participating parties. The more people are involved in a given task, the more potential agreements need to be negotiated to do anything, and the greater the transaction costs…

And later, Shirky essentially describes the thesis of his book:

But what if transaction costs don’t fall moderately? What if they collapse. This scenario is harder to predict from Coase’s original work, at it used to be purely academic. Now’s it not, because it is happening, or rather it has already happened, and we’re starting to see the results.

My conclusion: the lower the transaction costs, the greater the playing field will favour self-organizations systems like open source communities and the less it will favour large proprietary producers.

This is why open source communities should (and do) work collectively to reduce transaction costs among their members. Enabling the further collapse of transaction costs tilts the landscape in our favour. Sometimes, this can be down in the way we architect the software. Indeed, this is why – in FirefoxAdd-Ons are so powerful. The Add-On functionality dramatically reduces transaction costs by creating a dependable and predictable platform, essentially allowing coders to work in isolation from one another (the difference between collaborative vs. cooperative). This strategy has been among the most successful. It is important and should be pursued, but it cannot help collapse transaction costs for all parts of a project – especially the base code.

But what more can be done? There are likely diminishing returns to re-architecting the software and in finding new, easier ways, to connect developers to one another. The areas I think offer real promise include:

  • fostering cultures within open source communities that reward collaborative (low transaction cost) behaviour,
  • promoting leaders who model collaborative (low transaction cost) behaviour
  • developing tools and communications mediums/methods that prompt participants to improve the noise to signal, minimize misunderstandings, limit unnecessary conflict, and help resolve differences quickly and effectively (the idea being that all of these outcomes lower transactions costs).

This is why I continue to think about how to port over the ideas, theories and tools from the negotiation/collaboration field, into the open source space.

For open source communities, eliminating transaction costs is a source of strategic advantage – one that we should find ways to exploit ruthlessly.

Improving the tools of open source

It is really important to recognize that free software and open source spring not just from a set of licenses but from a set of practices and often those practices are embodied in the tools that we use. We think through the tools that we use and if you give people different tools they think differently.

– Tim O’Reilly, O’Reilly Radar update, OSCON 2007 (min 9:16 of 22:03)

For those coming to the Free Software and Open Source Symposium at Seneca College, and for those who are not, I wanted to riff off of O’Reilly because he is speaking precisely to something that I hope Dan Mosedale and I are going to dive into during our discussion.

The key is that while the four freedoms and the licenses are important they are not the sum total of open source. Open source communities work because of the tools and practices we’ve developed. More importantly – as Tim points out – these tools shape our behaviour. Consequently, we should never treat the tools or practices in open source as assumptions, but rather things that my must be questioned and whose benefits and limitations must be understood. It is also why we must envision and innovate new tools.

This is why I blog and write on community management and collaboration in opens source. I am trying to imagine ways to port over the ideas developed at the Harvard Negotiation practice into the open source space. I see a set of practices and tools that I believe could further enable, grow and foster effective communities. I believe it is a small, but important piece, to enabling the next generation of open source communities.

I know Dan enjoyed the presentation from last year and has some of his own thinking on this subject – with luck some interesting new insights will emerge which I promise to blog about.

Obama and Web 2.0 in 1995

Salimah E. just forwarded me this fantastic piece – from the Chicago Reader – about Obama. Part of what makes it fascinating is that it was  written 13 years ago. Just read it and look how consistent Obama’s past and present is from a values and goals perspective. This piece could have been written yesterday. What a rock that guy is.

Also interesting to read the piece from a technology angle. Consider again that it was written a decade before Web 2.0. But look at how Obama’s language and values around community building fit so perfectly with the social media technologies of today. Reading this (again written in 1995!) it becomes obvious that Obama would immediately see the potential and opportunity around online, self-organizing, social media. It explains how and why his stie has done so well. He literally lives and believes in the values of self-organizing to a degree that few other politicians do and so is willing to hand big parts of his site over to its users. (in this case users, supporters, or followers all feel like inadequate words, sigh).

Money quote:

“What makes Obama different from other progressive politicians is that he doesn’t just want to create and support progressive programs; he wants to mobilize the people to create their own. He wants to stand politics on its head, empowering citizens by bringing together the churches and businesses and banks, scornful grandmothers and angry young.”

Obama, different than other progressive politicians? Hmmm, I’ll confess that this line also makes me like the piece because it resonated with Taylor and I’s piece on the death of progressive politics. (Shameless link, I know).

Wikipedia: Community Management as its core competency

Last week Paul Biondich lent me The Starfish and the Spider and I just finished reading it (I know, I didn’t put it in the sidebar). Indeed, a number of people I respect have had great things to say about it – John Lily suggested the book ages ago and I remember reading his review and wanting to pick a copy up.

Tons of exciting ideas in the book. One that excited me most related to an idea (articulated by many people) that I’ve been trying to advance – namely that Community Management is core to open source. Specifically there was this exciting piece on how Jimmy Wales, the “catalyst” behind Wikipedia, spends his time:

Jimmy focuses a great deal of attention on maintaining the health of the Wikipedia community. “I go to speaking engagements all over the world at conferences, and everywhere I go I meet Wikipedia volunteers,” he told us. “Usually we go off to dinner and talk shop about Wikipedia. The Wikipedia gossip is the same all over the world-just the characters are different. The problems that affect community are always the same problems.” When he doesn’t meet the members in person, Jimmy spends “a ton of time writing e-mails internally, to the community, touching base with people, discussing issues that come up on the mailing list.” But “as far as working with Wikipedia, I don’t write articles. Very, very little do I ever edit. But I do engage with people on policy matters and try to settle disputes. (page 112 – paperback edition)

It could be that in starfish organizations the role of managers and leaders isn’t to tell people what to do, but help settle disputes, grease the wheels and make sure that groups are working well. Is this to say other expertise are not needed? Not at all. But it is great to see another take on how soft skills such as dispute management, facilitation, negotiation and mediation may be essential for sustainable success of starfish organization (like open source communities).

Communities within Slideshare

So my presentation on Community Management as a Core Competency of Open Source recently passed the 7000 views mark. I admit that I find it somewhat incredible that one can create a lecture that gets viewed this many times. But still more interesting is seeing how the content and community around Slidecast has evolved.

Presently my presentation is the 74th most viewed slidecast on Slideshare – it just got run over by “What Teachers Make” which blew by it on its way up the charts (and rightly so, it really is quite good even if it doesn’t have sound). I am also pleased to note thought that my bit recently passed “Paris Hilton Photo Collector” and is moving in on the Beautiful Women of Japan and 50 Funny Cats.

I’ve been visiting slideshare a fair bit since I first posted to it 8 months ago. What has been interesting is that as it has gets more popular it seems that both the slidecasts get better (for example “What Teachers Make”), and that the more interesting slidecasts are polling better (note “What Teachers Make” meteoric rise). Indeed my own presenetation’s relative rise against cats and sexy women is further example of this trend. A year ago it seemed at least a fifth involved scantily clad women – but the days of those slideshows doing well appears to be in relative decline (they are still there, don’t get me wrong). It just appears that once  you are this deep in the long tail, lots of other content is more interesting to people.

All this is to say that yet again Andrew Keen should be roundly ignored, but then the very fact you are here probably means you were already ignoring him…

My first 911 call – lessons for open systems

So this Saturday morning, on my way downtown to conduct a negotiation workshop for several wonderful people in Vancouver’s environmental NGO community, my friend Rikia and I were stuck behind a white 16 cubic foot box van that began weaving very erratically (I mean, into oncoming traffic erratically).

After some initial hesitation I made my 911 call ever.

(As an aside, I think I’m a pretty lucky guy to have made it to the age of 31 before feeling like I was in a situation where I had to call 911 – and frankly while this situation was dangerous, I myself was never in danger)

During the call I was struck by how patient and restrained the operator was. Although he never sounded cavalier, nor did I pick up any sense of urgency – likely a tactic to ensure callers stay calm. In addition, I noticed how the operator never doubted the underlying veracity of my story.

This observation got me thinking about a post I wrote a while back about how 911 is a perfect example of how public services already use open source principles. Accepting this argument, my 911 experience actually affirmed some things  I’m sure many open source veterans already know.

Any open system (and many closed ones) rely on a community of people to provide it with important data (e.g. where eradic drivers are, or where critical bugs may exist in the code). Since people often come into the 911 community (or an open source project) with a problem or concern they are likely predisposed to be agitated. Consequently, I suspect that open systems that retain the most users are those that are predisposed to assuage them and keep them calm. Indeed this probably not only improves retention (increasing the likelihood a caller/bug register calls again) but likely also helps maintain the sanity of those helping them. So lesson one: a little patience is essential for long term success.

In addition, I mistook the road the truck was driving on not once but twice (talk about testing one’s patience!). However, if the operator was annoyed,  I didn’t know it. While it is important that 911 get accurate information a worse outcome would be for a call where the operator and the caller get into a dispute – if a user has a negative experience with 911 they may never call again – significantly diminishing the value of the system and increasing the risk to society. Obviously the stakes aren’t quite so high for an open source software project, but putting a premium on accuracy above all else probably isn’t wise either. While we want users to be accurate – a system that penalizes inaccuracy so heavily that they never return is probably not wise either. So lesson two – always lead by trusting, but of course, verify.