[Python-Dev] Re: Stability and change

[Paul Hughett]

As an extension developer, I see considerable advantages to having
separate stable and experimental tracks, a la Linux.  The key
distinction, as I see it, is that the stable track has most of the
bugs fixed, is recommended for production use (though not perfect),
and that any code that works with stable version N will almost
certainly work with version N+1, but it doesn't have all the latest
and greatest features.  The experimental track, on the other hand, has
all the latest and greatest, but they might not work and the details
might change from version to version.

I then get several advantages from sticking to the stable versions:
(1) Any bugs I find are probably in my extension rather than in the
Python implementation.  (2) The bugs that I find are probably
consistent across most of the minor versions.  (3) I only have to
write for and support half as many different major versions.  Given
that the implementations are more stable, my workload is cut by a
factor of more than two.  (4) The documentation for the stable
versions is (probably) better quality, so I have to spend less time
experimenting to get things to work as I want.

Given that we distinguish stable and experimental versions (which I
regard as an obvious +1), we have the problem of labelling them and I
think the Linux system is well suited (but I'm still willing to listen
to alternatives): It's well-established and known to a large part of
our target audience.  It's pretty easy to determine from the version
number alone whether it's stable (minor version even) or experimental
odd); I wouldn't want to try to remember that--say--versions 2.2.1
through 2.2.19 are experimental while 2.2.20 and up are stable.

Paul Hughett