Now it all makes sense.

Apparently, the trend for all computer languages is to approximate Lisp. And, at least today, Ruby is as close as you can get without having to use recursively nested parentheses.

The interesting thing about Lisp is that is was designed to be notation rather an actual programming language. Lisp was intended to be a systematic way in which you can describe a Turing Machine. In other words, it was meant for communication, specifically, from one human to another human, and was not just meant to tell a CPU how to spin its registers.

While people talk about the elegance of lists of lists (and it is elegant in its way), what I find most intriguing about Lisp is its human language aspect.

One can argue that perhaps car and cdr are not the most transparent things in the world, but I think it’s not for nothing that Lisp is associated with AI in the minds of we who have a bare inkling of it. In truth, the most I have ever been exposed to Lisp is random dabblings in Scheme, and my time spent screwing around with Logo.

With Logo, the language aspect thing always intrigued me. Like I mentioned, I had long been interested in writing a text adventure game—interactive fiction. And parsing of natural language is one of the things that lists of lists are good for handling. But it ended up way beyond what my 8 year old brain could handle, so I moved onto procedural languages, which were easier to grok.

And interestingly, the whole thing with the Lines of Code issue is not necessarily LoC per se, nor is it even necessarily complexity. The issue is what I would call semantic density, and it’s related to the sociolinguistic concept of context-dependence.

This is the difference between languages like Ruby and Perl versus Assembly/C/Java, and it is related to the difference between Mandarin Chinese and English.

The thing to remember is that, while most people just think of a programming language as a way to tell the CPU what to do, in reality, it is just as important as a way to communicate your intent and your formulation of concepts to whoever else might have to maintain your code.

Particularly in this post-modern world, where everything worth doing has already been done, and all the clever algorithms have already been formulated, trying to re-invent the wheel is an exercise in futility.

This is probably why Lisp has such appeal. Ultimately, it is a human language for talking about computer algorithms. This is where it gets a lot of its power: it leverages the existing language of mathematics.