You should consider it, lots of people are getting stunning results that way.
Your flip responses in no way refute that fact, and in fact look like mere evasions intended to avoid having to actually deal with the points raised.
Here, try to specifically refute this:
The top circuit is the best human-designed cubic signal generator ever made, patented in 2000 by Stefano Cipriani and Anthony A. Takeshian of Conexant Systems, Newport Beach, California.
The bottom circuit was purely evolved. It works better. It outperforms the best efforts of all electronic engineers, ever. It's sophisticated enough that no one understands how it works yet. In fact, it has bizarre features that are unlike any that a human designer would ever think to employ.
"Blind" random evolution outperformed all human professionals. And this is hardly a unique example. Hell, it wasn't even unique in the very same study. The same researchers, again using evolution, also produced *two* distinct patentable improvements in PID controllers (used in a myriad applications): 1) a new set of PID tuning rules which outperform the 1995 human=designed standards, and 2) Not one but *three* different controller circuit topologies which outperform existing PID controllers. They've already filed a patent application.
Another team using evolution as a creative force derived a suite of algorithms for quantum computers, several of which solve problems better than any previously published (i.e. human-designed) algorithm.
Evolution *works*. Deal with it. Or continue to live in denial if you wish.
How long do you think it would take to randomly generate the string "echo 'Hello World'"?
By pure hit-and-miss? Quite a while. But since that's *not* how evolutionary results are produced, you have a straw man on your hands there.
A more interesting (and relevant) question is how long would it take an arbitrary computer program to evolve into one that produced a "Hello World" output, if it were iteratively reproduced (with occasional mutations, i.e. copy errors), and during each "generation" the odds of an individual program variation's likelihood of being copied were dependent upon how closely its output (if any) managed to match a "Hello World" string.
By *that* method (which is truly meets the requirements of an evolutionary process), you'd most likely get a successful result before you finished your coffee break.
How do I know this? Because unlike you, I base my views on actual hands-on experiment and testing, not unsupported armchair declarations.
I have used evolutionary algorithms to achieve success in more applications than I can recall to count, including a number where program code itself was the "genetic code" being evolutionarily altered.
Perhaps the most relevant one to the scenario you raise is the time the "environment" was a virtual machine memory space in which independent programs would all reside and run simultaneously (today this would be called "multithreading"). The memory space was initially seeded with a single simplistic program which did nothing more than pick a random memory block and copy its own code bytes to that block and initiate execution of the copy as a new program thread. This was such a simple program that it took only about 12 machine instructions.
So the initial program would copy itself into two copies, and those two copies would each copy themselves again so there would be 4, etc. etc. Before long the copies would start stomping on other copies, causing a bunch to crash, but no matter, as more "original" copies were always being spawned.
Pretty boring, eh?
But there was a catch. The virtual machine the program(s) were running on wasn't perfect. Each machine instruction had a small chance of screwing up. A test-and-branch operation had a tiny chance of failing to branch when it should, or branching when it shouldn't. A copy-byte operation had a tiny chance of randomly mangling the byte it was copying (or not copying at all). And so on. So each program had a decent chance of running properly, but also had a small chance of fumbling, and many of the fumbles would inevitably produce a self-copy that was, all together now, "mutated".
Now, it's perfectly true that most of the mutated copies crashed and burned. But because they did, it wasn't long before they were "removed from the gene pool", since they failed to copy themselves, and eventually they got overwritten by some other more successful program version writing a copy of itself over that memory location.
Successful copies, though, or copies that had a "mutation" that were either neutral (didn't affect the overall results of the program) or by luck beneficial (improved the overall results of the program) would continue to reproduce themselves.
And it should be easy to predict that the ones which had the lucky improvements, no matter how rare those were, would quickly spread across the memory space making even more copies of themselves, at a faster rate than the less "evolved" programs. They would eventually shoulder out the less efficient programs. And the next time a lucky improvement occurred, it would build upon the earlier one(s).
And, just as one would expect (at least, if one weren't so blindly dogmatic as to keep declaring against all evidence and common sense that evolution "can't" actually work), that's exactly what happened.
But the results were even more interesting than that.
I let the "population" run overnight. I forget how many "generations" that was, but it wasn't a truly huge number -- this was back on an *original* IBM PC, at 4.77MhZ. And the memory space was only 640K (total), so there wasn't a lot of room for a huge "population" anyway.
And yet, you'd be amazed at what happened:
1. Multiple "species" evolved -- different "styles" of programs which ended up doing their "reproduce myself" job in radically different ways from each other. In fact, it would be more accurate to say that they were different "phyla".
2. "Predator/prey" relationships had evolved, whereby some of the programs had transitioned from just minding their own business and copying themselves to actively seeking out "competing" programs and "killing" them by copying data into their source code.
3. "Viruses" had evolved. Some programs had streamlined themselves (for speed advantage) and relied on using the copy loop code of *other* programs in order to copy their *own* program code.
4. "Symbiosis" had evolved. Some programs had developed the strategy of "piggybacking" themselves on the front of other programs and causing them to copy the "symbiote" (or would that be "parasite"?) along with that program's own program code.
5. Even the programs that were still taking the direct route and just copying themselves had several types of interesting improvements, including loop streamlining (i.e., more efficient coding than original), overlapping code function (where a sequence of code instructions was executed more than once, for two (or more) different purposes), and so on.
6. The code in some of the "species" bore absolutely no resemblance to the original "seed". They had somehow managed to totally replace the original program with something quite different, in a step-wise fashion, without ever having lost the ability to "reproduce" along their evolutionary path. Hey, I thought the creationists said that was wildly implausible?
7. Most of the programs had varying amounts of "junk DNA" -- random bytes of unexecuted garbage that, by virtue of position or program function, didn't harm (or affect in any way) the results of the program. And, which "species" shared which random "junk" sequences was a clear clue as to which had evolved from recent "common ancestors". Hmm, just like biological DNA...
8. All of this resulted without any human (or other intelligent) interaction at all. The program space had simply a) an initial simple replicator, b) variation through random error, and c) reproductive competition. Period. And yet, those three seemingly trivial factors were all that was required to produce a dazzling array of novel working programs and strategies, and much increased complexity and information content. Through evolution.
So when you express doubt that evolution could ever produce even a "Hello World" output, excuse me for pointing out that you really have no idea what you're talking about.
If it was easy, then passwords would be worthless.
Password entry interfaces are purposely designed to prevent "partial" solutions from achieving "partial" success, specifically so that evolutionary methods (either automatic, or manual) can not be employed to crack the password.
Leave creation to the professionals guys.
I *am* a professional, so I appreciate the vote of confidence.
Even God has to say: "Let there be..."
If you believe that, then you're declaring that he's more limited in the ways that he can bring things about than even human programmers are. Are you sure you want to go there?