[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: [Axiom-developer] A possiible "navigation" approach for Axiom "cryst

From: root
Subject: Re: [Axiom-developer] A possiible "navigation" approach for Axiom "crystal"
Date: Tue, 6 Apr 2004 22:38:23 -0400


This flame is not directed at you, Bill. You just managed to step on
my religious convictions at a time when I'm in a flaming mood.

/me mounts religious soapbox.....

I've looked at Python and, while it implements ideas that closely
resemble Lisp, it misses the essential point. The essential point
is that in Lisp the programs and the data are syntactically equivalent.
It is fundamental, yet often overlooked, that this equivalence exists.
In Lisp it is trivial to parse programs, just use (read). To do that
in Python you need much more machinery. Treating programs as data and
data as programs makes lisp unique. (In fact, there have been misguided
moves afoot to distinguish code from data in hardware.)

Axiom's power is premised on this ability. Boot was an attempt to
construct Python long before Python existed. Dick Jenks and I had
almost monthly debates about this. At one point I rewrote Axiom's
Boot layer in Lisp, which simplified the whole build process, and
got endless grief over it so I "unwrote" it. However, I do expect
the boot language to disappear if I ever get the free time.

Boot and Python are "Lisp without parens" as the advocates
like to paint it. Usually they make some "minor" distinctions like
there are no macros, or full closures don't work, or some such.
There have been dozens of these "Lisp without parens" languages.
They feel they've only added "syntactic sugar" to lisp.

The reason that Lisp syntax is important has to do with the notion
of "impedence matching" (e.g. hooking a soda straw to a fire hose).
The reason computer languages exist is to try to match your ideas
and thoughts to machine instructions. Obviously there is a big
impedence mismatch. 

Some languages, like assembler and C, are very close to the machine
and you need to bridge the gap. The upside is that you get very
efficient code. The downside is that there are many ways to mismatch.

Others languages are very close to what you want to write and you
don't have to work hard to make the match. The upside is that your
ideas are easy to express. The downsides are that (a) the language
limits what you can express and (b) the results may not be efficient.
Languages like Smalltalk are great if your idea can easily be expressed
as objects but fail badly if you want an efficient linked list.

Lisp is the only language I know that (a) is very close to the machine
(car and cdr are pointers) and (b) is very close to your thoughts.
Not only is there very little syntax to learn but you can mix high
level, idea-specific statements with low level pointer operations:
(devolve-semantic-network (car my-big-thing) (cdr my-other-thing))

So, given Lisp's self-describing, self-modifying, broad-impedence-matching
abilities you'll find that languages that try to be "lisp without parens"
like Boot and Python, miss the central characteristics.

There are yet more characteristics that get overlooked but you get the
idea. All of the good ideas in programming were first implemented in Lisp. 

/me crawls back under soapbox


reply via email to

[Prev in Thread] Current Thread [Next in Thread]