Have you ever pondered about some really amazing feature of the biological world? The eye? The ear? The sense of touch? Bird flight? These are features evolved very gradually, over many generations. The net result was something that seems incredibly impressive. Sometimes so much so that it is hard to imagine that something so impressive could have evolved at all, yet they did.
None of these features evolved through single step selection. A group of eyeless creatures did suddenly had offspring that had an impressive eye, complete with a focusing lens, a retracting iris, and appropriate neural connections. It is far more likely that one cell happened to be more light sensitive, so it evolved to have even more light sensitivity because that provided a competitive advantage. Eventually, a mutation came along that had two light-sensitive eyes. This gradual and naturally selected process continued until the eyes that we see today in all sorts of creatures had developed. (This, incidentally, happened more than once.) Of course, it is theoretically possible for something as complicated as an eye to evolve in a single generation. However, the odds against that happening, and happening in a way that is beneficial to the organism, are incredibly small. In fact, there are mechanisms in place to prevent such massive changes in DNA structure, because most massive mutations are not good things.
The same is true of software. Most great software has evolved over many versions. Seldom is it exactly right the first time. Of course, a version of software is a somewhat arbitrary measure, because release criteria is not always equivalent. One developer may release 30 beta versions over 3 years before finally declaring a build V1.0. Another developer may release just two betas over 6 months before declaring a build V1.0. Therefore, we cannot take the build number at face value. The idea, however, is still the same. You are probably not going to get your software right the first time. You will release it into the wild, and all of a sudden, you will find a number of things wrong with it. In response, you evolve and refactor your software (assuming that it survives the first release), and the second release is generally better because we have directionally (as opposed to randomly) evolved it with a particular phenotype in mind.
Avoiding single step selection is a good idea. You wouldn’t want to just sit down with a text editor and start writing code (which will generate digital DNA) for an operating system, proceed until you have implemented everything, and then compile and expect that, in a single step, you will get exactly the phenotype you are hoping for.
This has behavioral implications. This is why a daily build is such a good idea. You generate a functioning organism every single day, and you can measure its phenotype against the expected phenotype, incorporating necessary mutations in the work that follows. It also makes beta releases a good idea. You are placing a particular set of DNA into an environment that more closely represents the “wild” of released software, so that again you can measure the actual phenotype against expectations.
I am a huge proponent of Microsoft’s latest beta approach – the Community Technology Preview. This puts the organism in the hands of as many people as possible, so that natural selection determines which features make it into the final version, which features mutate, and which features disappear entirely. Allowing the actual environment to influence mutation earlier and more frequently helps ensure that the organism is as viable as possible when you release the final version of your software.
Avoiding single step selection is also a compelling argument to avoid complete re-writes of software. Occasionally, a fresh developer will look at the code and suggest that they should lose all of the existing code and start again from scratch. After all, that code is old and full of messy bug fixes. What they apparently do not understand is that those mutations were necessary for the software’s survival. While another mutation might exhibit the same phenotype, how likely are you to find that more eloquent mutation on the first try? It is critical to leverage the value of the mutations to the software organism’s survival, and continue to mutate with future survival in mind. It is best to avoid mutation simply because it is old. In software, as in biological life, genes that have survived for quite a long time are very likely to be genes well adapted to survival. Why would you want to lose them?