The recent thread of documentation sparkled by Diana reminded me of the
secret of open development dynamics and some discussions I had with
James Duncan Davidson about what he named 'software darwinism'.
DISCLAIMER: I really hope not to hurt anybody's feelings here. For us
europeans it's very strange to know that there are individuals who don't
believe in the theory of biological evolution. Everybody (even religious
people) take it for granted. But I've lived in the US and know that this
sometimes touches religious nerves. So my apologies if this is so.
The abstraction of the darwinistic theory of biological evolution can be
referred to as 'progressive refinment through environment-selected
stocastical changes'.
This process is used by the entire planet ecosystem to maintain its
biological ecosystem stable.
The parallel with open development is striking:
1) code as DNA
2) patches as DNA changes
3) software copies as individuals
4) releases as species
5) users as environment
there is only one thing that doesn't fit because it doesn't exist in the
biological model: developers. (unless the biological model is increased
to include god-like entities, but I wouldn't go that far, since the
beauty of the model is that it doesn't require this. As Laplace used to
say: god is not a necessary hypothesis anymore).
So, the role of developers is the hardest to fit in this model because
given enough time and enough random changes, evolution is stable and, on
large scale, appears to be so smart that it triggers the feeling that
there must be a 'creator' someplace with a clear design plan.
Again, don't want to hurt anyone's feelings on this, but this is, IMO, a
very antropocentric approach: the fact that the human retina is most
sensible to the light frequency that our sun emits with more power, it's
not a matter of coincidence or divine design, but the result of million
billions adjustements.
Can you say 'a-patchy process'?
Back on our parallel: the developers play the role of genetic mutations,
only that instead of behaving randomly, they behave with a smarter and
more focused approach. This cuts by order of magnitudes the time
required for software to be developped. And the release early, release
often approach reduces the birth/death of species (releases) and the
more rapid this cycle is, the faster is the 'adattability' of the
software to its environment.
What can we learn from this?
A few important facts:
1) the evolutionary nature of open development is intrinsic, it cannot
be changed without severely altering the equilibrium of the social
system.
2) evolution is an incremental process: one small step is *always*
better than no step at all, even if this step appears incomplete and
meaningless. The non-linear community effects cannot be forecasted
before the event happens (see the butterly effect for non-linear weather
forecasts)
3) many small steps are better than one big step, even if they achieve
the same result. Why? because environmental feedback enters the loop on
every step, so instead of many small feedbacks, you get one big feedback
but adaptability is decreased (look at eXtreme Programming for more
information on this even for closed development environments)
4) even design can be made public and incremental: with the right amount
of abstraction, paper design can lead to discovery of problems even
before the system is built. The value of early and rapid feedback from
the environment (users) is vital to feedback the system and stabilize
it.
So, at the end, it's useless to resist to this intrinsic incremental
process: you will be assimilated anyway :)
--
Stefano Mazzocchi One must still have chaos in oneself to be
able to give birth to a dancing star.
<[EMAIL PROTECTED]> Friedrich Nietzsche
--------------------------------------------------------------------
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, email: [EMAIL PROTECTED]
