Why aren't we all speaking LISP now?

[Douglas Alan]

grante at visi.com (Grant Edwards) writes:

> On 12 May 2001 03:51:56 -0400, Douglas Alan <nessus at mit.edu> wrote:

> >On Thursday I went to a panel of preeminent language designers.  The
> >consenus is that we *are* all speaking Lisp right now, more or less,
> >only the name has been changed to Python.

> Why do people think Python is so Lisp-like? I just don't get
> it. I've written some mid-sized apps in Scheme and some
> small-to-mid sized ones in Python, and I don't think the
> languages feel the same at all:

>   1. Python doesn't have tail-recursion (AFAIK).

Scheme is only one dialect of Lisp, and a very specialized one at
that.  Most Lisp dialects do not do require tail recursion of an
implementaion.

>   2. In Python the representations of program and data are
>      completely different.  (I mean the external
>      representations, not the internal data structures used by
>      the interpreter.)

For day to day programming, the only use for this aspect of Lisp is
to make writing macros easier.  And writing macros isn't particularly
day to day programming, either.

>   3. Python's "lambda" is crippled.

Lambda's just a syntactic nicety, as long as you can have nested
function definitions.

>   4. Lisp's object model was slapped on as an afterthought.  

So was Python's.  There's no way that you can say that Python is any
more object-oriented than most Lisps are.  Common Lisp certainly has
the richest object system known to man.  (Perhaps a bit too rich.)

> Even simple things like iterating over a sequence of objects is done
> in a completely different way: in Lisp you do something to the first
> item then recurse.  In Python, you use "for x in list".

Only in Scheme would you typically recurse down a list.  In other
Lisps, you would do it a lot like you do it in Python.

> I think Python feels a lot more like either "dynamically typed
> Modula-3", or "non-message-passing Smalltalk" than any sort of Lisp.

Smalltalk is derived from Lisp too.  Smalltalk is *so* object-oriented
that I suspect programming in it feels a bit different from Lisp,
though.

|>oug