Perhaps an analogy from software engineering would help.
I'm currently working on a GUI that communicates with via telnet with our equipment. Basically, it presents a Windows application view for the user to monitor the equipment status and send configuration commands to the equipment. Actual communication with the equipment is through a not-very-human-readable command protocol for which the GUI acts as an interpreter for the user.
Actually, we have three systems that we're doing this for and hence three different GUIs, with the third system being new and its GUI currently being developed. The approach we're taking on this third GUI is analogous to what evolution does: take what's already there and modify it to a different use. That is an approach that engineers frequently use: take something that already works elsewhere and modify it for this new application.
A second engineering approach to parts of a new design is not at all like what evolution does: we take an entire module or sub-system for an entirely different design and plop it into the new design, redoing its interface with the rest of the system as needed.
OK, since the third system is very similar to the second, I took the second's GUI as my baseline and started modifying it. There were also some new plug-in cards in the system, so I made copies of the code modules that handled the old cards and modified them for the new cards -- analogous to evolution taking copies of genes and modifying them to make new proteins. And the over-all layout of the equipment is similar to but different from the layout of the second system, so I modified that -- analogous to evolution taking an existing structure and modifying it.
But the third system uses GPS, which the second doesn't but which the first, much simpler, system does. So I took the code modules from that first system's GUI and copied them whole into the new GUI, adding some "glue code" to connect it to the rest of the program. This is not at all like something that evolution would be able to do. This is an example of a designer being able to
and motivated to add something that evolution could not account for. BTW, when I had to upgrade the first GUI to handle a new firmware version in the equipment, I solved most of that problem by lifting entire sections of code from the second GUI and transplanting them into the first GUI; the arbitrary non-evolutionary transfer of code travels in both directions.
Many years ago, I once mused over a new science: software archaeology. As you compare the code in different related programs, you can see where code had been copied and modified to new uses. Indeed, there is such a science, but it's computer forensics and is used in finding evidence of patent and copyright infringement. But the point is that in comparing the code of different programs or even examining the code of a single program, you can detect where code was copied and modified (the evolutionary approach) and where code was just simply inserted whole (the ex-nihilo approach).
So, a Designer should be able to put a Design together any way He wants to, including lifting a perfectly good design for something that He had done elsewhere (eg, wings, obtaining oxygen while living underwater as whales must) and reusing that design over and over again. But evolution is far more constrained and can only work with what is inherited from previous generations and hence has to repeatedly reinvent "common features" (eg, wings, obtaining oxygen while living underwater as whales must) by modifying what is already there.
And again, by examining the Design, we can see whether an evolutionary approach was taken or an arbitrary "ex nihilo" approach. Overwhelmingly, we see evidence of an evolutionary approach. "Common features" such as wings may at first appear to be the same design reused, but when you examine them more closely you find that a bird's wings are different than a bat's, that they use different bones, and as you examine and compare bird and bat genomes you should see that the genes for those wings are different and that should also become apparent when you compare the embryonic development of the wings -- a Designer reusing a common design should have done it with the same genes or very much the same.
Of course, evidence that an evolutionary approach was taken does not preclude a Designer, just a Designer who was free to act arbitrarily and to reuse the same common designs over and over again. The Designer could just as well have constrained Himself to use an evolutionary approach, to have created Nature and then to use Nature to do the rest of the work; as Genesis says, God commanded the waters and the land to bring forth life (Gen. 1:20,24).
Compare topiaries with banzai trees. A topiary is a shrub that's been trimmed into a specific shape, such as that of an animal. There are artful ways to do it, I'm sure, but normally they just hack it into that shape. But a banzai grower patiently trims and influences his creation's growth in the directions that he wants, using and bending Nature to his will. Your Designer as a topiary hacker is far less impressive and praiseworthy than your Designer as a banzai grower.
PS
Recommended reading:
The Blind Watchmaker, Chapter Three, "Accumulating Small Changes", by Richard Dawkins.
The main reason for that recommendation is the model he presents there for how evolution works. It's the same as is used in
genetic algorithms, a powerful engineering approach that directly uses evolutionary processes:
1. Initialization. Start with an initial population of solutions.
2. Selection. Apply a "fitness function" to select a set of the best (ie, most fit) solutions in that population to produce the next generation of solutions.
3. Reproduction. Use the selection solutions to generate the next generation of solutions, using various techniques to increase variability (eg, cross-over, mutation).
4. Termination. If one of the solutions meets the required criteria, then stop. If not, then go back to Step 2 and repeat.
In life, there are a few more steps and another complication. From basic biology and genetics, your genetic code is called your
genotype while your physical characteristics is called your
phenotype. You inherit your genotype and it is the genotype that is subject to increased variation through genetic recombination and mutation; indeed, the only form of mutation that means anything in evolution is genetic. But selection does not act on the genotype, but rather acts on the phenotype. And the phenotype is created by the genotype through the process of
embryonic development.
It is in Dawkins' discussion of his BIOMORPH program that he goes through the links between genotype, phenotype, and development.
™ Version 4.2
(1)