Xref: utzoo comp.lang.lisp:3629 comp.lang.scheme:1656
Path: utzoo!utgpu!news-server.csri.toronto.edu!cs.utexas.edu!uunet!mcsun!ukc!edcastle!aiai!jeff
From: jeff@aiai.ed.ac.uk (Jeff Dalton)
Newsgroups: comp.lang.lisp,comp.lang.scheme
Subject: Re: Virtues of Lisp syntax
Message-ID: <3407@skye.ed.ac.uk>
Date: 12 Sep 90 19:00:53 GMT
References: <1990Aug26.205018.18067@cbnewsc.att.com> <1350028@otter.hpl.hp.com> <3368@skye.ed.ac.uk> <SODER.90Sep11141859@basm.nmpcad.se>
Reply-To: jeff@aiai.UUCP (Jeff Dalton)
Organization: AIAI, University of Edinburgh, Scotland
Lines: 64

In article <SODER.90Sep11141859@basm.nmpcad.se> soder@nmpcad.se (Hakan Soderstrom) writes:
>The syntax of Lisp is about the same as the syntax of
>Assembler: it doesn't exactly stop you from doing what you
>want, but it doesn't help either.  Almost all kinds of errors
>appear as run time errors.

Actually, Lisp syntax does help many people to do what they want.
It's certainly much more helpful than assembler.  Maybe it doesn't
help *you* to do what you want, but so what?  No one ever claimed
Lisp was the answer to all problems.

Of course people who think run-time checking is the worst of all
possible sins won't like Lisp.  Those people would do well to use
another language instead.  ML is a good choice if they want most
of the type work done for them.

>Jeff Dalton writes,
>
>>My view is just the opposite.  It's fortunate that a readable
>>external syntax can correspond so closely to a flexible, easily
>>manipulated data structure.
>
>Yes, this is the crux of the matter. It also means that the
>syntax is a compromise between machine readability and human
>readability. 

That's exactly what it doesn't mean.  In order to be a compromise it
would have to be worse for humans (as compared to other programming
languages -- because every programming language makes such compromises
to some extent) in order to be better for machines.  

But, as I pointed out before, (many) Lisp programmers don't regard it
as worse for humans: they prefer it to the more Algol-like syntaxes.
Critics of Lisp's syntax consistently ignore this point and suppose
that the syntax must be a cost rather than a benefit.

Of course, some people who dislike Lisp syntax may also happen to
think the syntax is good for machines.  But it's only because they
prefer the syntax of other programming languages that they see Lisp as
making a greater compromise.  And different preferences are just what
we expect on questions of syntax.  Different people prefer different
things.  It might be nice if everyone preferred the same syntax, but
it isn't so.

In any case, the idea that Lisp is more of a compromise than other
languages seems rather bizarre.  It may seem plausible (to some) if
we restrict ourselves to syntax.  But Lisp is notorious for being
unsuited to "conventional" machines.  (Before anyone flames me,
let me point out that I think Lisp can be implemented effectively
on conventional machines.  Nonetheless, it has a reputation that
is not entirely unjustified.)

>Because it was designed in the 60's, there is a
>bias towards machine readability. You help the compiler
>build its data structure.

There might be something to this if it weren't the case that
other languages designed at about the same time, such as FORTRAN
and Algol 60, didn't show the same "bias".

In any case, you're confusing the origin of Lisp syntax with
the question of whether it really is readable.

-- Jeff