by Brad Nelson 10/16/14
The more one reads about DNA and the various systems of control and manufacturing as carried out by proteins inside the cell, the more it looks like complex programming. In fact, it is programming. In order to build the structures in a cell, you have to have a specific program.
And anyone who has ever tried to create even a mildly complex computer program has quickly learned how difficult that is even when using all the powers of logic and foresight at one’s disposal.
I’ve done a bit of dabbling with programming here and there, including a small-footprint shareware calendar for Mac OS X. And let me tell you, even with the best intelligence at hand (or the average, as I have in this regard), it’s darn difficult to construct something in the real world via programming. There is no incrementing your way to a solution, other than the process of trial-and-error and debugging. You very much have to have in mind something you want to construct, and then you necessarily use the constrained, arbitrary, and obtuse methods of a particular language to do so. That is, the medium (computer bytes, circuit boards, proteins, whatever) are not the thing. There’s nothing in the thing that is “natural” to the end result (which is why, in practice, one is usually fighting with the tools). Thus you won’t explain programming via the physics of chemistry any more than you will explain the computer solitaire game you play on your computer via electricity.
And most programs that do anything worthwhile have various modules. And these modules each don’t do anything particular clever, but each is necessary and is part of the whole. For my calendar, for instance, there would be a module for handing clicks on the calendar dates, another for then displaying these dates, another for recording any info typed into the text field, etc.
But the design and construction process in no way represents any kind of evolution in regards to these modules. It’s not as if you start with a small one and then gradually build up to something more complex. Instead, one consciously breaks up a problem into discreet bits (or modules) with the mind (when all is said and done) to have all these modules integrate to achieve a designed purpose.
And that end goal is always in mind. But the modules themselves accomplish nothing in the sense of a useful function by themselves. In terms of natural selection, these modules are not complete unto themselves and cannot function except in relationship to the other modules, all of which are specifically written and integrated so as to achieve some structure and purpose. (Modules may be used in other programs, but even then they must be designed for this purpose in mind…typically designed so that a certain type of pre-designated data is to be fed into them, and a pre-designated type of data is to be output by them.)
Let’s just assume for the moment that I, as a programmer, am more intelligent than random chance. It’s difficult to image how you could construct any biological unit or subunit via a slowly evolving program. It’s devilishly difficult to write modules and algorithms, even with a goal in mind. Yes, software itself does evolve, but each feature added to a version 2.0 program is added by the programmer and with the same constraints, methods, and tools that were used to create the version 1.0 program (and probably with the mind to making enough changes to charge users for an upgrade).
It’s completely uncontroversial even among atheists/materialists to call it “the genetic code.” And the more we learn about DNA and the machinery of the cell, the more we see that it is a vast program, the DNA itself not merely storing raw data for the sequencing of DNA, but functioning also as an operating system and including (along with the cellular machinery) various programs. After all, it takes a complex program of some type to translate and construct proteins from the stored data, let alone putting together body parts and such.
Every attempt thus far by origin-of-life scientists to simulate on a computer any type of evolution of self-replicating life has had to (often unbeknownst to the programmers) insert their own intelligent design, especially in regards to having an end goal in mind. It’s thus difficult to see how any kind of simple program, let alone an enormously complex one that could form an immune system, could evolve by chance.
Normally it is chance events that ruin the ability of a program to do anything useful. A scratch on a CD, a miswrite on a hard disk (perhaps due to a power outage or surge), or even a mistyped keystroke typically break things. Programs are fragile, and thus it’s no surprise that many of the diseases that people suffer from are due to one protein or another (one could think of them as modules, or components of a module) having gone missing for some reason (the equivalent of a bug in the program)…perhaps because of a chance mutation.
I’m trying to imagine how I, or anyone else, would “mutate” one’s way to even the simplest via program. Just for the heck of it, take a look (granted, this is somewhat of an archaic language, but a powerful one in its own way) at how one can construct a game of Tic-Tac-Toe using the Logo language. Scroll down to the very bottom of this page where it says “Program Listing.”
Although other languages will necessarily promote solutions that look different, you can get some idea of the modularity of even the simplest of programs, of the many parts that must come together to function as one (forget that it all looks like gibberish…so does the content of DNA). Each part doesn’t do anything that would allow any kind of animal (or program) to survive and function. But together they can. Each module therefore doesn’t make much logical sense as an end-goal for evolution and natural selection. There would be no reason for natural selection to gravitate toward (assuming that it could) some module.
And for what it’s worth, here’s an online version of Tic-Tac-Toe written in Microsoft Small Basic. You can also see the program listening which is even far more complex (at least longer) than the one written in Logo.
I know that we have other programmers who frequent this site (professional or otherwise). It will be interesting to get their take on this question. And, to be fair, the nuts-and-bolts of the DNA operating system have barely been scratched. But they have been scratched, including this flow chart of the endomesoderm network. This is what a program looks like when expressed in physical objects instead of text symbols (which is what a circuit board basically is…programming for the use of electrons and such). This flow chart of endomesoderm charts the sort of “circuit” made by a complex network of proteins, and this is for just one aspect (the overall control and direction) of creating a specific type of tissue in a sea urchin.
A program is necessarily a different thing than throwing random darts at a dart board. And it shows.
Brad is editor and chief disorganizer of StubbornThings.
About Author Author Archive Email Follow • (2692 views)