In another thread talking about engineers’ perspectives on the machinery of life the topic of entropy came up. Engineers have to deal with entropy in all their designs and the very best efforts at dealing with it only serve to slow it down and never stop it.
So one of my big questions isn’t why most cell lines sooner or later go extinct as that’s easily explained by entropy. Rather my big question is how a rare few of them have managed to persist for hundreds of millions or billions of years.
In computer design engineering we have to deal with users changing the software load in unpredictable ways. We ship the computer out with a software load we know works. It then “evolves” unpredictably as the computer is used and customized without or without the informed consent of the owner. Often that evolution of the software load results in a system that no longer functions. Without some recovery method that particular computer, which is analogous to a single cell line, would become extinct. The ways we address this problem are many, convoluted, and complex but I’d like to focus on a few in particular.
One method is called a “factory restore”. In this method a protected image of the known working software load from the factory is used to replace the evolved load. This is typically implemented by a user accessable trigger and an image stored on a protected segment of the hard disk or separately on a CD rom disk.
A somewhat less effective but largely successful method of recovery from disastrous software load “evolution” is employed by more recent versions of Microsoft Windows. It employs automatic trigger mechanisms that take a snapshot of the current state of the software such that if disaster happens the state can be restored to a previously known working state. This allows successful modifications wrought by evolution to “survive” without backtracking farther than absolutely required. It doesn’t always work because the images aren’t complete snapshots, which would quickly overflow the storage capacity of the disk, but rather carefully selected critical bits are saved that usually work to restore a known working state.
In other than inexpensive personal computers where cost isn’t so prohibitive (such as servers) both automatic and manually triggered backups of the software state are made to external, removeable media. In the most critical applications multiple backups are made and stored in physically separated locations such that a catastrophe, like a fire, in one location won’t destroy all the copies.
Now since in my experience many (if not most or all) designs we humans invent to solve engineering challenges end up having analogs found in the design of life I propose that a plausible answer to how life deals with the devastating effect of entropy is along the same lines used in computer systems. Periodic backups are made such that what random evolution hath wrought on the software load (DNA) can be undone back to a previously known working state. Evolution starts over but doesn’t start over from scratch. The details and triggers employed can only be imagined at this point in time but it doesn’t take much imagination for a computer design engineer. Experiments to tease out the methods and triggers, if they exist, seem like a reasonable line of inquiry.
It’s difficult to imagine how mutation and selection could invent a disaster recovery method such as this and that likely explains why there’s little if any research thrown at figuring out why most but not all cell lines eventually go extinct. This is where the ID paradigm becomes very valuable. Rather than limit the possibilities in the design of life to what is reasonable for a reactive process like mutation and selection to invent we extend our thinking to what is reasonable for a proactive process like intelligent design to invent.