Writing in the journal BIO-Complexity, Winston Ewert has recently proposed the idea of a dependency graph to describe how designed objects in biology are typically related, by analogy to computer software. I’ve commented on Ewert’s article already, as have others at Evolution News. To help further explain the concept, I would like to introduce readers to my pet bunny, Daisy.
She is a lop-eared Netherland Dwarf rabbit. Or to put that another way, I have an object named Daisy of class Netherland Dwarf Lop, which is a kind of Bunny. Every Netherland Dwarf Lop is a Bunny, but not every Bunny is a Netherland Dwarf Lop.
Object-oriented programming languages like Java use the idea of a class: every data object is an instance of a class, and the class defines its properties. A second major idea is inheritance: new classes with more properties can be derived from old classes with fewer properties. The class Netherland Dwarf Lop is a subclass of the base class Bunny that has the additional property of floppy ears, and Bunny is a superclass of every particular breed of bunny. In Java, every class is a subclass of class Object. That means that every object of every class has the properties of an Object, but can have other properties in addition.
Inheritance in Biology
Presumably all Bunnies share a Bunny ancestor, and that ancestor was not a Netherland Dwarf Lop.
The software engineering concept of inheritance parallels Darwin’s idea of descent from a common ancestor, where superclasses and subclasses correspond to higher and lower taxa. In Darwin’s theory, taxa are not merely categories for organizing things; it is believed they always reflect actual ancestors which actually lived in the distant past. The idea is that the ancestor species (of the superclass) was relatively simple, but already had the key defining characteristics of the whole taxon. Over time, more species (subclasses) were derived by inheriting the characteristics of the ancestor, but also acquiring new characteristics by chance and natural selection, which could then be passed on to a variety of even more complex descendant species (subclasses of subclasses). The result would be that all species are related by a tree graph, like classes in an inheritance hierarchy.
The idea of Darwinian inheritance has some major limitations. For one thing, what did the original vertebrate look like, if it had no characteristics other than a backbone and a digestive tract? There has to be a certain amount of functionality at the outset, and some default properties: in order to survive, even the earliest lifeforms would have to start off quite complex. For just one example, evolutionists believe the earliest vertebrates had gills, even though many vertebrates today do not have gills. This is one way of looking at the huge problem of the origin of life: Ordinary organic molecules don’t have a lot of structure or function, and are not alive. They are a superclass to the subclass of complex biological molecules but they are not ancestors to them.
This limitation applies at every higher taxon as well. In Java, one does not usually create an object of the Object class, since it doesn’t do anything. The Object class is more like a category than something that you might instantiate, and it makes sense to think of the vertebrate taxon in the same way; there is no need to suppose there was a single ancestral vertebrate species. And even if there was, where did the additional complexity come from, to create taxonomic classes, orders, and families down the inheritance tree?
Our experience tells us that functional innovation comes from engineers. The central conceit of Darwinism is that natural selection, plus chance, is supposed to add complex new functional characteristics to all organisms over time. In practice it doesn’t, as we keep on saying here at Evolution News. In fact, the kind of evolution that happens in practice (for example, from wild Bunny to Netherland Dwarf Lop) has more to do with loss of functional characters over time (Lops can no longer hold their ears up). Living things start out complex and become more simple. Mike Behe has a forthcoming book, Darwin Devolves, which explains that point extensively. There are already some great preview articles here.
Composition over Inheritance
But there is another problem with the whole idea of inheritance. Software engineers have discovered that it is a terrible way to design new things. It turns out to be unwieldy and inflexible. Here is an article that explains why. This is worth repeating:
The really big problem with inheritance is that you’re encouraged to predict the future. Inheritance encourages you to build this taxonomy of objects very early on in your project, and you are most likely going to make design mistakes doing that, because humans cannot predict the future (even though it feels like we can), and getting out of these inheritance taxonomies is a lot harder than getting [into] them.
In other words, the problem with inheritance is that it locks you into certain design choices, and that can make it impossible to combine existing traits in new ways in the future. This is also closely related to the concept of generative entrenchment. Inheritance makes life difficult enough for an intelligent designer who does have foresight, never mind a blind and undirected process like Darwinian evolution.
Instead, software engineers have found that it is better to compose each new design from the particular elements needed each time. Newbie programmers are now taught to prefer composition over inheritance. That is, it is usually better to compose a new class or program from well-designed generic components, rather than progressively tacking new features onto existing classes or programs.
So to make the prototype Bunny, instead of starting with a non-descript weasely sort of thing, you might start with a framework; say Mammal; but then add the particular modules for the face, ears, legs, fur, gut, and behavior that you want. Finally you could add a bunch of options as recessive genes or hidden features (let’s call them Easter Eggs) to add a bit of variety or flexibility for its offspring, so that Netherland Dwarf Lops can appear.
The really interesting thing about biology is that living things do not seem to have been hampered by the limitations of inheritance. Bats and whales both have the complex characteristic of echolocation, despite the obvious impossibility (obvious even to Darwinians) of inheritance from a common ancestor who could echolocate. Likewise, consider the similarities between bats and birds, or dolphins and ichthyosaurs, which are very odd from a Darwinian point of view. There is an incredible array of animals that all have complex eyes, often featuring similar designs in taxa as wildly different as cephalopods and mammals.
The same characters appear again and again in life, but often without respect to inheritance. The tree of life constructed by Darwinian biologists is riven with conflicts at every level. One class of characters might indicate one tree-like relationship, only to be contradicted by a different class of characters. Darwinians have proposed all kinds of ad hoc mechanisms to explain this: horizontal (lateral) gene transfer, incomplete lineage sorting, convergent evolution. But wouldn’t it be better if there was one clear reason? And what if the reason was composition? That is, what if living things look the way they do because they were originally composed new from common parts, rather than derived from non-descript ancestors?
Composition Mistaken for Inheritance
If composition is a preferable explanation, then why have mainstream biologists not embraced it? Well, it is partly because biologists who have looked for an inheritance tree, and have found enough of a signal in the biological data to be convinced that there is something to the idea of inheritance. However many conflicts there may be, the idea of an inheritance tree still fits the data better than the idea of simple compositions.
But what if the compositions were not simple? In his paper, Winston Ewert’s key insight is this: not only are living things composed of elements, but many of those elements are themselves composed of other elements. Components are called dependencies, and the dependencies of dependencies for all species can be organized into one big dependency graph. The graph is not a tree, but parts of the graph look a bit like a tree if you ignore enough of the anomalies.
This realization, if confirmed, would be highly illuminating for biology. Ewert suggests that the dependency graph explains real software data and real biological data, and far better than any inheritance tree. In other words, the dependency graph idea explains the signal that looks a bit like a tree of ancestry, but in terms of composition rather than inheritance. It also goes much further, predicting that many genes follow a kind of “inheritance” (for want of a better word) that has nothing to do with taxonomy. Those predictions have been borne out so far. You can read about how Ewert tested these ideas in detail here.
It seems that living things may not be branches on a tree at all, but a forest of compositions (of compositions (of compositions)). And if true that would make sense, because compositions are better designs.
Photo credit: Daisy, by A. Jones.