Why is Python popular, while Lisp and Scheme aren't?

[Andrew Dalke]

Pascal Costanza:
> I have recently switched over to Common Lisp 
> as my language of choice and have written an article about it, to be 
> found at http://www.pascalcostanza.de/lisp/guide.html - you might find 
> it worthwhile.

It's a discussion of Lisp, with only a few points specifically of
why you switched from Java to Lisp and one mention of Python.  (There
were two references to Monty Python, from which Python the language got
its name.)  I was hoping for a more philosophical rumination of why
you chose Java over Python.  :(

Some points that are weaker in a Python/Lisp comparison are

  - Python doesn't have as many "funny names" as Lisp

  - Python also does run-time typing rather than static typing

  - You say
 > Please remember that due to their syntax, C-like languages and Pascal 
 > might also run into trouble when curly braces or begin/end keywords
 > are used incorrectly in conjunction with control statements (like if,
 > while, switch/case, and so on)

But Python doesn't have that problem, given neither braces nor begin/end
keywords.  Indeed, you seem to suggest that all Algol-derived languages
are like C/C++/Pascal/Java in having explicit delimiters, a separate
compilation step, static typing,

   - You say:
 > A nice thing about Lisp is that it doesn't noticeably distinguish
 > between built-in functions and user-defined functions.

The same is true for Python.


You talk about Lisp's macro feature.  That's come up  several times
on c.l.py.  I understand at least theoretically the usefulness of
macros.  However, I am quite worried about the supportability of
defining your own language on the fly.  For the comparison I would
have like to have seen, I was hoping for comments on the
maintainability of macros, especially given that some people like
you have found "them to be conceptually quite simple and easy to
write" while others find them "seemingly hard to understand."  I
believe the answer is you want a language which emphasises your
personal expressive power and not which which emphasises the
team's/project's/group's power.

A discussion on the pros and cons of macros has come up on c.l.py
before so there's no need to respond to it now, I'm just pointing
out what I was hoping to see and why I found this to be less
than that.

I read your mention that Lisp allows recoverability at the place
where the exception took place.  I recall reading in my progamming
languages book back in college that that ends up not being all that
useful, but I can't provide a reference for that now.  In my
own current thinking, I agree with the book.

I've used exceptions for many years now, and while thinking about
that book's comment.  I haven't found a place where I needed
continuation from the exception point but many where continuations
would be harder to handle.  For example, sometimes when the error
occurs I need to raise different exceptions given the results,
possibly after doing a bit of probing.  If all exceptions offered
rerun-at-raise point, this means my code needs to handle a return
to that point, followed by (in essense) a rerun of the code which
caused the error.  This can be tricky.

So I would also have prefered more examples of why a feature was
not only available in Lisp but why that feature is useful for
most programming tasks.  (And you are a fan of "practical things
that you need in every-day programming" so should stress usefulness
over ability.)

					Andrew
					dalke at dalkescientific.com