Testing Evolution – How to Tell if I’m Right

Theory and Reality

This is part of a series: testing evolution

I figured out how to test evolution, wrote an evolution simulator, and ran it. If my simulator is accurate, here are some things that should happen in living things.  I’d love to see how many of these have already been found.

EDIT: Here’s a link to my evolution simulator (project page)

If my simulator is correct, then here are three phenomena that should appear in living things:

  1. Evolution
  2. Irreducible Complexity
  3. Devolution Leading to Extinction


My self-copying programs reliably mutate into forms that are superior to the originals and reliably out-compete them.

How can this be tested?

  • Look for truly good mutations that have no bad side effects
    Note that in this case, a “good” mutation is one that makes a creature more likely to survive and reproduce than the non-mutants.  one example might be a mutation that makes someone significantly more intelligent in some area, without any side-effects like those that tend to come with autism or ADD.

Irreducible Complexity

I’m using the creationists’ term for this.  Richard Dawkins calls it “Mount Improbable“.  Here’s a list of resources claiming that many parts of living things are irreducibly complex, and defending that claim from those who say that they aren’t.

Irreducible complexity is the limit of evolution.  If it’s possible for a single mutation to turn you into superman, odds are that somewhere in the world, it’ll happen, and it’ll happen fairly quickly.  But what if the smallest change that would make you significantly better than everyone else takes 100 separate mutations before you get any benefit?  Now the odds are 1 in all possible combinations of 100 separate changes, or [all possible singe changes]100.

That’s unlikely enough that even if you have billions of years worth of mutations, it’ll probably never happen.  Whether the practical limit is at 1 in 1 000 000 000 000 000 000 000, or 1 in 1 000 000 000 000 000 000 000 000 000 000 000, there’s some point where if the next evolutionary “jump” takes too many changes at the same time, it simply won’t happen in the time that evolution has.  If even one-line, self-copying computer programs are irreducibly complex, then living things must be too.

One reason that I chose computer programs for testing evolution is that they can be very simple.  By any sane measure of complexity, a 100-byte self-copying program is far simpler than the fully automated, self-copying factory that is a living cell.  Therefore, I expect that a noticeable amount of evolution should happen far faster in self-copying programs than to living things.

Why?  For starters, if evolution really caused all life to appear from one or a few common ancestors, then it should happen fast enough for scientists to see it happen.  If evolutionists are right, and evolution created the human genome in ~4 billion years – a massive 3 billion nucleotide, 700 MB firmware file – then evolution has to happen at an average speed of nearly 1 nucleotide taking over the population per year.

In humans, assuming 20 years per generation, this means that one should expect 15-20 good mutations to become fixed in the human population each generation.  This is enough to generate a very small protein, or make a major change to an existing protein, or make noticeable changes to several proteins.  Note that for most of human history, the human population was a small fraction of what it is today.  Thus, one would expect that there are several times more good mutations than this in the human population, although they probably haven’t had time to spread around the world.

In bacteria, this should happen much faster due to their short generation time and huge populations, so it should be easy to detect.  If even bacteria – some of which can have generation times of 12 minutes – evolve fast enough for it to be easy to detect, then surely self-copying programs, which have generation times measured in milliseconds, should evolve far faster.  Thus, if evolution – including macro-evolution – doesn’t happen fast enough to be easily detected even in self-copying programs, that’s strong evidence that it doesn’t happen at all.  If it happens too slow to be detectable, or if it does happen fast enough to be detectable, but not nearly fast enough to generate a 3 billion nucleotide genome in ~4 billion years, then evolution can’t possibly have created life on earth, even if it turns out that one or a few species can appear naturally without God to become the ancestors of the rest.

In addition to the short generation times, the more complex a system gets, the more likely that any change will mess up another part of itself.

Conversely, the simpler a system is, the less likely it is that a change will mess up another part of itself.  There are, of course, exceptions, but the principle is still generally true.  Thus, if evolution created the designs of all proteins on the planet, it should effortlessly add entirely new, immediately useful commands to my programs, and it should do so fast enough for me to see it happening.  These good mutations should build on each other until I have a creature that’s completely different from what I originally wrote, both in form and in function. It should also be vastly superior to the originals at surviving in my simulator.

But even in something as simple as a one-line, self-copying computer program, I found that evolution is very limited. Instead of creating entirely new commands, all good mutations fall into a few categories of small modifications.  The basic form of the creatures doesn’t change, and the only change of function that I’ve seen is one broken command.  The broken command occasionally creates new global variables, but this doesn’t help the creature that created them.  I have not yet run into a single mutation that adds a new immediately useful command, although I won’t rule out the possibility that one might eventually appear.

Additionally, in both living things and self-copying programs, evolution runs into diminishing returns.  For example, one of these types of mutations gives a creature’s kids extra food.  One extra food makes a big difference.  Two do, too.  But if all creatures already have 1000, adding one more won’t make nearly as big of a difference as they would’ve if all creatures had the original amount.  Eventually, such mutations become insignificant.

How can this be tested?

  • If a one-line self-copying program is irreducibly complex, we humans should be too
    Any evolution in humans should be very limited, and will not be able to build on previous good mutations enough to evolve primates into humans.  We will not evolve into supermen, period.
  • The surest sign of irreducible complexity is that evolution slows to pretty much nothing
    This may be hard to detect, because evolution is supposed to happen slowly.  You might have to watch for many human generations before you can see that evolution really is slowing down, even if the humans are watching for it in bacteria.
    Why does this symptom happen?  As the “low-hanging fruit” of small good mutations gets used up, the only possible mutations left are far less likely, and thus happen far less often.  Eventually, the smallest change that would improve a creature enough for natural selection to act on it, is so unlikely that it’s almost guaranteed to never happen.  At this point, evolution is insignificant compared to other factors affecting a creature’s survival, like whether this winter is extra cold.
  • Good mutations that build on other good mutations should be far rarer than standalone good mutations The longer the chain of major improvements, the less likely it is to lengthen. Therefore…
  • I do not expect that a typically sized protein will appear by evolution, even on evolutionary time scales
    A typical protein is 300-400 amino acids long.  Since each amino acid is coded for by 3 nucleotides, that means a typical protein is 900-1200 nucleotides long when stored in the genome.  Those 900-1200 nucleotides are what evolution has to work with.  As of 2010, the smallest known protein was 20 amino acids long, which means that 60 nucleotides encode it.  In my simulator, evolution struggles even with chaining two good mutations together.  If evolution really created proteins, it should have created completely new commands in my self-copying programs that greatly helped them to survive.
    Note: by “protein size”, I mean gene length in nucleotides stored in DNA, not the physical space taken by the actual protein when produced.


The biggest surprise I got when I first ran my simulator was that my programs devolved to extinction.  A few years later, a friend of my dad’s gave me a copy of Genetic Entropy and the Mystery of the Genome, in which creation scientist and genetics professor John C. Sanford said that this same process is happening right now to all living things.  He calls it genetic entropy.  When evolutionary biologists find it in creatures that reproduce asexually, they call it Muller’s Ratchet.  I don’t know if they have a name for it in creatures that reproduce sexually.

What is devolution? In short, it’s the opposite of evolution.  Bad mutations build up in the gene pool over many generations, so that the mutants are not better than the originals, but worse.  Even though the worst mutations kill or effectively sterilize their hosts, many of them do not. Some of these near-neutral, but “slightly” bad mutations cause:

  • Sickle-cell malaria
    This one is interesting.  It’s good in the short term, but bad in the long term.  In the short term, it helps protect its host from malaria. But in the long term, it tends to kill.  How? It severely deforms red blood cells so they can’t carry enough oxygen.  But if you only have one copy of the mutant gene, and one non-mutant copy, the deformation is not as bad as with two copies, but it’s still significant enough that the malaria parasite has a far harder time surviving than the mutant.
  • Gluten intolerance
  • The genetic part of near/farsightedness

How can this be tested?

  • There should be a lot of near-neutral, but slightly bad mutations in living things
    In addition, I’m pretty sure that every living thing has some of them already.  Evolutionary biologists see devolution happen in creatures that reproduce by cloning (asexually).  They also see it in populations that are small – possibly too small to survive in the long term.  They’re sure, though, that it doesn’t happen in large populations of sexually reproducing creatures like humans.  They’re so confident that as far as I know, they haven’t even looked.
    If they do look, I think they’ll be surprised.
    Evolutionary biologists think that the reason near-neutral, but slightly bad mutations exist is that they “piggyback” on good mutations in the rest of the genome.  If this is true, then sexual reproduction will either greatly reduce the problem of devolution, or eliminate it completely.  It shuffles genes so that eventually, someone will be born who has the good mutation, but not the bad one.
    I think they’re wrong.  I think that what causes devolution is the fact that natural selection is a blunt instrument.
    If, for example, I can’t shiver, that won’t keep me from spreading my genes as long as I live in a warm environment or have plenty of warm clothes.  Natural selection probably won’t eliminate me or my mutant genes.  Thus, devolution should happen in all living things, regardless of whether they shuffle their genes.
    CORRECTION: According to creation scientist John Baumgardner, one of the main distinguishing features of Muller’s Ratchet is that the only way to reverse it is with a back-mutation.  Thus, Muller’s Ratchet is defined so that it technically doesn’t happen in creatures that reproduce sexually, except in parts of a sexually reproducing organism’s genome that don’t recombine.  I had thought that Muller’s Ratchet was simply devolution, and that evolutionary biologists simply turned a blind eye to it in any creature that had sex.
  • This type of mutation should build up in the genomes of living things irreversibly
    Technically, back-mutations are possible.  The reason I say that they’re “irreversible” is that back-mutations are far rarer than near-neutral, but slightly bad ones.  Thus, in real life, mutation and natural selection will not reverse the overall trend of devolution.
  • This type of mutation should be common enough to eventually drive any species that has them extinct
    If my simulator is accurate, devolution will either not slow down at all, or will not slow fast enough to avoid extinction.
    I expect that some evolutionists will argue that even if devolution happens consistently, it has a lower limit.  Eventually, a species will deteriorate to such a point that even a near-neutral, but slightly bad mutation will kill or sterilize, and thus any further devolution will stop itself.
    I disagree. I think that living things have so many moving parts that their genomes can effectively “rust out” all the way to extinction. Thus I predict that nobody will be able to demonstrate that this lower limit of devolution exists in living things.

Photo credits:

4 thoughts on “Testing Evolution – How to Tell if I’m Right

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 )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.