Words

The problem of whether a LISP program actually has a creator has always been a difficult one. In these days, it is especially problematic, due to the fact that LISP programs are harder and harder to find. Nevertheless, people have always thought that a LISP program must have a creator.

From a scientific point of view, it is easy to see why no LISP program has a programmer, and I intend to show this to you.

Section 2: The common proofs debunked

There have been several attempts at proving the existence of LISP programmers. However, these have suffered from a serious lack of standardization. Nobody could actually say what this LISP programmer is or how he looks like. In the end, through considerable effort, most partisans of the LISP programmer theory have reached a common conclusion:

• The LISP programmer is simple, without composition of parts, such as body and soul, or matter and form. Nevertheless, the LISP programmer is likely to take the shape of a parenthesis, should he incarnate.
• The LISP programmer is perfect, lacking nothing, and is completely distinguished from other beings.
• The LISP programmer is infinite. That is, he is not finite in the ways that created programs are physically or technically limited.
• The LISP programmer is immutable, incapable of change on his essence and character.
• The LISP programmer is one, without diversification. His essence is the same as his existence. However, despite being a single entity, he does have several persons belonging to the same being.

There have been several ways these people have tried to demonstrate the existence of this LISP programmer. However, it is obvious that they have erred. Listed below are the most common proofs they have cited.

The Cosmological argument is based on the assumption that there is a root cause of the LISP program, based on a simple reasoning. Every finite and contingent being has a cause. However, nothing finite and contingent can cause itself, and, furthermore, a causal chain cannot be of infinite length. Therefore, there must be a first cause — something that is not an effect.

This is clearly a logical fallacy. First of all, even if we accept the existence of this first cause, there is absolutely no proof that it is a programmer. Considering the time elapsed from the Big Bang, a randomly-wired neural network could have produced exactly the same result. In addition to this, those who accept this argument are clearly not familiar with many LISP concepts, such as higher-order functions. There is no obvious reason for which a LISP program could not have been simply the output of a LISP function, or the expansion of a macro. Furthermore, considering the way LISP compilers expand tail recursions, a LISP program may well have an end, but technically speaking, if an apropriate exit condition has not been defined, it may not have a beginning.

The Teleological argument is based on the idea that a LISP program is too complex to have been written by itself — and thus required a programmer. This is obviously the reasoning of someone who hasn’t seen LISP code.

First of all, LISP code is very simple and very short. It would be understandable to assert that Java programs need a programmer, but not with a LISP program. In addition, programmers are known to be very delicate about their code. No programmer would want to use all those parenthesis.

Some other theoreticians have tried to move the argument towards a more scientific, history-based discussion field. For instance, many people have recognized a LISP programmer’s intervention in their life. In fact, most AI students at MIT are known to be very respectful of the LISP programmer. However, there is no direct proof that they are not inventing everything.

Section 3: Arguments against

With all these myths debunked, I would like to make a few more points.

First of all, although every LISP book mentions a LISP programmer, these books are known to contradict themselves. In fact, the LISP implementations vary to such a degree that it is impossible to expect anyone to have written them in the first place. It is an accepted scientific fact that they have all evolved from a common, archaic ancestor that only had one function — CONS — to the shapes we know today. They have evolved like any other LISP program.

An interesting point this brings up is the problem of the perfection. Those who consider that LISP programmers exist also consider him to be perfect. This would mean that their programs should not have bugs, but for fsck’s sake, we all know this is not real.

Speaking of fsck, there is also the problem of evil (i.e. fsck). If the LISP programmer is perfect, why did he allow such imperfect tools like GUIs, BASIC, PHP and Web 2.0 to appear?

It is clear that there are no LISP programmers. LISP programs simply evolve. It is the nature of all things. The LISP programmer is not a being — it is the expression of LISP’s laws.