python simply not scaleable enough for google?

[Robert Brown]

Vincent Manis <vmanis at telus.net> writes:

> On 2009-11-13, at 18:02, Robert Brown wrote:
>
>> Common Lisp and Scheme were designed by people who wanted to write
>> complicated systems on machines with a tiny fraction of the horsepower of
>> current workstations.  They were carefully designed to be compiled
>> efficiently, which is not the case with Python.  There really is a
>> difference here.  Python the language has features that make fast
>> implementations extremely difficult.
>
> Not true. Common Lisp was designed primarily by throwing together all of the
> features in every Lisp implementation the design committee was interested
> in.  Although the committee members were familiar with high-performance
> compilation, the primary impetus was to achieve a standardized language that
> would be acceptable to the Lisp community. At the time that Common Lisp was
> started, there was still some sentiment that Lisp machines were the way to
> go for performance.

Common Lisp blends together features of previous Lisps, which were designed to
be executed efficiently.  Operating systems were written in these variants.
Execution speed was important.  The Common Lisp standardization committee
included people who were concerned about performance on C-optimized hardware.

> As for Scheme, it was designed primarily to satisfy an aesthetic of
> minimalism. Even though Guy Steele's thesis project, Rabbit, was a Scheme
> compiler, the point here was that relatively simple compilation techniques
> could produce moderately reasonable object programs. Chez Scheme was indeed
> first run on machines that we would nowadays consider tiny, but so too was
> C++. Oh, wait, so was Python!

The Scheme standard has gone through many revisions.  I think we're up to
version 6 at this point.  The people working on it are concerned about
performance.  For instance, see the discussions about whether the order of
evaluating function arguments should be specified.  Common Lisp evaluates
arguments left to right, but Scheme leaves the order unspecified so the
compiler can better optimize.  You can't point to Rabbit (1978 ?) as
representative of the Scheme programming community over the last few decades.

> Using Python 3 annotations, one can imagine a Python compiler that does the
> appropriate thing (shown in the comments) with the following code.

I can imagine a lot too, but we're talking about Python as it's specified
*today*.  The Python language as it's specified today is hard to execute
quickly.  Not impossible, but very hard, which is why we don't see fast Python
systems.

bob