Why don't people like lisp?

[mike420 at ziplip.com]

Lulu of the Lotus-Eaters wrote:

> Kenny Tilton <ktilton at nyc.rr.com> wrote previously:
> |People don't like Lisp because of misconceptions, and threads like that
> |help dispel those.
> 
> In my own mind, the biggest impediment to really liking Lisp is not the
> annoying parentheses and awful syntax... it's many Lispers (especially
> those like Tilton).

90% of Lispers give the other 10% a bad name, but generalizing in this case 
is like racism. 

> As soon as I try to learn more by reading discussions, I am bombarded
> with weirdly fanatical (and very long) posts that are overwrought with
> many misrepresentations (e.g.  Python has "Lisp DNA", when pointedly it
> does not by GvR's indication).  

Some Lisp implementations (like CMUCL and friends) are *based* on Python! 
In fact, they had Python even before Guido. (It's true, you just need to
read it literally)

If Guido is Python's mother, and Lisp and Python share DNA.... Who had sex
with whom?

> Not that different Lispers even bother
> with the same misrepresentations--just so long as they are clear that
> programmers of all other languages are ignorant and stupid.

I admit it, knowing a very old, obscure and very unpopular (relative to the
top 10) language makes one feel sort of 'elite'. By "obscure" I mean hard
to understand for mainstream people. Obscurity is in the eye of the
beholder.

In fact, Lispers take pride in the obscurity of their code. It's part of the
fun of using Lisp. Proof? Recently in CLL-CLP, someone complained that most
(C/C++/Java) programmers do not know what they are doing, writing all their 
code as functions that span 300+ lines. On the other hand, Joe Marshall and
someone else touted writing Lisp code that has 25+ nesting levels. Others
approved such practice. I think 25+ depth is much worse than 300+ length. 
The _minimal_ example is

((((((((((((((((((((((((()))))))))))))))))))))))))

I don't want to see *real* code that has 25+ depth, I'll have nightmares.


> Or tortured threads about things that are only possible in Lisp... but
> as soon as any example is presented, it is obvious that the same thing
> is not only possible, but much easier and more direct, in (some) other
> languages.  Then special pleading accompanies the weaknesses of doing
> something in Lisp:  you have to use some other distribution (maybe a
> really expensive commercial one); if only you wrote these difficult and
> huge macros it would be easy; you don't -have- to use the syntax since
> the semantics is abstract; you shouldn't want to do -that-, but rather
> this other thing; etc.

We could also produce Pythonista that are stupid and then blame Python for
it. Do not listen to Lispers who do not make sense. Of the examples of
things that are only possible in Lisp, I think two were good and valid

  a. my example of the 'for' construct (for a in (range 1000)), etc.
  b. the example about converting switch statments into jump tables
     by someone I don't remember

Maybe more were good, but I can't think of any right away (and I haven't
read the whole thread). Erann Gat wrote some good stuff about adding 
constructs to the language, but I didn't like his code examples. 
Alex Martelli wrote some good stuff about simplicity and uniformity, but
it turned out he didn't know macros (at the time of writing, at least).

You just need to exercise your critical thinking skills when reading.

Also, USENET is not for reading, it's for writing and for organizing
your own thoughts. If you want to read, read a book.