From the comments I received, it is apparent that I rushed through my description of mutation, which seems to have led to some confusion. I will attempt to rectify that shortcoming.

When I speak of mutation being non-random in biological life, there are a couple of ways to think of this. First, consider spontaneous mutation – a piece of the genetic code transforms itself from one message to another: we add a new nucleotide, or we remove an existing nucleotide. Assume no external influence. The rate at which these bits change depends entirely on what these nucleotides are. Some portions of that genetic code are more likely to change than others, due to the inherent stability of the molecules and the degree to which these modules really like being next to each other. Every nucleotide is not equally likely to change in an event of spontaneous mutation as any other nucleotide. Thus, it is not random. Now, you can also consider external factors. If the new combination is particularly unstable, that mutation may not last long at all, and instead trigger additional mutation. That mutation may produce a phenotype that is incapable of survival. These are also highly non-random.

What is seemingly random is the phenotypic response to a particular mutation. It is convenient for the molecule itself to mutate – this does not occur for the benefit of the organism. A nucleotide sequence in DNA will mutate purely because it is more unstable than another one. It does not matter to the forces governing the mutation whether the resulting organism will benefit from this mutation or not. There is no intelligent design for this mutation. The DNA sequences governing eyesight, for example, are not going to mutate purposefully in order to improve that phenotypic response. If eyesight improves, it will be the result of random mutation, and disproportionate survival of organisms whose eyesight turned out better because of these mutations (natural selection).

Mutation in software occurs primarily with explicit intent. (Yes, there are examples of viruses and other malicious software modifying the underlying software instructions, in much the same way that a gene researcher may insert a new sequence into an existing biological organism.) A jnz instruction will not mutate spontaneously into a jne instruction, for example. (A particular instance of this software – one cell – may do that in the event of hardware failure, but the software itself does not.) The creator, and the overseer of this organism, will change the underlying code with the intent of creating a phenotypic response that increases its chance of survival.

Given the concept of intelligent design and purposeful mutation, we can consider how we want to go about mutating our software (since I believe we can all agree that software is not yet perfect). This brings up another reader question – what is the boundary of the gene, as opposed to the entire body of DNA for a piece of software? The truth is that this is something that is under the shared control of both our tools and us, as software developers. The reader suggested something like a class or a struct. While there certainly are some elements of the analogy that strongly suggest this, my tendency is to disagree. Why? This is an artifact of the tools we happen to use for intelligent design of software DNA. I create a class because it makes it easier for me to create my software. The design of my class drives the creation of a particular type of software DNA only when I am using the exact same compilers in the exact same environment. If I use the same compiler for that class, I will end up with the same DNA. If I use a different compiler, I may end up with completely different DNA that exhibits a completely different phenotype. For example, I may compile some C++ code using a compiler optimized meticulously for one particular processor. The result will – presumably – be code that runs faster on that processor. If my intent is to create a high performance library that only needs to run on that processor, the same input created a vastly different expression with vastly different survival characteristics.

To me, a gene is a segment of binary code – a unit of deployment, if you will. I have seen (poorly written) software that embeds a huge amount of logic into a single logical unit of deployment – both at the human-readable source code level and the actual binary DNA level. Others more carefully analyze their software to ship them as a bundle of genes that can re-use each other and make the process of evolution more straightforward.

However, since developers are predominantly human, then it is probably more useful to think in terms of the genes as having some meaning at the source code level. Even though I do not personally believe this is the best analogy, it is far more useful in a world where very few people write their code in 1’s and 0’s.