Let me make this absolutely clear up front, I love Lisp syntax, and
think it is the best syntax for a variety of reasons. I won't
enumerate the reasons here (I've done so in another article) except to
say that having programs represented like data and having the language
able to manipulate the programs at runtime is a whole order of
magnitude more powerful and expressive than any other language syntax
I've ever used.
Additionally, I would never want to change Lisp's syntax except for
the following. I program a lot in the commercial world. Virtually
every programmer I've ever worked with hates Lisp because of the
syntax - the parenthesis. I unsuccessfully argue that Lisp syntax is
no easier or harder than any other language _once you get used to it_.
If you started out programming in Pascal, C, Java, C#, etc., of course
Lisp will initially look strange but once you get used to Lisp's
parenthesis I don't believe it is any harder than any other syntax.
In fact, I'd argue that once you get used to Lisp's syntax, it turns
out to be easier because we don't have one syntax for function
definitions, one for type definitions, one for structures, etc. Lisp
has only one syntax. But I digress...
What I am interested in doing is creating C/Java/C# like (Algol)
syntax for Lisp as I describe below. Dylan originally and elegantly
used a lisp syntax. It was later changed to an Algol syntax for the
only reason of making it appeal to mainstream programmers. The
original intent was to change syntax's but keep it compatible and
interchangeable with its original lisp syntax. Of course, semantics
were to remain the same. So, for instance, the "if" function would
return a value - something unusual in a typical Algol language. The
Dylan team failed in this attempt for totally political reasons and
not technical reasons (based on communications I had with someone
closely involved). By "failed" I mean that they lost interest in and
ability to _interchange_ the language syntax with its original Lisp
roots. They, somewhat arbitrarily, made changes to the system without
regard to continued backward compatibility.
I'd like to create an Algol-like syntax for Common Lisp. The syntax
and semantics would always remain compatible with Lisp. The program
would be written in Common Lisp. It would read in the new syntax and
output Common Lisp (the first converter).
I'd also like to have the ability to read in Lisp and output the new
syntax so that new syntax programmers would feel comfortable with code
written in Lisp syntax (the second converter).
Starting with something similar to Dylan would probably be a good
idea since this is what they originally intended and a lot of thought
was initially given in this area.
Doing this would make the system very portable. Any Common Lisp
system would be able to compile the converters. Once the language
converters (in both directions) were compiled new syntax code would be
able to be converted to Common Lisp and compiled or used by the native
Common Lisp system.
Now the reason for all this is several fold as follows:
1. Mainstream programmers would better entertain the use of such a
"new" language since it'll look familiar to them.
2. Lisp programmers would be able to code in native Common Lisp in a
mainstream world since the other programmers would see it in their
(Algol) syntax (using the second converter).
3. Existing Common Lisp environments could be used so no new compilers
would need to be built.
4. The mainstream programmers (after using the system for a while)
would slowly begin to discover the beautiful and powerful advantages
of a lisp environment (such as macros). This would really help the
language catch on.
5. Ultimately, this would create the possibility of getting more
mainstream programmers to take Lisp more seriously and start using
true lisp.
Now, knowing Lisp, a lot of this has probably already been done but I
don't know anything about it. Does anyone know about other similar
projects?
Secondly, is anyone interested in such a project?
Thanks for your time.
Blake McBride
blake@[EMAIL PROTECTED]
|
