Code, constraints, and creation

It is hard to look at living things and not be struck by how much information is packed into them. DNA is routinely described as a code, a set of instructions that tells a cell how to grow, repair itself, and pass those instructions on. Evolutionary theory says that this code, and the living machinery built from it, came about through random genetic changes filtered by natural selection over vast stretches of time. I have been wanting to write about this for a while, because once you set that claim next to how information systems actually work, the comparison is not as friendly to the standard story as people assume.

Both computer software and DNA depend on precise syntax. A program does not run because the bits are “mostly right.” It runs because the instructions are structured. The same is true of a living cell. Random change is not a mysterious creative force in either case. It is noise.

Imagine taking a working program and introducing random typos into its code, then keeping only the versions that still launch. You might get a trivial variation through. The background of a window might change from blue to red. A menu item might shift by a pixel. That is the kind of change people point to when they talk about variation we can actually observe. It stays inside the existing program. The program is still a word processor. It has not become a spreadsheet. It has not become an operating system.

Leave the same process running long enough, and the usual result is not new function. It is a crash. One error in the wrong place is enough to halt the program. After that there is nothing left for selection to work on. Code is rigid in that way. The more tightly specified the system, the less room there is for lucky accidents to invent a new architecture.

This is where the jump from small variation to large-scale evolution starts to look like a leap rather than a measured inference. We do see limited change within kinds of organisms, just as a program can absorb a few superficial edits and still run. That is not in dispute. What does not follow is that those small edits, stacked over time, will cross the boundary into an entirely different kind of system. A color change does not write a new application. A few surviving mutations do not write a new body plan, a new organ system, or a new coded language.

A proud theory treats that gap as a detail. It assumes that if a little change is possible, then endless upward change must also be possible, given enough years. That is not how information works in any field we can actually test. Selection can keep what already functions. It cannot invent the syntax, the error-checking, the coordinated parts, and the purpose that a working program requires. Those things come from a mind that knows what the finished system is supposed to do.

A humble look at the same facts is simpler. Complex coded systems do not write themselves. The software we use every day required programmers who planned, tested, and constrained the design. The far denser code inside living things points in the same direction. Random change hits a wall. Intention, foresight, and a creator do not.