Subject: Re: looking for a language with any of the following 4 charachteristics  (all 4 would be nice).
From: Erik Naggum <>
Date: Tue, 12 Feb 2002 22:16:14 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* Eric Moss <>
| Addressing the parentheses phobia, which I see in other students in my AI
| course, I say several things.

  I wonder if it is the parentheses or the enclosing delimiter.  For some
  time, now, I have been trying to understand how people react to Lisp, and
  something occurred to me some tima ago that was recently reinforced.  In
  almost all other programming languages, parentheses are actually painful,
  or symptoms of something painful.  E.g., in those stupid infix syntaxes,
  you need parentheses when the precedences of the operators you want to
  combine are not related the way you want them to be.  So the parentheses
  become a means of resolving a conflict between the language and your
  needs.  In C-style languages, where type casts are necessary due to the
  retarded type system, parentheses are used to resolve a conflict between
  what the language thinks should be the type of something and what you
  want it to be.  The number of parentheses thus correlate with the level
  of complexity, and the level of complexity with how hard it is to grasp.
  The only "neutral" parentheses are those used in function calls.  The
  rest of the delimiters serve different purposes and also look different.

  However, in (Common) Lisp, parentheses are the only game in town (well,
  this is not true, but to the extent they are, bear with me), and all the
  emotionsl responses to parentheses-as-pain-indicators from languages that
  the programmer may have been previously exposed to come right back at him
  at a very low level of consciousness.  Any thinking person would observe
  his reaction and think about it, but thinking peopla are never a problem.
  Those who only react and feel that something must be wrong with all the
  parentheses, may have a very particular reaction to parentheses.  I have
  had occasion to exploit this recently to test the hypothesis.

  < and > are accetable delimiters these days, so I changed the reader and
  printer to use them instead of ( and ).  (The only practical problem was
  that symbols with < and > in them needed to have that character escaped.)
  Presented to two people who had previously been negative to Lisp, one of
  them thought it was OK, now, the other went "you can't trick me into
  liking Lisp".  Presented to three people who were predicted to have a
  strong dislike of parentheses, but had not had prior exposure to Lisp,
  all three found it interesting, and one thought the parentheses of the
  original code looked silly when presented with it -- the others quickly
  figured out what the point of the exercise was, but did not react with
  hostility to the parentheses.  I found only one person whom I thought
  would not be hostile to parentheses, but he was hostile to all the HTML
  crap, instead, effectively being more annoyed with <> than with ().
  This, of course, serves no useful statistical purposes, but I do not want
  to run a research project on this.  I would like to experiment with
  working with this syntax for a while just to see how I think it works,
  however.  It might actually be the easiest way to get around the
  parenthesis "perception problem".

///                                                             2002-02-12
  In a fight against something, the fight has value, victory has none.
  In a fight for something, the fight is a loss, victory merely relief.