[Python-ideas] Proposal to change Python version release cycle

[tds333 at mailbox.org]

Hello,

one of my long standing ideas to improve Python is to adjust the
release cycle and version number handling. In short, to simplify it.

This is the first draft of the idea:

Proposal to change Python version release cycle
===============================================


Goal
----

Increment the major version number more frequently for every new language
feature release.
Change Python feature version counting from "major.minor" to "major".

This is simpler, better to handle compatibility and allows adding new
library features more frequently.

The current Python version scheme is Major.Minor.Patch this will be kept
but the major version number will be incremented faster and for every
language feature release as it is now for the minor number.

For example today the minor version number is increased for every big release
done in 1,5 year cycle. In this new language features with new keywords can
appear, new libraries can be included and other C level API changes can happen.
There backward compatible feature improvements and new features also backward
incompatible can happen.

I suggest to change this to increment the major version for every new release
of the 1,5 year cycle.
And allow new Python standard library backward compatible changes for every
minor release cycle every 6 months.

Start with this from Python version 4 on.


Benefit
-------

Clear separation of new language features and C API changes and new
backward compatible feature additions.

So for a major version on Python level new keywords can be added, build ins
can be added or removed and the C API can be changed (new features or other
incompatible changes).

For a minor version new standard libraries can be added and API can be improved
in a backward compatible way. This can be done more frequently for example in
a 0,5 year cycle. Allowing the Python library part to improve in a higher rate.

For a patch version only none breaking bug and security fixes are allowed.
(Same as it is now, or even a little bit stricter)

With this change there is a clear separation of new language Features which
are also tracked by other Python implementations and new library features.
This can be seen very easy by only looking at the Python major version.
The C API level is included in this standard and is not allowed to change
in a minor version as it is now. This is because booth the Python language
and the C API of CPython implementation is a standard and tracked by other
implementations. For them it is easy to say I am compatible to Version 4.
For everyone in computer business it is clear what is meant.

The Python standard library can be improved in a higher rate because backward
compatible feature changes are allowed in a higher rate for minor versions.
Also provisional libraries can be improved in a faster rate for every minor
version. (for example every 6 months instead of 1,5 years)

For Unix in the Python executable the major version can be appended and this
specifies the Python language standard used. This is done already but most of
the time only EXECUTABLEmajor.minor is useful. Also more complicated to handle
as a simple Number. Can be problematic on some platforms because of the dot ".".

Python major version every 1,5 years (same as it is now for major.minor).
Python minor version every 6 months (to allow faster standard library changes).
Python patch version as needed (to fix only bugs and security related stuff)

This can solve the problem of adding something as a standard library and then
this is the dead of the library because it cannot be improved any further
in a higher update rate.
The Python standard library should not be a dead end for a library after
inclusion. This allows Python code to improve faster than the C code.
This is needed to include new features faster and because we have more
people capable in Python programming than for C in the Python community.

On C level the compatibility distinction is simple only track the major
version and no longer a mixture between major and major.minor compatibility.


Risk
----

Minimal because to track features the major.minor version already has to be
tracked.
It is a change some assumptions about Python versions are at this point no
longer valid.
On C level external libraries and wrappers must adopt it and changes are
needed.


Open questions
--------------

The exact release cycle for minor, can also be every 4 months if needed.
Clear separation what is part of the language standard and what is part
of the C API.
Some modules, for example "sys" can also be part of the language Standard
and should not change between minor versions.

The difference between the stable C API and that for every minor version
can be removed. There is only one C API guarantee for a major version
and it does not change for a minor version.


None goals
----------

Change the release cycle of 1,5 years for new big releases.
Change the versioning scheme to something other than "major.minor.patch".
New big ground breaking changes to everything.
To complicate something.


Regards,

Wolfgang