Well, frankly, looking at actual genetic code, one can't help but find it rather ... organised. You know, being produced by a randomized search algorithm and all, one doesn't really expect so many features.

Everybody knows about telomeres, the "death clock". But there's more. Every gene has a preamble, most of which is not understood. Some of it is known to encode parameters along the lines of "if you detect substance X, copy this gene", with hundreds of variations and parameters in there (like the concentration to be detected for example). It is also known that it is possible to have AND and OR relations in these preambles, and one preamble can refer to another, by name (not by position in genes). This is followed by a small set of instructions meant for the ribosome (the easiest of which is along the lines of "stop after X number of basepair-triples are processed, do not continue to the end of the gene"), then the start codon "ATG" (for all plants and animals, bacteria and organella use others), and then the gene itself, the thing that contains actual instructions to build proteins, followed by a stop codon, of which many variations exist. Then there is a post-amble of the gene also meant for the ribosome (instructions like "export this resulting protein to the outside of the cell", as opposed to releasing it inside the cell, and this contains a wait timer, and a death timer).

So what our DNA does is send programs to ribosomes that are generally along the following lines :

1) n = 0; stop_after_codons = $X; modifiers = $Y
2) transcribe (taking modifiers and stop_after_codons into account) until you hit the stop codon
3) while $TIMER, hold on and do nothing
4) if $EXPORT request a cell membrane to envelop the protein and make it leave the cell (and a hundred more of these modifiers)
5) n+=1; if n < $X goto 1 (by releasing the RNA chain. it'll quickly get picked up again by this ribosome or another and restart the program), else destroy the RNA chain by making it's central half-helix collapse

Note that this is the very lowest level of structure that is inside the DNA. There is very distinct highlevel organisation as well, we just don't understand it at all. This is also not the lowest level of structure inside an eukaryot cell, as the ribisomes/mitochondria/... also have internal DNA and are executing complex programs themselves, and our DNA is just one of the parameters they work with.

This is, frankly, not at all how I'd expect the result of a genetic algorithm to look like (referring to the AI concept of genetic algorithm). Genetic algorithm outputs/programs can be generally summarized as working as follows :

1) poewuiqfawer;awe;rj;l // Non-sense, but usually a NOP that jumps to position 2
2) take the data xor with some weird value
3) jump to random location in the gene on some condition
4) jump to random location in the gene on some condition
5) result = value and 2309823141
6) op8uqwerawe;jkasdfaser // Non-sense
7) jump to random location in the gene on some condition
8) q[3452345g23421dad // Non-sense
9) jump to random location in the gene on some condition
10) take position 3+8*n-5 in the data, add 5, and xor the value at the resulting location with 290138472134

Let's call it "horror-basic". Spaghetti code doesn't quite cover just how much spaghetti there is here. You'd think there'd be a lot of difference between programs that implement different functions, but when you don't understand what the hell it's doing all programs look alike. While I have seen once or twice things that looked like a basic structure in the result of a genetic algorithm, it's extremely rare, and certainly nothing as pervasive as you see in the human genome.

Programs like this example then somehow manage to calculate uncalculatable functions, or find something in an image, or they produce instructions that you can send to robot legs that make them go forward.

This could, of course, be a difference in complexity. Nobody's ever run a genetic algorithm for more than a few months, and the genetic algorithm we think operates life has been operating for ~4 billion years. Still, our DNA, frankly, looks like a medium-size (certainly no more than 10k-50k lines of code) program that has been compiled from a much higher level programming language. I'm not saying it's not written by a genetic algorithm, and genetic algorithms are famous for taking bloody long to do even the most basic things, but ... I'd like to see this genetic algorithm's implementation, because it's a lot more complex than just duplicate, mutate, evaluate fitness. And it's output is remarkably better than anything I've ever come up with. It looks very LISPy in the sense that the DNA's basic operating principle is to rewrite a highlevel program into a slightly lower level program, and then rewrite the lower level program, and then rewrite it again into a protein (and then let physics "rewrite" those proteins into things like human beings).

not including all the organelle programs it depends on