Is Python moving too fast? (was Re: Is python commercializationazing? ...)

[Skip Montanaro]

    Alex> When I told people that the 1.5.2 release I was using, the latest
    Alex> one, had been 100% stable for over a year, I saw lights of wistful
    Alex> desire lighting in their eyes (at least as soon as they understood
    Alex> that here, for once, 'stable' did NOT mean 'dead':-)....  Oh well,
    Alex> it was nice while it lasted; now, the perception of Python will
    Alex> switch back from "magically stable and sound beyond ordinary
    Alex> mortals' parameters" to "quite ready to change core language for
    Alex> the sake of a marginal and debatable minor gain", i.e., "just
    Alex> another neat thing off the net".

I began using Python in early 1994, probably around version 1.0.1.  In the
intervening 6+ years, Python has had what I consider to be five significant
releases: 1.1 (10/11/94), 1.2 (4/10/95), 1.3 (10/8/95), 1.4 (10/25/96) and
1.5 (12/31/97).  (1.5.1 was released 4/13/98 and 1.5.2 was released
4/13/99).  So, while it's been a bit over a year since 1.5.2 was released,
Python really hasn't changed much in over 2.5 years. Guido and his core team
have been very good at maintaining backward compatibility while improving
language features and performance and keeping the language accessible to new
users.

We are now in the midst of several significant changes to the Python
development environment.  From my perspective as a friendly outsider, here's
what I see:

    1.  For the first time in it's 10+ year history, the language actually
        has a team of programmers led by Guido whose full-time job is to
        work on the language.  To the best of my knowledge, Guido's work at
        CNRI and CWI focused on other stuff, to which Python was applied as
        one of the tools.  The same observation can be made about the rest
        of the core PythonLabs team: Tim, Barry, Fred & Jeremy.  All had
        other duties at their previous positions.  Python was an important
        tool in what they did, but it wasn't what they got measured by in
        yearly performance reviews.

    2.  For the first time in its history, a secondary development team has
        surfaced in a highly visible and productive way, thanks to the
        migration to the SourceForge CVS repository.  Many of those people
        have been adding new ideas and code to the language all along, but
        the channel between their ideas and the core distribution was a very
        narrow one.  In the past, only the people at CNRI (and before that,
        CWI) could make direct changes to the source code repository.  In
        fact, I believe Guido used to be the sole filter of every new
        contribution to the tree.  Everything had to pass his eyeballs at
        some point.  That was a natural rate limiter on the pace of change,
        but I believe it probably also filtered out some very good ideas.

	While the SourceForge tools aren't perfect, their patch manager and
	bug tracking system, coupled with the externally accessible CVS
	repository, make it much easier for people to submit changes and for
	developers to manage those changes.  At the moment, browsing the
	patch manager with all options set to "any" shows 22 patches,
	submitted by 11 different people, which have been assigned to 9
	different people (there is a lot of overlap betwee the gang of 9 and
	the gang of 11).  That amount of parallelism in the development just
	wasn't possible before.

    3.  Python is now housed in a company formed to foster open source
        software development.  I won't pretend I understand all the
        implications of that move beyond the obvious reasons stated in item
        one, but there is bound to be some desire by BeOpen to put their
        stamp on the language.  I believe that there are key changes to the
        language that would not have made it into 2.0 had the license
        wrangling between CNRI and BeOpen not dragged out as long as it did.
        Those of us involved as active developers took advantage of that
        lull.  (I say "we", because I was a part of that.  I pushed Greg
        Ewing's original list comprehensions prototype along when the
        opportunity arose.)

    4.  Python's user and programmer base has grown dramatically in the past
        several years.  While it's not possible to actually measure the size
        of the user community, you can get an idea of its growth by looking
        at the increase in list traffic.  Taking a peek at the posting
        numbers at

            http://www.egroups.com/group/python-list

        is instructive.  In January of 1994 there were 76 posts to the list.
        In January of 2000 that number grew to 2678.  (That's with much less
        relative participation today by the core developers than in 1994.)

        In January of 1994 I believe the python-list at cwi.nl (with a possible
        Usenet gateway) was the only available discussion forum about
        Python.  Egroups lists 45 Python-related lists today (I took their
        word for it - they may stretch things a bit).  There are at least
        three (maybe four) distinct dialects of the language as well, not to
        mention the significant growth in supportef platforms in the past
        six years.

All this adds up to a system that is due for some significant change.  Those
of us currently involved are still getting used to the new system, so
perhaps things are moving a bit faster than if we were completely familiar
with this environment.  Many of the things that are new in 2.0 have been
proposed on the list off and on for a long time.  Unicode support, list
comprehensions, augmented assignment and extensions to the print statement
come to mind.  They are not new ideas tossed in with a beer chaser (like
"<blink>").  From the traffic on python-dev about Unicode support, I believe
it was the most challenging thing to add to the language.  By comparison,
the other three items I mentioned above were relatively simple concepts to
grasp and implement.

All these ideas were proposed to the community in the past, but have only
recently gained their own voice (so to speak) with the restructuring of the
development environment and growth in the base of active developers.

This broadening of the channel between the development community and the CVS
repository will obviously take some getting used to.  Once 2.0 is out, I
don't expect this (relatively) furious pace to continue.

-- 
Skip Montanaro (skip at mojam.com)
http://www.mojam.com/
http://www.musi-cal.com/

[Completely unrelated aside: I've never voiced an opinion - pro or con -
about the new print syntax, either on python-list or python-dev.  This will
be my only observation.

I have used the following print statement format for several years when I
wanted to insert some temporary debugging statements that I knew I would
later remove or comment out:

    print ">>", this, that, and, the, other, stuff

because it would make it easier to locate them with a text editor.  (Right
shift, while a very useful construct, is hardly common in my programming.)
Now, I'm happy to say, I will no longer have to quote the ">>" and it will
be easier to get the output to go to sys.stderr...]