Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

APE 21: APE on ending long term support releases + Updates to APE 2 to reflect new release cycle without LTS #82

Merged
merged 23 commits into from
May 31, 2023
Merged
Changes from 4 commits
Commits
Show all changes
23 commits
Select commit Hold shift + click to select a range
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
105 changes: 105 additions & 0 deletions APE21.rst
Original file line number Diff line number Diff line change
@@ -0,0 +1,105 @@
Ending Long Term Support Releases
---------------------------------

author: Thomas Robitaille, Pey Lian Lim, Simon Conseil

date-created: 2023 February 16

date-last-revised: 2023 February 21 <keep this up to date anytime something changes>

date-accepted: <replace with accepted date>
hamogu marked this conversation as resolved.
Show resolved Hide resolved

type: Process

status: Discussion
hamogu marked this conversation as resolved.
Show resolved Hide resolved


Abstract
--------

This APE proposes to no longer designate any releases of the core package as being
"long-term support" (LTS) and provide guidance on how to handle API changes and deprecations.


Detailed description
--------------------

`APE 2: Astropy Release Cycle and Version Numbering <https://doi.org/10.5281/zenodo.1043887>`_ describes the release cycle
for the core astropy package, which consists of major releases every 6 months that
add new features (e.g., v5.2), and releases in between this that are limited to fixing bugs
or updating documentation (e.g., v5.2.1). Every 2 years, major releases are designated
as being LTS (e.g., v5.0) and we have committed to releasing bugfix releases
for this version (e.g., v5.0.3) for up to 2 years.

At the start of the project, having LTS releases was critical for acceptance by
large organizations/projects for which stability is paramount, as the core package went through
significant API changes from version to version due to the youth of the project and LTS
releases were a way to shield against these changes, or at least reduce disruption to
be every 2 years.

LTS releases are however not free:

* While we use infrastructure to automate backporting fixes to release branches,
in practice the LTS branch diverges more and more from the main development
branch and automated backports are more likely to fail as time goes on,
requiring human effort to manually do the backports, which can sometimes be
non-trivial.
* Even once fixes are backported to the LTS branch, carrying out releases is not
fully automated and requires manual steps, so having to do
bugfix releases for both the latest release branch and LTS branch puts an extra
burden on the core package release team.

In addition, it is not clear that LTS releases are needed anymore - now that the
core package is over ten years old, it has reached a much higher level of
stability. No other main package in the scientific Python ecosystem has LTS
releases, and there is no longer a strong argument for having this
in astropy either.

This APE proposes the following:

* No longer designate any releases as LTS.
* Keep the 6-month release cycle and bump releases to x.0 every 2 years.
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Maybe make the two years period more flexible ? 2 years still seems a good period in general but it may make sense sometimes to wait a bit more before publishing a new major version. And with the new scheme delaying a new major version has no consequences.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

But this also means that if someone wants a new thing that will totally break API, they have to wait 2 years? Do we not merge that PR for 2 years?

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yeah indeed. This case should hopefully not happen too often, but we could imagine releasing a major version only 1/1.5 year after the previous one on exceptional circumstances ? But in general if there is a need to totally break the API there should be a long enough period of time before that with deprecation warnings, so the 2 years cycle seem realistic.

Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

It's worth noting that with a fixed 2-year cycle, some API changes might wait 1.9 years, and others might be merged 1 week before the deadline.

There would tend to be a bias (maybe strong?) toward the major version feature freeze deadline, because folks might have an idea and want to get it in knowing that it will be another 2 years otherwise. Something to consider!

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yes, that's why I think we should keep some flexibility in the 2 years cycle.
But also before a breaking change appears in a major release, there should be deprecations in a previous minor release. So major release are not the time to merge anything just because we can break things in this release, we should plan beforehand what major changes are waiting, if deprecations have been released, for how long, etc.

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Agree with @taldcroft here. The most annoying numpy changes we have had to deal with are things that are merged just before the release and hence we didn't catch them in -dev.

Would it be an idea to freeze further ahead of a major release? With perhaps more advertising to test the corresponding -rc?

Alternatively (or additionally), maybe the way to do this is to be more flexible about when major releases happen, and decide on whether the next release will be major ~mid-way between releases, based on what is already ready there and what is being planned (with perhaps an astropy-dev mailing to ask what people are planning).

Part of this might also be to follow pandas' example and really make sure API changes are explained and work-arounds given.

One practical question: how is it going to work with major items? Are they just going to sit on as PR requests for ~1 year? Or is there a separate branch? As long as new features are OK for minor releases, I don't think this is a super-big issue, but probably should be discussed in the document!

Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should have read @saimn's message - agreed that if the cycle is flexible and we insist (as we should) that breaking changes have deprecation periods, that solves most of the problems.

Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

One practical question: how is it going to work with major items? Are they just going to sit on as PR requests for ~1 year? Or is there a separate branch? As long as new features are OK for minor releases, I don't think this is a super-big issue, but probably should be discussed in the document!

Yes new features are OK for minor releases. It's just the ones that break the API that should wait, with deprecation added in between. And that should be a minority of the PRs hopefully, so I guess we can just milestone them for the next major release and rebase when we start the major release cycle. Another way would be to have a "future" branch but if there are conflicts it will be more painful to resolve them compared to doing that for each PR.

* Refer to the x.0 releases every 2 years (e.g., v6.0) as "major"
releases, other releases every 6 months (e.g., v6.1) as "minor", and bug fixing
releases (e.g., v6.1.2) as "bugfix" releases.
* Minimize as much as possible any changes that break API or change results in
minor releases, but being pragmatic and accepting such changes if they would
not affect many users.
* Add deprecation warnings or future warnings in minor and major releases but only
go through with the breaking changes in major releases (either the next major
release following when a warning was added, or subsequent ones if the changes
are deemed to be high impact enough to wait longer).

With this in place, we would effectively be striving to maximize stability over
two-year periods but users would see deprecation warnings to prepare them for
changes. This is in contrast to the current LTS system where users might not see
a deprecation warning until the next LTS release as deprecations are not typically
backported.

Branches and pull requests
--------------------------

N/A
Copy link
Member

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Should we also link astropy/astropy#14713 here?


Implementation
--------------

This APE proposes to continue supporting the v5.0.x LTS series but to not
designate v6.0 as LTS.

Backward compatibility
----------------------

N/A

Alternatives
------------

<Remove placeholder below before merge>
If there were any alternative solutions to solving the same problem, they should
be discussed here, along with a justification for the chosen approach.

Decision rationale
------------------

<To be filled in by the coordinating committee when the APE is accepted or rejected>
hamogu marked this conversation as resolved.
Show resolved Hide resolved