cocoon-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "Andrew C. Oliver" <>
Subject Re: [RT] evolutionary development processes
Date Mon, 06 May 2002 00:24:53 GMT
That reminds me of...

I keep meaning to get around to an experiment I dreamed up.  I'm sure
someone has thought of it before but they probably didn't think of it in
the shower so mine is better. ;-)

A few bytes of code that constantly take in a number of random factors
replicate and modify their replication.  They apply a basic unit test
consisting of "can this replicate and execute", if it can then they let
their "child" live and eventually replace themselves with it (aka
"die").  The system employs a rule that those who replicate successfuly
most frequently get more resources, and those who don't get less.  Those
"strands" that don't (which I've not worked out how to identify) would
be eventually removed once they had insufficient resources to ever get
on a CPU (which there might be many)..  

The test would stop when:

1. Some of the code achieved concsiousness 
2. Something really really cool happened
3. The machine crashed
4. I got bored with it and needed the computer for something else.

I think I could almost do this in java with BCEL.  I'd have to work out
the framework these suckers would run in but it sounds like a blast...

XSP could make this readable even.....

but then again, I really am a crazy person... what do I know? ;-)


On Sun, 2002-05-05 at 10:36, Stefano Mazzocchi wrote:
> 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.
> <>                             Friedrich Nietzsche
> --------------------------------------------------------------------
> ---------------------------------------------------------------------
> To unsubscribe, e-mail:
> For additional commands, email:
-- - software solutions for business - Excel/Word/OLE 2 Compound Document in
Java                    - the best build/project
		    a guy/gal could have! - Make Ant simple on complex Projects!
The avalanche has already started. It is too late for the pebbles to
-Ambassador Kosh

To unsubscribe, e-mail:
For additional commands, email:

View raw message