merits of Lisp vs Python

[Cliff Wells]

On Sun, 2006-12-10 at 01:28 -0800, Kay Schluehr wrote:


> Who really wants to write web apps? Web apps are just an excuse for
> Pythonistas to write web frameworks.


I've been lurking, waiting for the right moment to toss in my two cents,
and finally, and here it is.

I've been using Python heavily for many years (since late 1.5.1) and
frankly I've gotten a bit bored with it.  I think your statement
indirectly (and unintentionally I'm sure) sums up why.   Python is
certainly pragmatic.  Python has *everything* you'd want for writing
applications: extensive libraries, flexibility, etc.  

Unfortunately, writing applications is boring. 

The way I like to overcome this boredom (and hence stay productive) is
by writing clever code.  I don't mean obfuscated one-liners (although
I'm guilty of that too), rather I mean generalizing code, creating
frameworks and then developing the application in that framework, that
sort of thing.  Python has been pretty good for me so far in keeping the
ceiling high enough that I could stretch but not bump my head too often.
I suspect I'm not alone in this need (hence the unusual number of web
frameworks written in Python).   

However lately I've noticed that the ceiling is quite apparent: Python
programmers are free to define DSL's via functions, classes, clever
operator overloading, etc, but not in the one way that actually makes
them really interesting: macros.    
It might be true that macros would make it more difficult for someone
else to understand my code (although I doubt much more than say, Zope or
Twisted, or any of the popular ORMs floating about).   Regardless, let's
take a moment to consider another point of view: I. DON'T. CARE.  That's
right.  I don't care if anyone else can read it.  Frankly I may not even
care if *I* can read it in a year.   Every year I look back at what I've
written the previous year and think about how much better I could have
done it *this* year.  This has gone on for over twenty years now and I
suspect that if that fact ever changed it would probably be time for me
to retire from programming as I'd have stopped learning (or would at
least be bored out of my mind).

The majority of code is throwaway.  That is, whatever need it was
written to fulfill will cease to exist, the coder will think of some
brilliant new approach that requires a major rewrite, another programmer
with different ideas will rewrite it from the ground up (probably in a
new language), a library will appear that renders it moot, etc, etc.
While I'm sure there is a huge base of ancient code out there somewhere,
faithfully powering our banks and dams and pushing fractions of pennies
about, I simply don't care.  Someone may have to read it, please god
don't let it be me.  I don't care about old application code.  It's
effing boring.  I don't just program because it pays the bills.  I
program because I *like to program*.   That means not having arbitrary
limits to what I can express so that some hypothetical 8th grader can
come along in some future decade and grok some one-off program I hacked
together over a weekend.   If I write code during a drunken binge, then
dammit, I'll run that code in another drunken binge.  If not, then I'll
damn well rewrite it when I'm sober.   I neither want nor need moral
programming imperatives handed down from above.   I will write crappy
code whenever I damn well feel like it.  If I learn something from it,
all the better.  If not, well that's my choice as an adult to take that
path.

There is lots of talk about how, if Python had macros, everyone would
create their own mini-languages and it would be a virtual Tower of
Babel, etc, etc.  Perhaps.  But of course, given how much syntax Python
has grown since 1.5 (most of which is there to compensate for
statement-oriented syntax and lack of macros) I'd suggest that perhaps
the tower is already being built directly into the language.

As an aside, it's pretty sad when many of the c.l.lisp folks on this
thread seem more polite in general than the c.l.py crowd.   Lisp may
have expression-based syntax and macros, but it's also got Eric Naggum.
If we can't have the nice features of Lisp, let's at least not adopt its
downsides.

Regards,
Cliff

P.S.  As a disclaimer, I *have* had a few beers tonight already and
have, in fact, been binge-coding, so if this seems like a rant, I
reserve the right to deny all knowledge of anything I may have written
up to this point. 



-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.python.org/pipermail/python-list/attachments/20061211/f54822a9/attachment.html>