Outer Web Thought Log

en+nl feeds: atom | rss1 | rss2
en feeds: atom | rss1 | rss2
nl feeds: atom | rss1 | rss2
archives: by month | by title | by language
« Visitors from Paderborn | Main | More ASF graphs »

When making the suggestion yesterday that the distribution of ASF members across (top-level) projects is somewhat askew, I knew I had to go in and check my assumptions or I'd be making a fool of myself. Furthermore, Stefano just posted a personal and well-written account on the value of ASF membership, with an interesting endnote:

I personally believe in keeping the bar low for committership and
keeping the bar high for membership.

I believe that this helps us getting more people inside the foundation
(potential members) but keeps the real powers of the foundation heavily
filtered and therefore highly focused on what it means to be a member.

As much as I understand his rationale, I was curious to see how this reflects upon the actual representation of each top-level project in the Foundation. Armed with a pinch of Python and the CVS permission configuration file, I tabulated some data which reflect the technical distribution of ASF members per top-level projects, i.e. the projects a given ASF member has commit access to. Relating that to the amount of normal committers who have access to a given project produces the following chart:

Which means that i.e. for the httpd project, 63% of the possible project participants are ASF members. Things to note: technicaly, James was still considered to be a Jakarta project (repository-wise) at the time I run my little script, instead of a proper top-level project. PHP also doesn't appear on this chart, since they operate their own infrastructure. What you can't see from the previous chart is the lack of relationship between community size and membership, so here's one which reflects this:

This puts the amount of people with technical commit access (members included) to one (or more) module(s) of a top-level project in perspective against the percentage from the chart above. Now, things are more interesting. Relate Jakarta and XML with the TCL project.  Or APR and Cocoon. Of course, the oldest project (httpd) quite logicaly has a large amount of members.

This last one basically shows what projects members are working in. Out of 111 members (at the time of running my script), more than half of them have somehow commit rights to a CVS module related to the httpd project. 25% of the members is interested in the XML project, etc...
Caveat: the assumption that commit access reflects actual involvement in a project is definitely wrong. I.e. of the 14 ASF members that have commit access to the Cocoon project repository, only 7 or 8 can be considered active participants. Factoring in that change would change the graphs dramatically, but would be hardly scientifical. Also, the large amount of Avalon committers is caused by 60 Cocoon committers that have access to a certain Avalon CVS module. In reality, there's only some 30'ish 'real' Avalon committers, and some of them also are Cocoon committers.
Caveat: statistics are a means to prove anything. So please take all this as a grain of salt:

• my Python skills are quite exotic, so be prepared for some massive calculation bugs (I checked, though)
  
• the dataset I started from can probably contain errors or misreflections of reality
  
• commit access doesn't mean one is actually involved
• a project's success depends on much more than the above stats, if it depends at all

Comments and reactions are much welcomed.