🚀 go-pugleaf

In article <GATELEY.91Jun26150215@gefion.rice.edu>, gateley@rice.edu (John Gateley) writes:
 
> ...There are many features which require a different mindset:
> recursion instead of loops, first class functions, dynamic typing,
> macros etc. etc. etc. Among all these new features, I think the
> problem of learning an extremely simple syntax is the smallest of the
> challenge. The syntax is very regular, has very few special
> characters, and can be learned quickly. 

That's true.  Learning the rules of Lisp syntax is easy.  But there are
two reasons why that doesn't make it easy to read:

#1 is that you're talking about consciously learning
the rules and consciously parsing things.  But Lisp syntax doesn't 
transfer easily to the unconscious.

#2 is that what other languages do with syntax, lisp does with special 
keywords, like defun, lambda, cond, let, prog, loopxxx... I don't know
the exact words, but they all have special structural meanings and
special treatments of certain arguments.  Learning all the special
forms and their argument forms takes longer than just learning to
balance parens.  And still your eyes can't learn it very well.

> I bet that all the people who are bothered by it are much more
> bothered by some of the other features (which are semantic features).

Well, I for one LOVE the semantics of Scheme and dislike the syntax.

> And, a lot of the problem here is being faced with something "new".

That may be for some people.  I've known about Lisp for a long time,
so I don't have a new user's point of view.  But I don't think the 
semantics are that different from other languages, just more consistent.  
I still think syntax is what puts off most of the people who are put off.

> ...I do most of my code reading on a terminal in an emacs buffer so that 
> I can use all the commands when needed. I very rarely print out Scheme 
> code and look at it on paper.

This sounds like a REAL INTERESTING point.  Do you mean you use the
editor to step between arguments and to find matching parens?  If so,
you're FEELING your way, or maybe more like WALKING, around the code--
in any case, something kinesthetic is going on...COOL!  But notice how
it's like groping in the dark (in a well-labeled, tree-structured space, 
(wasn't that a short story by Hemingway?) I grant you).  In other words, 
Lisp syntax is no help to your EYES, but with emacs as a CANE...  This 
probably has some great implications for user interfaces for blind people!

--Steve