[AUTHOR’S NOTE: Another in the series of articles explaining how evolution theory requires luck or intent in order to be reconciled with existential science knowledge and current understanding. The original content has been reformatted and lightly edited to make it easier to read.]
DNA: the ultimate source code
In my writings as Atlanta Creationism Examiner, I have never pretended to be a scientist. On the other hand, for two decades I wrote computer software for a living, so I am considered an expert by many in the field of software development and application programming.
In college I was taught “Computer Science”, called Management Information Systems in Business school, but I never really considered programming software a “science.” Science seems to take place most often in an ivory tower paid for by government grant.
By the same token, I saw very little management of information systems in the real world. Our code more behaved like electronic assistants to help do a job as opposed to decision makers who told you how.
If there’s any one thing that I know about computer software that will always be true, it’s that you cannot guess what will happen inside the machine simply be reading its source code. If something is in code, it is a form of software. That means it has been designed.
Look, I know how software works; I have created applications that remains in use today, years after leaving the business. I know the computer is no smarter than its programmer.
I wrote banking software, translation tools, financial applications, email service providers and user interfaces in languages called Basic, Pascal, and Visual C++.
Depending on where you bank or shop, you might deposit your paycheck or buy a tennis racquet using code I wrote. You may swipe your credit card and answer a question I posed: credit or debit, or “electronic benefits transfer?” (a quaint euphemism for food stamps) At various points in my career, I was considered quite good at my job. Often, I got more credit than I deserved.
My boss thought it ingenious to see how I learned to reuse code by making it more generic in function, but I always considered myself something of a slacker. I wasn’t being economical as much as I hated writing the same block of code more than once. Why reinvent the wheel?
Code is always written in a form of extreme punctuation-specific “pidgin” English. It gets translated by a compiler into machine language, an unintelligible stream of zeroes and ones. An essential tool of any software developer is called a debugger. It is software that allows the programmer to follow the code instructions line-by-line, looking for errors called software “bugs.” The term originated with the first computer malfunction, literally caused by a flying insect.
More than once dubbed a “Subject Matter Expert”, I was sent to teach others how to use our application products to develop customized solutions.
It’s never hurt my potential for success as a public speaker that, as my wife has said, I can talk the bark off a tree. I had geek street credentials. Once I got “marooned” in Australia for almost six months. I got paid to watch a tennis tournament. It was a tough life, but somebody had to do it.
Paid to travel the world on an expense account just to play the hero when something broke…is this a great country, or what? Life is good. Those t-shirts aren’t lying.
When we write software code, expecting it to perform a specific task and produce work to our benefit. Sometimes unanticipated consequences arise from our best conceived plans. We fail to account for bad data introduced by operator error or otherwise flawed input.
Garbage in, garbage out. Best laid plans of mice and men, you know? Simply reading through the “pidgin” English of software language does not explain why the software broke. Was the code fault tolerant in the sense it handled the exception properly? You have to be able see a problem happen to know where things began to go wrong. It could be as simple as a comma used instead of a semi-colon or a misplaced parenthesis.
The wrong value could be stuffed into a variable or the wrong variable could be used by mistake in equation. It’s extraordinarily difficult to write a thousand lines of source code without making a single mistake. Software code should be elegant, meaning as few instructions as possible should be used.
Keep It Simple, Stupid – the KISS principle.
By building simple blocks of code into procedures and functions, source may be reused by multiple processes, even crossing application boundaries by the inclusion of dynamic linked libraries (DLLs).
The most evolutionary software development tool in my repertoire for about half of my career was C++, a development language that used inheritance to share code attributes between objects.
Ironically, we really did create and deploy objects using descent with modification. I may not be a scientist or a geneticist and certainly, I’m no expert on DNA. But I do know quite a bit about designing, writing, and debugging software code to solve real problems. Slinging code is not easy. To be more precise, it’s not easy to do well. One of the few things I know about DNA is that 3 billion lines of code, or instructions, are programmed within a single living cell.
That’s a lot of information crammed into a microscopic object. No human programmer who ever lived has come up with a comparable design. It’s a miracle that two people were able to figure out how DNA works. We owe a debt to Crick and Watson. Simultaneously, the code is incredibly simple and complex. DNA is so simple, it contains only four nucleotides: adenine, guanine, cytosine, and thymine. Recombined into different sequences, these four building blocks can create any living organism on Earth. We aren’t sure how it happens but if the order of gene sequencing is scrambled, the result seems to be a completely different organism.
From information culled from one cell, scientists can tell if it was a liver or a brain cell. They can tell if it came from a primate or a human. They can tell you exactly which human body produced that one cell, out of several billion on the planet. All done from the DNA instructions found in one living cell.
Computers are only half as complex as DNA – instead of four variables, you only get a zero or a one. No computer expert on the planet can read a thousand lines of source code and predict every conceivable outcome with both valid and invalid input. How can any human on earth read 3 billion instructions in a single strand of DNA and without testing be able to tell what purpose each individual nucleotide serves?
It’s a pretty impressive partial list when you consider organisms to which this “law” of simple DNA recombination applies: alligator, ape, boa constrictor, centipede, daffodil, elephant, flounder, giraffe, hippopotamus, iguana, jackal, kangaroo, lemur, moose, newt, oak tree, penguin, Quaker, rooster, salamander, worm, and zebra.
The one common denominator between each of these disparate life forms is DNA. In my years of experience, I never encountered code that wrote itself except by using code generation tools.
I helped write a code generation tool once. An (arguably) intelligent designer exists somewhere behind every piece of source code in existence. I felt obligated to qualify “intelligent designer” because I lumped humans together with God.
I’m quite sure that God is intelligent, but sometimes I question the wisdom my fellow man. Frequently I question my own intelligence.
No human is qualified to question the intelligence of the only true Creator, the designer of DNA. Humans don’t really know how to make anything from scratch.
[Author’s Addendum: Since this article was originally published, I have confessed to being rather impressed by the 3D printer, but that output still doesn’t compare to a living organism.]
[Final Word: The lecture by Dr. James Tour that specify the problems with assuming a purely “natural” origin of life are quite convincingly presented in this lecture video.]