A critic of Guido's blog on Python's lambda

Alex Martelli aleaxit at yahoo.com
Sun May 7 04:23:12 CEST 2006

Paul Rubin <http://phr.cx@NOSPAM.invalid> wrote:
> > Yes, we are, because the debate about why it's better for Python (as a
> > language used in real-world production systems, *SCALABLE* to extremely
> > large-scale ones) to *NOT* be insanely extensible and mutable is a
> > separate one -- Python's uniformity of style allows SCALABILITY of
> > teams, and teams-of-teams, which is as crucial in the real world ...
> My current take on Lisp vs Python is pretty close to Peter Norvig's
> (http://www.norvig.com/python-lisp.html):
>     Python has the philosophy of making sensible compromises that make
>     the easy things very easy, and don't preclude too many hard
>     things. In my opinion it does a very good job. The easy things are
>     easy, the harder things are progressively harder, and you tend not
>     to notice the inconsistencies. Lisp has the philosophy of making
>     fewer compromises: of providing a very powerful and totally
>     consistent core. This can make Lisp harder to learn because you
>     operate at a higher level of abstraction right from the start and
>     because you need to understand what you're doing, rather than just
>     relying on what feels or looks nice. But it also means that in
>     Lisp it is easier to add levels of abstraction and complexity;
>     Lisp makes the very hard things not too hard.

Sure -- however, Python makes them not all that hard either.  Peter and
I have uncannily similar tastes -- just last month we happened to meet
at the same Arizona Pueblo-ancestral-people ruins-cum-museum (we both
independently chose to take vacation during spring break week to take
the kids along, we both love the Grand Canyon region, we both love
dwelling on ancient cultures, etc -- so I guess the coincidence wasn't
TOO crazy -- but it still WAS a shock to see Peter walk into the museum
at the same time I was walking out of it!-).  Yes, it IS easier to add
complexity in Lisp; that's a good summary of why I prefer Python.

> I've heard many times that your current employer uses Python for all
> kinds of internal tools; I hadn't heard that it was used in Very Large
> projects over there.  I'd be interested to hear how that's been
> working out, since the biggest Python projects I'd heard of before
> (e.g. Zope) are, as you say, toy-sized throwaways compared to the
> stuff done regularly over there at G.

Sorry, but I'm not authorized to speak for my employer nor to reveal
details of our internal systems -- hey, I cannot even say how many
servers we have; the "corporate approved metrics" is ``several
thousands''...;-).  The most that managed to get approved for external
communication you'll find in the "Python at Google" presentation that
Chris di Bona and Greg Stein hold at times in various venues, and that's
not saying much -- good thing I'm not the one giving those
presentations, as I might find hard to stick to the approved line;-)


More information about the Python-list mailing list