Subject: Re: RFC: Lisp/Scheme with less parentheses through Python-like     significant  indentation?
From: Erik Naggum <>
Date: 2000/08/14
Newsgroups: comp.lang.lisp
Message-ID: <>

* Paul Fernhout <>
| She is willing to consider learning Lisp and has in the past
| expressed interest in it.  In this particular case, I would be doing
| all of the development, but there is always the issue of maintenance
| down the road.  While her approval is a factor, there is still an
| issue for myself with my own aproval of the language (versus say
| Python or Smalltalk or C or Delphi which I have all used for other
| projects).

  Instead of thinking of your partner like "someone else", I would
  suggest you think of her as a part of yourself, in that when you
  explain something to her, you realize that the common ground between
  you is a foundation for understanding your _own_ thinking so much
  better.  This will (in my experience) mean that even if that other
  person never maintains or even understands the actual _code_, it has
  been developed within a framework of understanding that will benefit
  it over its entire lifetime.

  This has nothing to do with the syntax of the language, of course.

| I think we all bring our prejudices to the table, although ideally
| we rise above them as you point out.

  I think the best we can with our prejudices is to be aware of them.
  If you think you can rise above them, it will be impossible for you
  to understand which prejudices you haven't risen above.

| There are many other factors -- familiarity, prefix notation,
| functional style, availability of libraries, availability of
| support, availability on specific platforms, availability of
| programmers (network effect), whether it fits into the Microsoft
| vision (ugh!), and so on. (This isn't meant to slam any particular
| Lisp implementation, as obviously many of them are quite complete in
| terms of libraries and support.)

  The factor that throws programmers from other languages most is none
  of those things.  The lack of familiarity between languages that are
  accepted is quite stunning.  However, human beings are, despite
  every effort of the user interface crowd to reduce us to clicking
  idiots, a species marked by its use of _language_, which means that
  we are naturally predisposed to feel a sense of similarity not in
  how words are strung together, but how they have a common root,
  heritage, etymology.  Look at how Indo-European words crop up
  everywhere, and how the recent discussion of the "rete" evolved!

  Lisp has a _lot_ of words that are foreign to the C/Algol crowd, and
  the words we have in common don't generally mean the same due to a
  wide disparity of conceptual heritage.  Suppose a language with a
  lot of useful features, but based in, say, Norwegian, were to be
  marketed in the predominantly English-speaking programming world.
  It could use as many braces and semicolons it could stand, but it
  still would feel foreign.

| Still, I feel the parentheses are the single worst adoption hurdle
| in a causal review, and are sort of symbolic of the language's
| acceptance difficulties.

  (Causal?  Casual?)  The parentheses are a sort of lithmus test of
  people's intelligence.  (This will insult about 5.5 billion people.)
  How well do you tolerate that some of your basic presumptions are
  violated?  Suppose you were ridiculed for writing from left to
  right.  Suppose you were ridiculed for using letters describing each
  language's pronunciation instead of universal symbols for concepts,
  however they were pronounced.  Suppose you were ridiculed for eating
  with knives and forks?  Suppose you were ridiculed for books with
  the text of their spine upside down when you lay it face up on your
  desk?  If you are the kind of person who is able to put yourself in
  a position where you _understand_ that what you take for granted is
  somebody else's belly laugh, my guess is you possess sufficient
  intelligence to become a good programmer, or scientist, or do any
  other highly intellectual work for that matter.  If you _can't_, and
  you obsess about certain trivia (which nobody are going to _change_
  regardless of how trivial it appears), don't program computers.

  Some would say that syntax is irrelevant.  It obviously isn't.  It's
  as stupid as saying it's irrelevant which way you write, and then go
  from there to write books with neat spirals of text on every page.
  The _arbitrary_ is very far from _irrelevant_.  I would venture that
  the arbitrary is among the most important aspects of human existence.

  Being able to accept whatever is arbitrarily chosen in whatever
  culture you deal with does seem to be an ability in short supply,
  but that doesn't mean those who can do it are _inferior_.  It's the
  other way around: Those who can't should shut the fuck up.

| They also satisfice -- looking for a solution they think is "good
| enough", hence "worse is better".

  Worse is better is really not about selecting good enough, but about
  making lazy choices -- whatever seems least expensive at each point,
  often confused with "most convenient".  What "wins" might not even
  be good enough, but may be marketed so as to have a bright future.
  People can't think long-term by themselves (people still smoke, for
  instance), but if they are presented with something that will look
  good years from now, they'll buy it, hook, line, and sinker.

| The reality is that programming is becoming more and more important
| to people's lives.

  This is a many-faceted truth with so much ambiguity that it is best
  not to state it.  Try with one of the individual facets.  Do people
  have problems that cannot be solved by existing software?  If so,
  why not?  Are they helped by languages like Visual Basic and C++?

| People do learn to program -- the issue is more, if they don't
| choose Lisp, why not?

  Because Lisp would actually solve their problems, and then they
  would've wasted all that time learning to program in it, and they
  would have to figure out the answer to "now, what?".  I'm serious.
  Don't give people what they want -- they'll simply hate you for it.

| And how can that be overcome?  Obviously, this issue may be much
| deeper than typography. Typography is just the only thing I can
| think to change with reasonable effort, while still preserving
| Lisp/Scheme's power and elegance.

  Perhaps it's time to have a belly laugh over the notion that users
  should program at the very detailed level that real programming
  requires?  Suppose you want to convert a bunch of pictures into
  icons.  Suppose you know how to do that with one picture: You click
  on the file, "drag" it over to the icon-generating program, then
  "drop" it there.  Repeat until thoroughly disgusted with the idiocy
  of the paradigm of direct manipulation.  (It doesn't matter whether
  you can select several files before dropping, obviously.)  Suppose
  instead you were able to communicate your actual _desire_ to the
  computer, in (gasp!) a _language_!  Not a programming language, but
  a language suitable to express goals and such.

| The major strong point of my proposal (IMHO) is that it makes a minor
| typographical change to the Lisp family language syntax, which might
| have some major potential benefits.

  It amazes me that you still think it's a minor typographical change.

| There obviously remain many challenges to programming well.

  You know, I don't think catering to the parenthophobic will make any
  difference at all.  C++ is popular.  It has the worst syntax of any
  real programming language so far.  It is only eclipsed by Perl.
  Reading the manual of VCRs is hopelessly beyond their users' grasp,
  yet they sell in great numbers and are considered useful.

| But why make it any harder than it has to be?

  I actually think programming both as a carreer and as a science
  suffer so much because it has been made easier than it has to be.
  Fiddling with superficial syntax indicates that the problems of
  acceptance are not where they should be.

  I think we need to figure out what the real problems are.  As long
  as we find that people come to Lisp of their own accord, and as long
  as we have reasonable success with that approach, there is very
  little to argue that we're doing something wrong.  I also don't
  think we're doing anything wrong because whatever _is_ being done
  wrong is not related to _which_ language people use, but rather what
  they expect to do, and have to do, in whichever language they choose.

  I appreciate the many glimmers of light this discussion has
  uncovered, but I'm still quite annoyed by what I consider a huge
  waste of time in fixing what isn't broken to begin with, but we have
  a long history on this newsgroup to have valuable discussions come
  up only when someone proposes something that everybody thinks is a
  dead end at the outset and get all upset about.  Nothing happens
  with the dead-end stuff, but the discussions are usually fruitful.

  If this is not what you expected, please alter your expectations.