Re: [gentoo-dev] Bugzilla usage for overlays' projects [was: sunrise, a temporary compromise]

[George Shapovalov]

This was originally supposed to go into another thread, but hey - this is a 
perfect illustration of what I am going to talk about (to unconfuse Seemant 
right away - this is not related to your posting but rather to the situation 
that lead to it). I really was considering sending this as a "theoretical 
musings" email (pointed at spyderous primarily? he seems to enjoy my rare 
postings like these :)), but well, looks like I'll have to be somewhat 
serious for a change.

Executive summary:
There is a (by now) well established knowledge on group dynamics depending on 
its size, involving parameters such as "Dubnar's number" for example. Two 
references I spotted just recently (well, Ok, they are from 2004 actually :)) 
can be found below:
http://www.lifewithalacrity.com/2004/03/the_dunbar_numb.html
http://globalguerrillas.typepad.com/globalguerrillas/2004/03/what_is_the_opt.html

(and here is a more scientific writing, a "base article" for which the above 
two are kind of illustratory/anecdotal evidence types:
http://www.bbsonline.org/documents/a/00/00/05/65/bbs00000565-00/bbs.dunbar.html
)

The first two are kind of extreme in their coverage - one talks about MMORG 
guilds and another about terrorist cells, but hey, who said we are that 
different ;)? Both talk about social structure/critical sizes of the groups 
at small and medium scale. Social networks brought together towards 
implementing some common goal, so I say observations similar to those should 
apply to us too. 

It looks like we are now at that tipping point. 
herdstat tells me we are some 233 developers atm, which sounds damn close to 
that "magical" number of 150 active group participants (in our case that 
would correspond to reasonably active "regular" devs, i.e. the ones who do 
general maintaince, participate in discussions (by at least trying to read 
them) and at least sometimes emerge from that one small project they are 
in..). 

The suggestion "maybe this whole screaming is a something inherent to the 
group size" has been voiced recently a few times. So yes, to me this indeed 
seems very likely to be the case. Ironically, the later push to "cleanse" 
inactive devs, coupled with successfull recruitment may have been the thing 
that pushed us over (remember, "dead souls" don't count)..

So, what is the pont I am trying to make? Well, basically I just want to say 
that the problem is real and won't go away by periodically screaming "be nice 
to each other", since it seems to be inherent to a group size. We cannot just 
reduce our numbers - it does not work this way. If anything, we need *more* 
people, not less :). However at this point we cannot grow either. The main 
idea of the original (3rd cited) paper is that this is a real limit, imposed 
by the amount of "housekeeping interactions" that are needed to sustain a 
group of that size, "it is the way we are" as species. As you push more 
people in, more start leaving  and for a group to grow past that limit it has 
to restructure, assume a more diffuse interaction/more role division perhaps? 
(Similarly, just putting "some *one* at the top won't work either without 
restructuring the group. In fact it seems to work worse for the groups that 
are over the "small group limit"). So, yes, we have to adress it, and lets 
try to do it right. However lets not take this lightly, I sense a lot of 
fights involved :), but I am optimistic of eventual outcome..
(But don't ask me for a grand plan - I don't have one, I hope evolution forces 
will help us sort things out :)).

George 

PS.
A short short summary of critical group sizes. I really need to refresh my 
memory on that stuff though..

"Small groups" - 5 to 9, optimal - 7,8 People concentrate on one common 
problem and interact very closely.

"Medium groups" - 25 to 150, optimal 80-90 (but when there is a clear bias to 
add people (shiny idea/something valuable/commonly recognized as necessary) 
it is stable at a maximum of ~150). Often involves tight "small subgroups", 
normally specialized, general interaction is "loose" but still on a personal 
level (even if not very intensive)

"Large groups" - I only remember the upper limit of ~2000 for those and I am 
rusty on what is the "failing factor". Seems like a Debian situation to me 
(with most everybody else, us included, stuck at a "medium group" level).


Commertial entities often overcome these issues of scale by imposing 
a "chain-of-command" structure, effectively splitting into smaller subgroups 
and having a hierarchial structure made of those. However this arrangement is 
explicitly deemed unsuitable by many developers (according to voiced opinions 
in the past).
I suppose we can think about some loose arrangement of small and medium 
groups, may be even some minor modifications to our project structure can 
help (make Top level projects = medium group, subproject = small group). This 
one is apparent of course, but, as usual, the devil is in the details (people 
doing work in different areas and, most importantly, how to contain the 
interaction without prohibiting it..).

PPS
Sorry, this came out longer than I though, but I believe we need to have at 
least a clear understanding of the problem. If this brings a smile on 
somebodie's face, I say I am even :). If somebody takes this seriously, - so 
much the better..
-- 
gentoo-dev@g.o mailing list