Hi,
Jason Thomas wrote:
> Marc,
>
> I had a few ideas about how to make JBoss more self managing and make
> it easier for more people to help.
Self management is important.
> I think one of the problems the
> 95% of unutilized people have is that even a small ?task? is very
> difficult to accomplish in the context of a large system. Also
> before the 95% gets frustrated and gives up, they take up your time.
Yes, and that time is wasted. Completely.
And frustrated people are generally not nice.
> I think that these both of these problems could be solved by creating
> a simple interactive system to allow people to exchange source code
> and specifications.
IMHO we already have such a system. But it isn't
formalized, and new people unexperienced in OSS
do no know it.
> Here?s how it might work...
>
> Developers would be divided into two groups: designers (experienced
> Jboss developers that have RW CVS access) and programmers (everyone
> else).
Informally, we already have this division.
If it should be formal, who should do the
division? More work for the board?
> When a designer needed to accomplish a task they would break
> it down into detailed specifications (descriptions, test cases, uml
> diagrams) for methods or classes and enter them into the system along
> with ?deadlines?.
This is the old non-OSS mode of development.
In JBoss and other OSS projects, the designer
generally implements his design himself. That
way, no time is spent writing formal docs of
use to the implementor only. And the
implementation also works as a proof-of-concept
telling that the design is valid.
> Then they would work on something else or take a
> break and wait for programmers to write the code.
In the time they spent writing detailed formal
specifications, they could probably have
implementing everything.
> When a programmer
> wanted to help out they would go into the system, look at the
> outstanding micro-tasks, write the code for it, and submit it to the
> system.
To avoid duplicate work, the micro-tasks would
have to be assigned.
> The designer would then come back around the ?deadline?,
> grab any code that the programmers wrote, integrate it into JBoss,
> and write any unfinished code themselves.
And ask programmers for any microtasks assigned,
but not finished. And if no programmers wrote
anything, the designer would have to write
everything himself anyway. And in case of bugs,
the designer has to debug another person's code,
which is harder than debugging your own.
> Designers could also assign ?points? to micro-tasks to entice
> programmers to help. Programmers could put on there resume ?Received
> 18574 JBoss programmer points?. The system could even automatically
> promote a programmer (i.e. send them a CVS password) to a designer
> when they reached so many points.
Sorry, but I find this a bit silly.
OSS programmers do not program to earn points,
or to earn a CVS password.
There are two reasons an OSS programmer would
start working on something. For the work to
be done and contributed back to the project,
both reasons are present:
1) The programmer has the opinion that some
change or new development has to be done.
It is sometimes referred to as "the itch".
This ensures that the person doing a change
has a personal interest that the change is
done.
2) The programmer wants to earn the respect of
his fellow programmers. OSS development is
to a large extent a meritocracy, meaning
that the more work you have contributed,
the more weight your words have when
discussing future development.
Sometimes, if this reason is not present,
the work is contributed back to the project
anyway so that the programmer does not have
to incorporate his changes into every new
version.
> I don?t think this methodology is too radical - it?s basically using
> standard methodologies in a collaborative environment.
Yes, but these methodologies have not proven
sucessful in OSS development.
> It would make
> it easy for anyone to contribute code, even if they only had a
> limited amount of spare time.
It would also create a formal hierarchy, with
all the problems of that.
> It would also allow anyone to
> contribute without taking up any of your time.
Writing detailed formal implementation
specifications put a large burden on the
designer.
> Does anyone think
> this could work?
I don't think so.
Some resaons why I don't think this would work
are given above. For some more in-depth
analysis and background, check out:
http://www.opensource.org/for-hackers.html
Best Regards,
Ole Husgaard.
