🚀 go-pugleaf

David Gudeman:
   How can you say that syntax is unimportant when such a huge
   percentage of people who try lisp or scheme are turned off by the
   syntax?  It is certainly important to them.  It is a hindrance to
   the goal of getting more people to use the language, and it is a
   distraction for many people trying to use the language.

   Any language feature that is unpalatable to large numbers of people
   is a misfeature.  And calling it "relatively unimportant" isn't
   going to make it any less important to the people who are bothered
   by it.

I don't think that syntax is the big issue for people who don't like
lisp or scheme.  The big issues are more along the line of lack of
decent reference works (something like the old MAC-Lisp manual would
be nice -- very complete, to the point, and cheap).

-- 
Raul <rockwell@socrates.umd.edu>

In a recent article David Gudeman writes:

  Any language feature that is unpalatable to large numbers of people is
  a misfeature.  And calling it "relatively unimportant" isn't going to
  make it any less important to the people who are bothered by it.  If
  you don't think a lot of people are seriously bothered by lisp syntax
  then you are mistaken.

The CAD Framework Initiative is in the process of standardizing on
Scheme as an extension language for CAD system use.  In deciding to use
Scheme, it was critical to the process that we separate the language
semantics from the syntax.  

A proposal which did not state categorically that a "C-like or
shell-like" syntax overlay will be defined and made part of the standard
was shot down two months ago.  Last week, after rewriting the proposal
to clearly state our committment to dealing with the syntax issue,
Scheme was approved by the Architecture Technical Subcommittee by 24
votes to none (2 abstentions recorded).

The reason for this was that there was clear agreement on the semantic
richness of Scheme, and clear agreement that the normal Scheme syntax
would be difficult to sell to the bulk of the user community.  Hence our
compromise.  

As the chairperson of the Extension Language Working Group, I am very
happy with this solution.  Personally, I'm happy to write Lisp.
However, what I really want is the semantic richness of Scheme, coupled
with whatever it takes to make the language successful.

I believe that's what we're getting, and I think this is an important
point in the life of the Lisp family of languages, because in a sense it
brings them into the main stream.  When Scheme implementations (with or
without alternate syntax) are widely available, providing extensibility
to interactive applications, the number of people writing Lisp, (whether
they realize it or not) will increase dramatically.
--
   /		   /    Manager, Framework Technology - Cadence Design Systems
 -/-  o		  /__  ___  __	___  ___  ___           555 River Oaks Parkway
 /   / /\  /\	 /  / ___/ /   /  / /__/ /__                San Jose, CA 95134
/__ / /	 \/  \  /__/ /__/ /   /  / /__  ___/ barnes@cadence.com (408) 944 7222

In article <4582@optima.cs.arizona.edu> gudeman@cs.arizona.edu (David Gudeman) writes:

   In article  <GATELEY.91Jun25134644@gefion.rice.edu> John Gateley writes:
   ]
   ]I mean that syntax is relatively unimportant.

   How can you say that syntax is unimportant when such a huge percentage
   of people who try lisp or scheme are turned off by the syntax?  It is
   certainly important to them.  It is a hindrance to the goal of getting
   more people to use the language, and it is a distraction for many
   people trying to use the language.  Just because it isn't a problem
   for _you_ doesn't mean that it isn't a problem.

Let me try and explain what I mean :^) and at the same time reinforce
what a couple of later posts have already said. Many people don't like
Lisp/Scheme true, but to blame it all or even majorly on the syntax is
unfair. 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. With a small amount of
practice (and EVERY language requires a small amount, or more) the
programs become understand, and those nasty little parens cease to be
nasty.

   Any language feature that is unpalatable to large numbers of people is
   a misfeature.  And calling it "relatively unimportant" isn't going to
   make it any less important to the people who are bothered by it.  If
   you don't think a lot of people are seriously bothered by lisp syntax
   then you are mistaken.

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).
And, a lot of the problem here is being faced with something "new".
For example, I put off learning emacs for the longest time, just
because I hate learning new editors. Different commands, different
styles etc. But, once I did, I really enjoyed it. Similarly
Scheme/Lisp is something new to most people, and all it takes are a
couple of changes to make them frustrated and go back to the old way
of doing it.

   By the way, fancy editors may make it easier to balance parens when
   writing lisp, but they don't help much in reading it.

I disagree VERY much with this statement. 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.

John
gateley@rice.edu
--
"I've thought the thoughts of little children and the thoughts of men
 I've thought the thoughts of stupid people who have never been
 so much in love as they should be and got confused too easily
 to fall in love again." The Residents and Renaldo and the Loaf

In article <ROCKWELL.91Jun26084802@socrates.umd.edu>, rockwell@socrates.umd.edu (Raul Rockwell) writes:
 
> I don't think that syntax is the big issue for people who don't like
> lisp or scheme.  

For people who want a Scheme-like language, but don't like Scheme, like
me, the main reason is probably the syntax.

> The big issues are more along the line of lack of decent reference works...

Last Scheme manual (PC Scheme from TI) seemed pretty complete to me.

--Steve

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

In article <602@smds.UUCP> sw@smds.UUCP (Stephen E. Witham) writes:

(hopefully not taken too much out of context).
   But Lisp syntax doesn't transfer easily to the unconscious.
   And still your eyes can't learn it very well.
I would be interested in some data backing up these assertions. At
this point it is just you and I saying "no you cant! yes you can!".
Unfortunately I don't have any data backing up my assertions other
than I have helped teach scheme for several years, as well as
programming in it, and have not noticed the things you are describing.

   I write:
   > ...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!

I think you are taking my point slightly incorrectly. Suppose you are
programming in language X, and have a big huge function (several
pages, full of nested loops etc.). Can your eyes parse it? I use the
editor to help me with cases like that, and to make sure that parens
balance. I do not consider myself "feeling my way". I have a good tool
and I use it.

j

--
"I've thought the thoughts of little children and the thoughts of men
 I've thought the thoughts of stupid people who have never been
 so much in love as they should be and got confused too easily
 to fall in love again." The Residents and Renaldo and the Loaf