Saturday, June 12, 2010


In his biography, Craig Venter says he wants "to take us far from shore into unknown waters, to a new phase of evolution, to the day when one DNA-based species can sit down at a computer to design another. I plan to show that we understand the software of life by creating true artificial life."

But one problem with going into "unknown waters, to a new phase of evolution, to the day when one DNA-based species can sit down at a computer to design another" is that there's no fault tolerance in the system.

What happens if Venter or someone else on his team accidentally wipes us all out while taking us out into the deep toward his "new phase of evolution" - say he accidentally creates a zombie virus?


That's why I think we need to take some precautionary measures.

First, let's make a backup copy of our species. We need to implement a redundant array of independent disks for humanity. We might begin with RAID 1 and step it up from there. Let's mirror the critical data on at least two separate physical drives. If one crashes, then the other will immediately take over.

At the same time we ought to begin sending expeditionary teams to the next most Earth-like planet in our solar system, Mars. This will be the first step toward colonization and, in turn, eventual terraforming of the Red Planet to make it hospitable for humans.

This way, we can reboot with Humanity 2.0 on a terraformed Martian landscape should the first one crash.

Later we can expand to RAID 2 and beyond as we deem necessary. And terraform additional planets in the process.

Of course, we might not need the backup copy or copies. But they'd be good to have. You never know if we'll need it. And we can always delete it.

Again, I'm just saying this should provide a significant level of fault tolerance.

What's more, we could go beyond all this.

For example, we can modify our backup copies too. Or we can use our backup copies to modify current Humanity 1.0.

Say we let our backup copy or copies of Humanity run at the same time as our original program. Say we bring both programs online. We can make them go live simultaneously. Thus we'll have two (or more) running copies of Humanity. Say Humanity 1.0 runs concurrently with Humanity 2.0, 2.4, 2.7, 3.0, 4.0, and so forth.

Perhaps we could then introduce modifications into one or the other to see what'd happen. We could take the various versions of Humanity on different developmental tracks.

If we find we don't like a certain development in one of the real-time running versions of Humanity, or even in our own original Humanity 1.0 program, we can stop it in order to modify it. We can copy the code in, say, Humanity 2.7a which we do like, and, after some tweaking by the software developers, integrate it into Humanity 2.7b which we don't quite like.

But let's not program the whole thing in C or C++ which are susceptible to buffer flow attacks (among other problems).

We can develop patches for our Humanity program as well. For example, we could add a utopia patch. Or even a dystopia patch for fun. We could add a superheroes patch that would take a certain number of humans in Humanity 5.0 to "a new phase of evolution." Or, if Venter wants to experiment with a zombie patch, hey, that's totally cool too! Just make sure he does it on an asteroid, not on a moon let alone planet since they're arguably more difficult and expensive to terraform.

BTW, some might think we'd need more than just a handful of terraformed planets in order to run all our various programs, which might get a bit time-consuming as well as costly in terms of needed resources and manpower to terraform. It's not as if planets grow on trees!

But that's not necessarily the case. Sure, it'd be nice to have multiple planets to play on. But it's not an absolute necessity. We could just re-use the ones we've already got. What I mean is we could just delete Humanity version 3.x if it's getting a bit old or too many bugs keep cropping up or whatever, and subsequently reformat it with a version we do like on Earth 3.x. It's all good.

Moreover, perhaps we could dual or even multi boot different versions of Humanity on the same planet. Obviously we'd have to divide the planet into various partitions.

We might not want to run pirates and ninjas together. Or, wait, maybe we do, in order to better answer the age-old question.

Or if we don't like how slowly Humanity 3.1 is running on Earth 3.1, then we could heat the planet's core and overclock Earth 3.1.

Eventually it'd be nice if we could run several planets together in parallel to harness their collective power and achieve higher performance levels.

Also we ought to consider networking the various planets together for better file-sharing. Or to play MMORPGs. Let's hope Humanity 7.21 on Earth 4.2 (the planet formerly known as Jupiter) doesn't utterly obliterate Humanity 6.1 on Earth 3.8 though, since we'll disable things like respawning.

Of course, we'd have to come up with a multi-planetary defense system. We'd need a firewall to keep out invading alien species. In this case it might help to install the Ender Wiggin update as well.


  1. You make it sound so hard. I propose Git ( and the following branching model ( to keep track of the different versions of humanity.
    You could still use C++, just add a bunch of unit tests ( and do continuous integration (CI, e.g. CruiseControl to make sure it's relatively safe after each committed patch.

  2. Does it make me a huge nitpicking geek if I point out that the image at the top of the post is actually from Sid Meier's Alpha Centauri, and not from SimEarth? :P

  3. Hi Christoph,

    Thanks, that would streamline and expedite the whole process. Maybe you'd like to apply for the CTO position once Project SimEarth gets underway? :-)



    Hi Chris H.,

    LOL! :-) Well, the SimEarth images I found looked way too ancient. But I used to love playing Sid Meier's Alpha Centauri. So I couldn't resist grabbing an image off of it.


  4. Patrick,

    I would be delighted to lead humanity into its (artificial) future.