What is a living cell and DNA from a digital computing perspective?

The cell is a system that receives input materials, uses them in certain ways and produces one or more different useful outputs and waste. The cell is a closed system containing highly organized and integrated subsystems that operate in a complete and complex synchrony. These subsystems are discrete molecular machines closely integrated and equipped with monitoring and loop back connections. One can think of the cell as a super modern car factory, where everything is performed by robots, the raw materials are delivered to the input gates of the factory and the finished cars and waste are taken away from the output gates. All work, including repairing of broken robots and machines is done in the factory by other robots and machines. Nothing except raw materials enters into the cell and nothing except ready production and waste exits.

The DNA is both storing information and the information itself that controls the operation of all robots in the cell and entire organism.

Since the cell is a completely computerized factory and the computing model inside the cell is digital – the same as in a modern computer, only much more sophisticated and tuned we shall examine creation of a digital computing system from the moment it was conceived to the moment it is fully operational and then will multiply that to see what is necessary to have an operational fully automated factory. In this way we shall see what was necessary in order to produce a working cell, although in a short article like this we will be able to only scratch the surface of a mountain of complexity.

A digital computing system consists from at least two hardware parts – memory and processor plus one or more software parts – that is one or more programs. Such a computer system would be quite useless, as it is closed and any useful work that it might have done will be firstly limited to a pure computation and secondly the results will be inaccessible, locked in the memory since the system is closed. Before we add elements to that system so that we make it a little more useful, we will have a little more detailed look at the memory and processor.

The memory is storage of information. Depending on the type of information memory can be of different types, and have different types of attachment to the processor as well as different ways of being accessed. Memory is a passive element, but it contains the assembly instructions that control the operation of the active element – the processor.

The processor is the active element of a digital computer system. It reads assembly instructions from the memory, interprets them and consequently executes them. The results of their execution can be different types including such that it may need to be stored in memory for later use. Every processor understands only limited sets of assembly instructions for which it was designed and created. Each instruction that a processor understands is hardware programmed in it as a set of digital circuits that perform that particular operation. For example the designers of a certain processor might have decided for whatever reasons that instruction 10000110-b will represent addition and instruction 10000111-b subtraction. The designers of another processor might have decided that instruction recorded as 01110110001000111001011101010110-b will represent addition and instruction 01010100011000111000001001100011-b will represent subtraction. The difference between these two processors is not only the actual data that represents the instruction but also its range. Bigger instruction size means a wider range of possible instructions, usually bigger data word, wider bus connecting the processor and memory, wider word of the memory and faster relative operation. The first two instructions above are 8 bit while the second two are 32 bit wide, where both processors are using binary logic. The designers of a third processor might have decided that their processor will use quaternary logic thus being relatively much faster, but far more difficult to produce. For a quaternary logic processor an instruction might look like 0123-q or 12301102133-q and so forth.

The memory that is attached to the processor must be compatible with the processor in every possible way. It must have been designed for that processor – it must be able to hold compatible data in word size and dimensions. It must be attached compatibly - that is the width of the address and data buses, the voltage levels, the impedance of the input/output circuits, the frequency characteristics, and other properties e.g. physical characteristics must be absolutely compatible. Next but also vitally important is that the memory must be of sufficient size in order to hold all necessary software items and data. Other characteristics of the memory are whether it is read only memory or random access memory; for how long data can be held without being corrupted.

Summarizing what is necessary for a compilation of simplest digital computing system:

• formulate objectives – decide the scope of the system, what will be expected from it, including:
  - complexity of problems to be solved,
  - performance requirements
  considering what are the available resources and technologies, is that possible.
• decide what numeric system will be used
• design what micro-operations will be performed by the processor
• design the circuits that will perform the micro-operations
• design all subsystems of the processor, including read/write operations, input/output operations, interrupts, hold, reset, back loops, address bus, data busses, etc, etc, etc
• design memory with compatible electrical characteristics, physical characteristics, address bus, data bus, data type, synchronization, etc, etc, etc
• produce processor
• produce memory both types ROM and RAM
• create a complete hardware system
• design a program using the instructions previously defined
• write the program and somehow transfer it into the ROM memory
• launch the system
• Test the system, if there is a fault then find the source of the fault – is it a problem in the processor, the memory, the surrounding elements or the program. Go to the appropriate point above, fix the problem, continue with next point.

By now it must have become ABSOLUTTELY clear that before writing a program one must have constructed the entire computing system that will accommodate, interpret and execute that program. The software is separate from the machinery and is dependent on it. The machinery must first exist and then the software can be designed and written.

This concept is a fundamental principal of all information/processing system. This fundamental principal applies takes precedence over all disciplines that are using information processing systems, including living biological cells.

In evolutionary terms, evolutionists must explain how the system (the cell) including the DNA as memory placeholder, (but excluding the DNA as information) assembled itself (without assembly instructions to control the molecular machines to create and replicate the entire cell including DNA as placeholder), and then how the DNA as information (the assembly instructions appeared).

Evolutionists grew the idea for mutation as a force required to help natural selection. From a computer design engineer the proposal that mutation can be useful in that sense is remarkably naive and is truly hilarious. By definition evolution enhances the organism, it adds information. The mutation as explained by evolutionists is when an error occurs and information in DNA is changed. Change of DNA as in static state cannot add new information; it can only replace an existing instruction. In a computer program that would mean to change the value of an address with another value e.g. 10000110-b with 10000111-b. If the two values happen to be unimportant data e.g. part of the name of a menu item then there will be a little dissatisfaction but the system will continue to work. However if the value that was replaced was a constant data used in computation or an instruction then the program will stop operating correctly and its results will be harmful. The same applies for mutations that may occur while the program was copied. If a byte was omitted to be copied then that is obviously a serious problem; in the best case the program will malfunction, in the worst but most likely case it will pass illegal instruction to the processor and as a result the processor will either hang or throw an exception and terminate the illegal program. If an instruction was copied incorrectly then this is the same case as with a static change of instruction or data. If a new instruction or data was injected in the program while it was copied then either the result will be the same as missing an instruction, or the data segment of the program will be moved, thus creating a complete mess during execution which will most probably end in an access violation, or in the best case the algorithm of the program will change and some undefined error in the program operation will be present. To have a useful mutation a very precise intervention must be done, first one MUST secure space for the new data with EXACT size, and then the new enriching code must be injected at the precise place of the program. A number of other changes must be undertaken in order to ensure the integrity of the program. For example all jumps and branches of the program which pass over the change must be recalculated and replaced with a valid new offset. This is on its own is a very serious exercise which requires transformation of the entire program, however this is not all. Because the size of the jump has increased it is possible that some jumps will be no longer possible, so the change does not only involve changing the data for the jump instruction but also changing the actual jump instruction. Changing the jump instruction in this context however means change of the program size, as smaller size instruction is replaced with bigger size instruction, but that means that some jumps will be again invalidated, so everything must be done again. To summarize injecting a little information "mutation" in the program code means that the program must be re-assembled as many times as conditional/unconditional jumps are in the program plus one (worst case). After doing all this, we might still end up with useless program, because the program logic might expect a particular jump (the physical) instruction at a particular place, which we just replaced, so the program logic is corrupted, and it won't work. The same issues that make any mutation of a program harmful apply to DNA. Only a dilettante may suggest that mutation of highly specified code could produce useful change. In the best case the change will produce little harm. In the usual case the results will be devastating, that is death for the system unless someone restores the order.

We will continue our discussion for creation of a complete fully automated factory to further see the fallacy of the idea for self organized living matter. Let’s assume that the simple computing system consisted only from processor and memory is now created and operates properly. The next thing that is necessary is to add abilities to it, so that it is able to control certain things such as motors, pumps, etc. To do that the processor must have been designed with abilities to use peripheral circuits. These circuits are addressable in a similar way to the memory. They also must be compatible with the processor in the same way as the memory. The range of peripheral elements that can be attached is significant; they can be timers, frequency generators, digital to analog converters and so forth. Since the parts of the robots that need to be controlled such as motors, pumps, heaters, coolers, and other external devices have high power inputs while the computing device and its peripheral outputs are low power elements we now need to design circuit that will allow the low power output of the computer system to control the high power elements of the robots. We need to design power amplifiers and synchronize their inputs with the outputs of the computer system and their outputs with the inputs of the power elements. Failure to synchronize these circuits will result in destroying the computing system, which in turn will generate high level signals on the peripheral outputs of the computer system, which will be amplified and passed to the power elements. As a result some or them may get damaged and/or damage other mechanical systems connected to those power elements.

We need to rework our processor and give it some output capabilities, so we go back to the creation algorithm above and start from beginning. Once we have done this we need to create the digital peripheral circuits, the mixed peripheral circuits and number of power synchronizers. This is not easy at all – suppose you have an iPod, and you need to make it to play so loud as to make a concert on a Olympic size stadium - all you have is raw materials and you, you have to do it yourself. Imagine you really have to do this ... make a concert for 120 000 raving people with your iPod... Once we have all elements we need we again have to go back to our creation algorithm above to assemble everything in a working system.

So far so good but having output peripherals is only necessary and not enough in order to control any robot, it is also necessary that some input is delivered to the computing system. These inputs tell to the computing system what is the position, state, etc of the robot working element, other power elements state and others. We now must further enhance our computing system to accommodate this requirement for input. The next thing that needs to be done is to develop sensors, which are placed respectively to gather information and supply it to the computing system. The output from sensors is usually not directly usable by any computing system and need to be converted to compatible digital type of data that is usable. Therefore we must also design circuits that convert the sensors output to digital signals. These circuits must have input compatible to the particular sensor output and their output must be compatible with the computing system power characteristics. If these (as well as the output) circuits are incompatible or malfunction the results will be devastating for the entire robot.

Let us assume that we have designed and developed sensors, circuits converting their analogue output signal to digital, peripheral circuits that are required to attach the sensors digital signal to the computing system and finally we have extended the processor to be able to accept that input information. Although we expanded our computing system beyond recognition it is still not fit to be used for control of a single robot. What will happen if some sensor reports a critical condition that requires immediate attention but the program that is currently executing is engaged with a slow process unrelated to the signaling sensor? We need now to go back and add even more functionality to our processor that will allow it to handle interrupts. An interrupt is a special signal that goes into the processor to inform it that something needs immediate attention and the processor must immediately execute some specially designed program that handles the reason for the incoming interrupt. This interrupt handling program, will be written later according to what will be handled by the particular source, to which the interrupt port will be connected. After we add this new feature to our computing system and processor we are ready with the hardware part of it.

The next task is to write the software. Creating a program is more complex that simply writing it. Suppose that the computer system that we design will be used to control a transportation robot. We would like to have this robot to use the optimal trajectory in order to be as efficient as possible. If the system that we design will control an oven where some materials will be prepared we will want similarly to control the oven in an optimal path. The same principal applies to all systems that we will control. In order to be able to control any system optimally (and in some cases even just to control it) we have to model the system; this means to describe it in a mathematical way, and transfer the model into a program. In order to do that we must be not only experts in mathematics but also we must know the properties and laws of the physical world. (Remember that we actually examine a cell, i.e. we must fully understand the world and its properties on an atomic level). After we create a model we can transfer it to a program using the assembly instructions of the particular processor that we will be using.

Here is an example of a small assembly program for demonstration:

                      107  j2
 2216 [04] 18CE2004   108          ldy     #style_front
 221A [02] 8658       109          ldaa    #$58
 221C [04] B700DC     110          staa    supervisor_function_request
 221F [02] 4F         111          clra
 2220 [04] 33         112          pulb
 2221 [03] 37         113          pshb
 2222 [04] 183A       114          aby
 2224 [05] 18E600     115          ldab    00,y
 2227 [06] BD8400     116          jsr     Supervisor
 222A [03] 2403       117          bcc     j3
 222C [03] 7E2270     118          jmp     error
                      119  
                      120  j3:
 222F [03] CE6000     121          ldx     #$6000
 2232 [03] CCC700     122          ldd     #$C700
 2235 [05] ED00       123          std     00,x
 2237 [03] CC6000     124          ldd     #$6000
 223A [05] ED02       125          std     02,x
 223C [02] 8680       126          ldaa    #$80
 223E [04] 33         127          pulb
 223F [02] C117       128          cmpb    #$17
 2241 [03] 2720       129          beq     quit
 2243 [03] 37         130          pshb
 2244 [05] ED04       131          std     04,x
 2246 [02] C600       132          ldab    #$00
 2248 [04] E706       133          stab    06,x
 224A [04] 18CE2534   134          ldy     #$2534
 224E [02] 8680       135          ldaa    #$80
 2250 [02] C65D       136          ldab    #$5D
 2252 [04] F700DC     137          stab    supervisor_function_request
 2255 [06] BD8400     138          jsr     Supervisor

:10221000F700DCBD840018CE20048658B700DC4FE0
:102220003337183A18E600BD840024037E2270CEAE
:102230006000CCC700ED00CC6000ED02868033C1A9
:1022400017272037ED04C600E70618CE2534868010
:10225000C65DF700DCBD84008654B700DCBD840099
:102260007E21DA8654B700DCBDF900FE7FF03539F7
:10227000338645C603F700DCBD84003936861FB7B8

Looking into this very, very, ..., very tiny program it must be clear that a suggestion that a random mutation could enrich it is not naïve, it is plain nonsense. Any change of this code will result in a broken algorithm or invalid instruction. Now consider that the DNA of a human is about 3 billion symbols.

Creating the software program and storing it in the memory of the computing system concludes its development. This was a very brief overview about creation of a single computer that controls a single robot in the fully automated factory that we are building.

For every operation in the fully automated factory we will have to construct one or more robots and/or machines that will perform that operation. Consider how many operations are needed to create a car from raw materials. The fact is that this fully automated factory will be presenting the entire industry from paper manufacturing, woodwork, leather and cloths to metal works, electrical machinery and so forth – everything that is used in a car. Remember, in our factory only raw material enters and only ready production and waste exits. Every single operation in each of these sub-factories will be performed by a separate specialized robot(s), which we have to design and manufacture too. Then we will have to construct the factories and so forth.

Let us now assume that we have constructed all robots for our fully automated car factory. We have made a detailed design for each operation in our factory including all sub-factories and we made a specialized robot according to that design for each operation. Now we need to get all robots, machines and sub-factories to work in synchronous manner. We need to make a central computer that controls the entire system, the sub-factories, the robots and so forth. Of course each sub factory will have to have its own central computer, and may have its own sub-factories. We will have to make a production plan how our factory will work and enforce that plan.

To make things even more obvious consider that if the processor of one robot breaks up it must not only be replaced, but the same processor also must be produced within the factory. In other words in our factory for cars we have another plant for processors, memory, power elements, electric motors, hydraulic pumps, pistons, rubber, fibers, electrodes, and so forth, and, so forth, and so forth everything that is used in the factory, there must be even power station inside – only thing that enters the factory are raw materials.

The fully automated factory cannot fix itself before it is fully functional. It is not possible to build a half factory, which immediately starts itself and completes the whole factory. The system is operational only after it has been compete, and then launched. Further if the system is damaged and the damage is too big it will not be able to self-fix, therefore an assumption that the system was created gradually is simply absent of logic and understanding of design.

A cell is exactly like the fully automated factory that we described, the difference is that it is much smaller, much more elegant, much more sophisticated and the robots and machines are as big as molecules because they are actually molecules.

The next thing to consider is that in an organism such as human there are millions of different cells – brain cell, muscle cell, skin sell, bone, etc each of which is a different fully automated factory like the one we described.

It should be clear why for a design engineer the concept for evolving matter without the direction of an inteligent agent i.e. Creator is gibberish, plain garbage without scientific value.

Miroslav B. Bonchev
August, 2006
England

The video below is an interesting clip from an Exploration Films production.