CLPython (was Re: merits of Lisp vs Python)

[Paul Boddie]

greg wrote:
> Willem Broekema wrote:
>
> > I guess in part it's because there are not that many people really into
> > both Python and Lisp, and those who are might not find this an
> > interesting project because there is nothing "wow" to show, yet.
>
> Another reason (or maybe the reason for the reason) is
> that people are usually interested in Python because it's
> a relatively simple and lightweight thing.

I think it's more likely that the Lisp people wonder why you'd want to
write anything other than Lisp (and they're all supposedly too busy
doing other things, anyway, like rewriting their own version of
reddit.com), whereas the Python people either haven't heard about it,
aren't really interested because they believe other projects (eg. PyPy)
will deliver the same benefits (which probably won't be the case
entirely), or don't have the means to either run and experiment with it
or to help out.

> Having to install a complex and heavyweight thing like
> a Common Lisp system just to be able to program in
> Python doesn't seem like a good deal.

There seems to be a fairly high intuitive similarity between various
Common Lisp concepts and various Python concepts, although one can only
make best use out of Common Lisp features (or the features of any
particular platform) if the correspondence is sufficiently high. I
suppose the argument that one can write extensions in Lisp rather than
C may be enticing, but one returns to the "why write anything other
than Lisp" argument at this point. There may be an argument for having
CLPython as an embedded application scripting language, but again the
Lisp camp have often advocated Lisp for that role, too.

> It might become a good deal if you could then compile
> the Lisp and get a lean, efficient binary executable
> out of it. But that's going to require much more than
> just a straightforward translation from Python to Lisp.

Indeed.

> If CLPython starts to show signs of making progress
> in that direction, then it could start to get
> interesting. Although I think I'd rather target Scheme
> than CL if I were doing it -- cleaner language, small
> yet still extremely good implementations available.

Well, there are some open source Common Lisp implementations around,
despite the obvious bias in certain circles to encourage everyone to
use the proprietary implementations instead, and things like SBCL are
only a simple package manager install away. Meanwhile, there was an
implementation of Python for Scheme, but I don't think the developers
took the idea much further after presenting it at PyCon a few years
ago.

Paul