Testing Evolution – The Results

This is part of a series: Testing Evolution

I figured out how to test evolution, and I wrote an evolution simulator.  Here are the exact results I get when I run it, and some examples of the same phenomena from biology:

  1. Original Creature
    Muller's Foundry Screenshot - Original Creature
    I started with a simple creature that gives itself 1 food, and copies itself.
  2. Evolution Starts
    Muller's Foundry Screenshot - After 1000 Generations
    After a little while (1000 generations, +- a large range), the first signs of evolution appear.  Some mutant creatures cheat and give their kids more than 1 food.  This doesn’t give as big of an advantage as one might expect, since most creatures won’t get a chance to reproduce a second time (they get crowded out by the next generation).  But it’s significant enough that these mutants eventually out-complete the originals.
  3. Near-Neutral Mutations/Fitness Tradeoffs/Junk Code
    Muller's Foundry Screenshot - Tradeoff Mutation After 1000 Generations
    By this time, another biological phenomenon appears: fitness tradeoffs.  Note that in #2’s screenshot, the first code statement is garbled.  It no longer does its original job, but it does absorb mutations.  This probably doesn’t have a good effect overall at first, since it also has a significant bad effect.  But these eventually lengthen into monstrous mutation sponges that give a significant advantage over the original.  My first guess is that this doesn’t happen because it gives an immediate fitness advantage.  Instead, mutations that add a random letter are probably just less likely to cause errors than mutations that delete a random letter.  Due to a subtle difference between the way my simulator does mutations, and how they happen in biology, I expect that such mutation sinks will be less beneficial in actual living things.  I don’t think that will prevent them from appearing.  Also, it seems that what was originally called “junk code” in living things isn’t nearly as worthless as evolutionary biologists expectedDivine Creation predicts that there will be no truly function-less code in the original creatures.
  4. Evolution Slows to a Crawl
    Muller's Foundry Screenshot - Evolution Slows to a Crawl
    This is a consequence of Michael Behe’s Irreducible Complexity (AKA Richard Dawkins’ Mount Improbable).  Irreducible complexity is the level of complexity at which it’s impossible to jump to the next significant improvement with only a few mutations that happen all at once.  It’s the limit of evolution.  The main symptom of irreducible complexity is that as the “low-hanging fruit” of small, good mutations get used up, evolution slows to almost nothing.  All other possible changes are so unlikely that you can be pretty sure that they’ll never happen, even if you have billions of years.  In this case, I found that the 2 main good mutations were:
    – Giving the kids more food
    – Turning the first command into a mutation sink (not sure if this counts as “good” enough to make those who have it take over)
    Once those get used up, it seems that the next smallest change that causes a significant good effect – whatever it may be – is improbable enough that I can be pretty sure it’ll never happen.
    EDIT: It turns out that although evolutionary biologists don’t talk much about evolution’s limit, they do talk and write some about how to get around that limit.  Their name for the hypothetical form of evolution that’s able to create all life from a common ancestor is open-ended evolution.  One organization – the Astrobiology Research Trust – has a $100,000 prize for anyone who can demonstrate an “artificial life” (probably self-copying or life-like digital systems) that evolves without any practical limit.  As far as I know, nobody has yet claimed the prize.
  5. Devolution
    If a creature has lots of food and then becomes sterile, weird things happen
    EDIT: Due to browser glitches, I had to re-run my simulator to get this far.  This screenshot is what I found the first time I ran it for this post.  What probably happened was that each creature became sterile, but at least 1 of them had a huge amount of food.  Without reproduction – at least in my creatures – there was no natural selection, and every creature’s code became very random.
    They don’t teach you about this in grade school, but they should.  It’s the main thing that happens in the long term.  Near-neutral, but slightly bad mutations build up in the gene pool.  Each one isn’t bad enough to eliminate itself, so natural selection doesn’t get rid of them.  They’re far more common than good mutations, so the overall trend is “down, not up“.  In my creatures, evolution and devolution are rather “jumpy”, in the sense that they aren’t a gradual process, but happen suddenly.  I expect that the bigger and more complex the genome, the smoother each will go.
    Why?  In 1-line programs, a mutation that changes 1 letter may change 1% or more of the entire genome.  In a 1 000 000 000-line program, a mutation that changes 1 letter changes a far smaller proportion of the code.  Such small changes can still have huge effects, but they also can have no noticeable effect.
    Evolutionary biologists have known about this devolution for several decades.  They run into it in living things.  When they find it in creatures that reproduce asexually, they call it Muller’s Ratchet, after the guy who discovered it.  Here’s an example of devolution in a virus, and here’s an example of devolution in a microbe.  I got both from a quick search of google scholar for “muller’s ratchet”.  I’m not sure if evolutionary biologists have a name for devolution in creatures that reproduce sexually.
    For anyone who decides to read up on Muller’s Ratchet, pay attention to whether the papers you’re reading are talking about simulations or experiments on actual living things.  In living things, it appears to happen consistently.  In evolutionary biologists’ simulations, it sometimes does, and sometimes doesn’t, depending on the exact way that the simulation was written.
    Here are a couple of examples of near-neutral (from an evolutionary standpoint) but slightly bad mutations in humans:

  6. Foolish Mutations/Temporarily Beneficial Mutations/Short-Sighted MutationsMuller's Foundry screenshot - after foolish mutation
    Muller's Foundry Screenshot - Before Foolish MutationEDIT: These screenshots are from a third run.  I may have been lucky enough to catch it at the point when these foolish mutants had almost completely taken over.  It’s also possible that the creature that wasn’t dependent on an external variable had a back-mutation.
    I don’t know if any of these are the correct terms, but what finally caused a mutational meltdown was a mutation that was good in the short term, but bad in the long term.  It gave its host much more food, but made it dependent on an external variable.  When it took over the population, every creature depended on that single variable.  It was only matter of time before one of them got a mutation that set that variable to a negative number or a non-number, which made every creature’s children stillborn.
    Here’s an example of a short-sighted mutation in humans:

  7. (Rarely) Partial Resistance to Devolution
    Regex Stasis
    I only ran into this after running my simulator many times.
    Once in awhile, two mutations will happen that wrap much of a creature’s source code in something that keeps that chunk from being run as code, thus effectively deactivating much of the creature.  In this case, the first command has largely turned into a regular expression, which is used for searching for patterns in text.  I have also run into creatures that developed quote stasis, in which much or all of the first command turns into a quoted string of text suitable for running code to do something to.  This does not seem to stop devolution or extinction, but I still think it’s noteworthy.  These “stasis”-causing mutations have the following effects:

    • Devolution slows to a crawl
      In my simulator, devolution and extinction are largely caused by the buildup of random variables.  When the first command in one of my creature breaks, it creates a torrent of random variables.  These encapsulating mutations prevent the code that they surround from creating those variables.
    • Evolution appears to slow down by a similar amount
    • The creatures get far bigger than they otherwise could
    • The species survives for many times as many generations as it would without code stasis
    • Sometimes, though not always, the stasis will disappear on its own.  It appears that this becomes harder the longer that creatures remain in stasis.
    • The parts of a creature that are no longer running don’t appear to cause good mutations either
    • The simulator tends to crash
      I seem to run into a disproportionate number of web browser crashes when creatures develop stasis.  I’m guessing that this is due to bugs in the browsers that the simulator is running in.  Specifically, my guess is that the spontaneous crashes are due to the browsers reaching a limit to how many variables they can remember, and crashing when the simulator tries to set aside more.  I don’t think that web browsers are designed to store so many variables that their names alone may fill gigabytes.
  8. Mutational Meltdown
    Muller's Foundry screenshot - the final result
    EDIT: Due to browser glitches, I had to re-run my simulator to get this far
    If I run my simulator for long enough, this always happens.  It happens so consistently that I haven’t yet bothered to finish a “run for X generations” feature.  I did find early on, though, that I needed a way to tell when every creature had died out.  I originally planned to show a screenshot of the simulator after the population went extinct, but Internet Explorer glitched.  That’s one disadvantage of testing evolution by mutating actual computer code.  Browser developers could probably use my program as a fuzz tester to find bugs in their JavaScript engines.  I’ll probably run it again sometime soon and post a screenshot then.
    EDIT 2: This is from a run I did awhile later
    Alternate way for self-copying programs to go extinct
    Here’s another way that mutational meltdown can happen.  Instead of the copy command breaking, the first command broke.  As far as I can tell, the creatures all by chance became dependent on a single variable, but not because that variable had their food.  Instead, they all needed the variable to stay the same lest the first command have an error.  Then a mutant changed that variable, and all subsequent creatures couldn’t copy themselves, because the copy command never got a chance to run.

Photo credits:


10 thoughts on “Testing Evolution – The Results

What do you think?

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s