Lulu of the Lotus-Eaters wrote:
> Kenny Tilton <·······@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.
From: ·············@comcast.net
Subject: Re: Why don't people like lisp?
Date:
Message-ID: <d6cu5czr.fsf@comcast.net>
·······@ziplip.com writes:
> 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.
Depth 25 isn't really that bad. Consider a simple LET expression:
(let ((x (+ a b)))
...)
That + is four levels deep in parens. There's a few similar sort of
constructs that end up being somewhat deep. For example, look for an
item in a collection by it's nickname, if it has one:
(cond ((find item collection
:key (lambda (thing)
(or (thing-nickname thing)
(thing-name thing)))) ...)
(....))
THING-NICKNAME is 6 levels deep. Wrap something like that in a
handler-case, and you'll be up in the 20+ parenthesis in no time.
The 25+ thing I found was an unusual coincidence of several of these
`parenthesis-rich' constructs together. It was `logically' much
shallower.
In article <············@comcast.net>, ·············@comcast.net wrote:
> ·······@ziplip.com writes:
>
> > 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.
>
> Depth 25 isn't really that bad. Consider a simple LET expression:
>
> (let ((x (+ a b)))
> ...)
>
> That + is four levels deep in parens. There's a few similar sort of
> constructs that end up being somewhat deep. For example, look for an
> item in a collection by it's nickname, if it has one:
>
> (cond ((find item collection
> :key (lambda (thing)
> (or (thing-nickname thing)
> (thing-name thing)))) ...)
> (....))
>
> THING-NICKNAME is 6 levels deep. Wrap something like that in a
> handler-case, and you'll be up in the 20+ parenthesis in no time.
>
> The 25+ thing I found was an unusual coincidence of several of these
> `parenthesis-rich' constructs together. It was `logically' much
> shallower.
>
Why should be an indention depth of, say, 25 should be worse than, say,
20? Indention depth is seldom a problem at all. I really
don't care - it just needs to be indented in a way I can
read it on a screen. It is just another 'made up' problem
of Lisp.
·······@ziplip.com writes:
>
> 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.
>
Its not as bad as you think it is. The deeply nested code is likely
divided into a sequence of distinct "modules" that accumulate, use and
dispense with local state as they execute. There is likely some
overall state that is also manipulated, but its likely that only leads
to a few of the outermost indents.
An editor like Emacs will let you skip from sexp to sexp without
having to count parens and indents, so you can navigate at whatever
level of detail you want. If you're using an editor that cannot
navigate expressions like Emacs can, then any large or deeply nested
function in any language is going to be very difficult to manage.
Its somewhat analagous to using a computer controlled milling machine
to handle repetitive work vs using a manually operated machine to do
it.
Gregm