OO misconceptions (was: Re: Long Live Python!)

[Peter Hansen]

Tim Hammerquist wrote:
> 
> <*someone*@ActiveState.com> wrote:
> > Python allows you to build larger systems because it allows a looser
> > binding between granular components, it allows more to be done in less
> > code and it makes testing so much easier that the loss of compiler
> > warnings is trivial.
> 
> I'm all for rapid development and such, and I use Python whenever I think
> it has an advantage over another choice (which is quite often).
> 
> But what does 'larger' mean in this case?  Larger than the MySQL engine?
> Larger than a linux kernel?  Larger than the Red Hat install scripts?

Yes.  Yes.  And yes.

(Oh, sorry... how big are those programs?  No, wait, it doesn't matter.)

> I wouldn't implement a RDBMS in Python. Nor would I implement a word
> processor in assembler.

Neither would I.  An RDBMS would most likely need performance beyond
what Python could provide, but if that were not the case, Python would
most certainly be an option.  (I don't know what assembler has to do
with this discussion, but I would prefer Python over it for writing
a word processor, performance issues aside.  Performance issues 
included, I might use a little bit of assembler for the hot spots 
of the word processor, but a more reasonable choice would be C, of 
course.  A good way of writing very large applications in Python
would be to have the performance-critical parts coded not in Python,
then spend the development effort where it counts on the higher level
complex functionality, and testing.)

> *nix OSes (like BSD) have attained an incredible scalability.  
[...]
> And what language is the
> majority of the core of BSD written in?  It's written in C, which does
> not even claim to be an OO language.

Typical Python applications, even really large ones, would not likely 
have the sheer number of programmers working on it that the BSD core
has had, nor the length of time they've worked on it.

> An application's scalability has much more to do with the programmer's
> use of algorithms and abstraction than with the language in which it's
> implemented...no matter how much money ActiveState has invested in it.

Did you write all this just for this jab at ActiveState?  I know of the
opinion some people have of them, but I didn't sense that *someone*'s 
posting contained anything more commercial or biased than what many of 
the rest of us, who don't work for ActiveState, have written.

You're right about algorithms having more to do with this issue than the
language, but some languages support better algorithms (by making
their implementation easier and less buggy) and faster development than
others.  Those are merely two of the ways in which Python supports
"larger" applications.

-- 
----------------------
Peter Hansen, P.Eng.
peter at engcorp.com