BIG successes of Lisp (was ...)

[mike420]

In the context of LATEX, some Pythonista asked what the big
successes of Lisp were. I think there were at least three *big*
successes.

a. orbitz.com web site uses Lisp for algorithms, etc.
b. Yahoo store was originally written in Lisp.
c. Emacs

The issues with these will probably come up, so I might as well
mention them myself (which will also make this a more balanced
post)

a. AFAIK Orbitz frequently has to be shut down for maintenance
(read "full garbage collection" - I'm just guessing: with
generational garbage collection, you still have to do full
garbage collection once in a while, and on a system like that
it can take a while)

b. AFAIK, Yahoo Store was eventually rewritten in a non-Lisp.
Why? I'd tell you, but then I'd have to kill you :)

c. Emacs has a reputation for being slow and bloated. But then
it's not written in Common Lisp.

Are ViaWeb and Orbitz bigger successes than LATEX? Do they
have more users? It depends. Does viewing a PDF file made
with LATEX make you a user of LATEX? Does visiting Yahoo
store make you a user of ViaWeb?

For the sake of being balanced: there were also some *big*
failures, such as Lisp Machines. They failed because
they could not compete with UNIX (SUN, SGI) in a time when
performance, multi-userism and uptime were of prime importance.
(Older LispM's just leaked memory until they were shut down,
newer versions overcame that problem but others remained)

Another big failure that is often _attributed_ to Lisp is AI,
of course. But I don't think one should blame a language
for AI not happening. Marvin Mins ky, for example,
blames Robotics and Neural Networks for that.

[Lulu of the Lotus-Eaters]

Kenny Tilton <kt*****@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).

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 misrepresentati ons (e.g. Python has "Lisp DNA", when pointedly it
does not by GvR's indication). Not that different Lispers even bother
with the same misrepresentati ons--just so long as they are clear that
programmers of all other languages are ignorant and stupid.

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.

Yours, Lulu...

--
_/_/_/ THIS MESSAGE WAS BROUGHT TO YOU BY: Postmodern Enterprises _/_/_/
_/_/ ~~~~~~~~~~~~~~~ ~~~~~[me***@gnosis.cx]~~~~~~~~~~~~~~~ ~~~~~~ _/_/
_/_/ The opinions expressed here must be those of my employer... _/_/
_/_/_/_/_/_/_/_/_/_/ Surely you don't think that *I* believe them! _/_/

[Simon András]

da*******@yahoo .com (dan) writes:

Google ate my long post, so I'll make it simple.
Thank you.

Lisp failed (yes, it did) because of the parentheses. Normal people
can't parse 13 close-parens easily. Functional notation is
non-intuitive and hard to read.
Yes, you're right, lisp failed, it's dead, and has been for about two
decades now. (Search google for posts like yours from the last century
to confirm this.) But somehow this doesn't stop it thriving, so it's
probably one of the the healthiest dead languages in the history of
IT.

And of course the culprit is the parantheses. (Thank you for telling
us about it! Dylan people will be especially delighted about the
news.) Although ten years ago it was GC, and before that it was that
it needed special hardware to run at acceptable speed.

It's also true that normal people can't parse 13 close parens. Most
Lispers probably can't either, and they definitely don't. Do
pythonistas count whitespace?

I'm grateful for your concise critique of "functional notation". I
assume you mean prefix notation, and considering that algoloid
languages also use this for functions, you should probably switch to
Forth (too bad you probably think it's dead, too). Silly me, I thought
that the charm of infix notation disappears at functions of arity 3 or
more.

The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.

This is _so_ true, I wonder why it reminds me of the following:

"A French politician once wrote that it was a peculiarity of the
French language that in it words occur in the order in which one
thinks them."
Wittgenstein, PI 336

Bye,
Andras

[Pascal Costanza]

Lulu of the Lotus-Eaters wrote:

Kenny Tilton <kt*****@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).
You don't like Lisp because you don't like some other guy who is using it?!?
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 misrepresentati ons (e.g. Python has "Lisp DNA", when pointedly it
does not by GvR's indication). Not that different Lispers even bother
with the same misrepresentati ons--just so long as they are clear that
programmers of all other languages are ignorant and stupid.

That's just your interpretation of what they say. I think both "sides"
have their fair share of beliefs that they cannot back by argument
and/or empirical assessments. Every language has features that people
have learned to appreciate because of hands-on experience. It's in fact
an esoteric experience in the truest sense of the word: one that cannot
be described in words.

I haven't actually ever used Python in practice, so I can't really tell
whether the syntax or some other features of Python will make me go
eureka when I use them. And I don't care because I already have made
that experience wrt s-expressions and macros, and I hope that I will
never have to go back to a language without macros. All the counter
arguments I have heard so far seem to be made on the basis that people
haven't made that experience yet that I am talking about. Yes, every
language feature has its dangers. What matters is whether the advantages
outweigh the dangers or not. In the case of macros, IMHO you shouldn't
guess, you should just try.

If you are really interested to find out whether macros work in practice
or not, it is extremely easy to do so. Pick one of the free commercial
or non-commercial implementations of Common Lisp, download the free book
"On Lisp" by Paul Graham from his website, try to understand what he is
saying about macros, try to write your own. Maybe you will get it, maybe
not.

These are just my opinions, they are not proven facts. Actually, I don't
really care whether you try it or not. I have made up my mind, and if
someone asks whether macros are useful or not - and this was the start
of this thread - I am going to try to share my experience.

For every discussion, you can concentrate on what are seemingly the most
extreme statements and counter them on the basis that they are too
extreme, or you can try to find out by yourself what actually hides
beneath those statements. (Or you can just ignore a topic if you're not
interested.)
Pascal

[Paul F. Dietz]

Lulu of the Lotus-Eaters wrote:

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).

Do you often let the behavior of others control how you think
about technical topics?

Paul

[Pascal Costanza]

dan wrote:

The world is moving in the direction of languages like Python

Yes, and that's a good thing.

It's a good thing because it means that static approaches are replaced
by dynamic approaches.
Pascal

[Kenny Tilton]

Lulu of the Lotus-Eaters wrote:

Kenny Tilton <kt*****@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).
So you would charge right out and use Lisp, except you do not like me?
Hmmmm....

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 misrepresentati ons (e.g. Python has "Lisp DNA", when pointedly it
does not by GvR's indication).
I phrased that with a vague metaphor precisely to avoid saying anything
about Python's history and motivation, about which I am largely
ignorant. I have no idea where the ideas for garbage collection,
first-class functions, and a MOP came from, but Peter Norvig, a Python
fan, writes:

"Basically, Python can be seen as a dialect of Lisp with "traditiona l"
syntax (what Lisp people call "infix" or "m-lisp" syntax). One message
on comp.lang.pytho n said "I never understood why LISP was a good idea
until I started playing with python." Python supports all of Lisp's
essential features except macros, and you don't miss macros all that
much because it does have eval, and operator overloading, and regular
expression parsing, so you can create custom languages that way."

That's at: http://www.norvig.com/python-lisp.html

Note that Norvig is not saying how Python ended up so close to Lisp,
just that it has. Me neither/too.

Not that different Lispers even bother
with the same misrepresentati ons--just so long as they are clear that
programmers of all other languages are ignorant and stupid.
Nonsense. We actually hope a few Pythonistas will come help us build up
some free libraries for Lisp to solve a weak point for us. We recognize
Pythonistas as (a) Early Adopters who (b) groove on interactive,
dynamic, powerful languages.

We are recruiting, not flaming.
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.

It's funny this never occurred to me, but my own Cells hack uses macros
big time. Here is a before/after in which I manually macroexpanded the
code and spliced the output back into where it would have expanded:

Before:

(make-instance 'boiler1
:temp (cv 20)
:status (c? (if (< (temp self) 100)
:on :off))
:vent (c? (ecase (^status)
(:on :open)
(:off :closed))))

After:

(make-instance 'boiler1
:temp (make-c-variable :value 20)
:status (make-c-dependent
:rule (lambda (c &aux (self (c-model c))
(.cache (c-value c)))
(if (< (temp self) 100) :on :off)))
:vent (make-c-dependent
:rule (lambda (c &aux (self (c-model c))
(.cache (c-value c)))
(ecase (let ((*synapse-factory* nil))
(status self))
(:on :open) (:off :closed)))))

Some observations:

(1) This is an extreme case, because Cells is an ambitious hack. But the
principles are the same for simpler applications

(2) If I did not have macros, I could compress the above 20%, but no more

(3) Expanding the macros exposes implementation details. I use Cells a
lot, and I refactor a lot. Exposing internals is not just a theoretical
no-no, I'd be dead.

(4) So as not to overstate my case, I snipped this clause from the
actual expansion:

:code '((ecase (let ((*synapse-factory* nil))
(status self))
(:on :open) (:off :closed)))

That is just plain scary. What I am doing is not only expanding the user
code into a lambda form, but also generating /this/ code to dynamically
(at run-time) stuff the code's source (in symbolic form, what the macro
gets its hands on at compile-time) into a slot in the cell data
structure to help with debugging at crash-time. (ie, the source level
debugging on my particular implementation could be a lot better (I just
learned they are working on it) but I have anyway worked around that
with macros.

(5) Leaving aside exposed implementation (a fatal problem, mind you) "I
can do that in Python without macros" is /not/ an objection, unless the
code comes out as terse as the "before". One thing we Lispniks should
have emphasized early on is that one thing macros do is compress and
prettify the code. Surely Pythonistas will acknowledge the value of that.

(6) Paul Graham says it better: http://www.paulgraham.com/onlisp.html

kenny
--
http://tilton-technology.com
What?! You are a newbie and you haven't answered my:
http://alu.cliki.net/The%20Road%20to%20Lisp%20Survey

[Ville Vainio]

da*******@yahoo .com (dan) writes:

Lisp failed (yes, it did) because of the parentheses. Normal people
Lisp hasn't failed as long as emacs is around, and uses Lisp.

Actually, one of the problems with Lisp might be the steep learning
curve. Lisp does not offer the instant appeal of Python. The most
common initial impression of Lisp is "yuck" (parens), while w/ Python
it's mostly "wow, I didn't know code could be so readable and
powerful" (though the whitespace is sometimes an issue, the shock
might last for several minutes).

Now that neither Lisp not Python has the idustry-dominating status
(unlike Java, C++), instant appeal matters a lot. If people are
expected to hop in as a hobby, Python wins hands down. It takes just
3-4 toilet sessions (if you have the habit of reading in toilet) to
master Python, whereas w/ Lisp you have to hack the code for a
while. And still, you can't read the code fast enough; it's fast
enough to write, but reading can be painful initially (unlike perl,
where the pain lasts indefinitely).

Lisp offers a bit more power than Python (macros), but after a while
with Python, one notices that none of the power that is missing is
actually even needed. Python has just the right
features. Period. There are one or two warts (dangling variable after
list comprehensions comes to mind), but the language as a whole feels
natural. Lisp feels natural if you are writing a compiler or want to
be as orthogonal as possible, Python feels natural for most (all
except drivers/applications with extreme performance requirements) of
the real world applications.

The world is moving in the direction of languages like Python, that
fit naturally with how we speak and write.

Yes it is; that doesn't mean that Lisp would be dead after a while. At
least not until emacs supports Python natively :-). Seriously though,
Lisp is one of the more programmer centric (== least evil) languages
around, loved by programmers and shunned by the managers. If Python
(and ruby, which I view mostly as a Python with different syntax)
weren't around, Lisp would be the language of choice for most
pythoneers.

Hmm, I guess I should leave usenet alone on saturday nights, but what
the heck :-).

--
Ville Vainio http://www.students.tut.fi/~vainio24

[Kenny Tilton]

Pascal Costanza wrote:

I haven't actually ever used Python in practice, so I can't really tell
whether the syntax or some other features of Python will make me go
eureka when I use them.

FWIW, I have used Python in anger, and the textual clarity of my code
was indeed remarkable.

--
http://tilton-technology.com
What?! You are a newbie and you haven't answered my:
http://alu.cliki.net/The%20Road%20to%20Lisp%20Survey

[Paul Rubin]

Ville Vainio <vi************ ********@spamtu t.fi> writes:

Lisp offers a bit more power than Python (macros), but after a while
with Python, one notices that none of the power that is missing is
actually even needed. Python has just the right
features. Period. There are one or two warts (dangling variable
after list comprehensions comes to mind), but the language as a
whole feels natural. Lisp feels natural if you are writing a
compiler or want to be as orthogonal as possible, Python feels
natural for most (all except drivers/applications with extreme
performance requirements) of the real world applications.

No language feels more natural than Lisp. There's a real sense that
while Python was invented by a brilliant programmer, Lisp is built
into of the structure of the Universe. Bob Kanefsky's song "The
Eternal Flame" is a humor piece for sure, but it expresses that
sentiment beautifully. I can't imagine it being written about Python
or any other language than Lisp.

http://www.songworm.com/lyrics/songw...rnalFlame.html

[Lulu of the Lotus-Eaters]

|> 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).

Pascal Costanza <co******@web.d e> wrote previously:
|You don't like Lisp because you don't like some other guy who is using
|it?!?

Absolutely! One of the things that is greatest about Python is its
programming community, and its newsgroup. Quite apart from any matters
of syntax or semantics, or OOP vs. FP, or any of that stuff, it's a
heck of a lot nicer working in a language where you can get friendly,
helpful, informative answers to questions... and ones that lack scorn
and contempt.

From what I can tell, Lisp would be a terrible choice from that POV.

Python is good, but so are, e.g., Ruby or Haskell in slightly different
ways. Perl, PHP, C++, and Java would probably be ranked in descending
order here, but still mostly positive.

The only languages I've seen with truly vindictive and nasty user
communities are Lisp... and VB. It's a strange closeness of the two.
All the more so because VB has a lot of poorly educated, not
particularly bright, user who are merely boastfully defensive about the
only thing they know. To the contrary, I clearly recognize that
Lispers--even most of the most over-the-top rude ones--are startlingly
intelligent. I'm not sure which is worse though... someone like Tilton
is easily smart enough to avoid sophistry, and yet he engages in it.

All that said, I also know that you cannot choose a language ONLY on its
user community. Obviously issues like static/dynamic typing, available
libraries, platform ports, and lots of issues cannot be brushed off.
Even speed of execution occassionally matters.

Yours, Lulu...

--
mertz@ _/_/_/_/_/_/_/ THIS MESSAGE WAS BROUGHT TO YOU BY:_/_/_/_/ v i
gnosis _/_/ Postmodern Enterprises _/_/ s r
..cx _/_/ MAKERS OF CHAOS.... _/_/ i u
_/_/_/_/_/ LOOK FOR IT IN A NEIGHBORHOOD NEAR YOU_/_/_/_/_/ g s