Subject: Re: Programming Style
From: Erik Naggum <>
Date: Wed, 08 Aug 2001 11:34:54 GMT
Newsgroups: comp.lang.lisp
Message-ID: <>

* "Wade Humeniuk" <>
> As a testament to what Duane said (I still remember vividly learning Lisp)
> you eventually do not even see the parens (except when you have to).  It
> takes some getting used to but your brain will eventually see the "code"
> automatically.  But you have to be patient and _let_ it happen.

  This is actually no different than any other language.  To what extent do
  C programmers _see_ its punctuation?  Commas, semicolons, braces, parens,
  brackets, etc, all convey meaning immediately without been obsessed about
  as such.  Getting them right can be a significant hurdle as you struggle
  with the syntax.  Once you stop seeing the & and instead think "address",
  you have got the hang of it.  Perl hackers have mastered this technique.
  The reason many people who have learned C prefer to continue on the C
  branch of evolution is that they found the process of learning all that
  syntax quite _painful_.  This is especially true for parentheses in C.
  You only need them in expressions that cross a fairly high complexity
  threshold and you can get rid of them by simplifying the expressions.
  Lisp is chock full of parentheses, with no way to get rid of them -- if
  you simplify your expressions, you end up with _more_ parentheses.  The
  "syntax = pain" equation in most C programmer's heads translates to a
  desire to reduce the cost of learning a new language by trying to adapt
  it to the pain they have already been through.  However, once you grok
  the parentheses in Lisp, they are _not_ painful.  In fact, they are so
  much more liberating and enabling and downright _friendly_ that you would
  just _love_ to have similar tools available in every other language you
  use.  This is why the "economy of syntax" in C is really a "poverty of
  syntax" and the perceived verbosity of Lisp translates to a wealth of
  opportunity.  Like so many other things in life, you rarely get _only_
  what you optimize for.   ///