Hi Tomas, Everyone.

This seems like a good thing to discuss separately from the original

On 2018-03-02 22:06:32 +0100, Tomas Vondra wrote:
> Can you guys please point me to the CF rules that say this? Because my
> understanding (and not just mine, AFAICS) was obviously different.
> Clearly there's a disconnect somewhere.

I think we generally have documented the CF process very poorly.  Way
too much of it was discussed in-person at developer meetings (with notes
taken), is buried in deep threads arguing about release management or
individual commitfests.  A lot of the wiki information is outdated too.

Thus I'm trying to summarize my understanding in this email. It probably
doesn't 100% match other people's understanding. After we've resolved
those differences, we should update the wiki page, and delete outdated

A single Commitfest is commonly called CF.

== Goal ==

Commitfests primarily exists so:

- we do not accidentally loose track of patch submissions that deserve
  attention, that previously happened frequently
- that reviewers and committers quickly can find patches deserving their
  attention (i.e. ones in in needs-review and ready-for-committer
- that there's a single point documenting the state of the patch, to
  avoid situations where different people interpret a thread differently
  without noticing.

== Entries ==

A commitfest entry is a patch, or set of patches, implementing some goal
(e.g. a new feature, some cleanup, improved docs). Each commitfest entry
is associated with one or more email threads, that discuss the feature.

A patch can be authored by multiple people, and the set of people
actively working on a patch can change.

Submitting a patch as a commitfest entry to a specific commitfest
implies a statement by the author that the patch needs input from
others. That input can be agreement on design decisions, high level code
review, testing, etc.

A CF entry can be in multiple states:

- Needs Review: this means that the patch author needs input to
  continue. While there may be some concurrent activity, the author will
  stall at some point without he input.

- Waiting for Author: there has been feedback to the author that makes
  continuing review unproductive. The most desirable case for that is
  because there has been a detailed review describing issues with the
  current implementation, which the patch author is expected to address
  or discuss.  Another reason might be that the current patch doesn't
  apply to the source tree anymore, and a rebased version of the patch
  is needed.

- Ready for Committer: reviewers have reviewed the patch and are,
  presumably after a few rounds of patch updates, happy with the current
  state and think the patch needs the attention of a committer. That can
  be because the patch is ready to commit, or because the design has
  evolved as far as it can without validation from somebody potentially
  willing to commit the patch.

- Committed: The patches associated with the CF entry have been

- Rejected: The project has decided that the patch in the current form
  is not desirable.

- Returned with Feedback: The patch has gotten review indicating that it
  needs nontrivial changes, and the author did not have time and
  resources to perform them within the time of the current commitfest,
  or shortly thereafter.  It might be set because the author indicated
  so explicitly, stopped responding, etc.

- Moved to next CF: The patch was in needs review state, but either the
  current commitfest is about to end, or the patch is clearly in a state
  that is inappropriate for the current commitfest. The latter usually
  only matters in the last commitfest in a release cycle, more about
  that below.

== Commitfest Process ==

Commitfests start at a certain date. To avoid timezone issues, the
cutoff is when the start day has begun everywhere on the world.

All patches to be considered in that CF have to be submitted the day
before the start date, and either be in Needs Review or Ready for
Committer state.  That requirement exists because the goal of commitfest
is to provide input to patch authors so the patch can evolve and to not
forget patches that ought to be committed.

During a commitfest reviewers look at patches and provide feedback to
the authors. In the best case reviewers respond within a few days,
adapting the patch, answering changes, etc.

If the reviewers think a CF entry is ready for commit (or need design
input from a committer), the patch is set to Ready for Committer. Some
committer will hopefully come along and either commit the patch, or
explain what should happen in their opinion. Thus the followup states
can be Committed, Needs Review, Waiting on Author.

If patches are in Waiting for Author state for a while, after a
"warning" by the CF manager or reviewers, the patch will be marked as
Returned with Feedback, signaling that the project is not expected to
continue working on the patch.  If a patch needs extensive changes
(i.e. it's unrealistic they are made before the end of the current CF)
it often also can make sense to mark such patches as Returned with
Feedback, but input by the authors should be sought.

If patches are in Needs Review state at the end of the commitfest, the
patch will be moved to the next commitfest. If they are Waiting on
Author, the patch should be marked as Returned with Feedback.

== Last Commitfest ==

The last commitfest is the CF before the expected feature freeze date
for the current yearly postgres release.

A few extra restrictions are in place, to make it more likely to finish
features that have a realistic chance of ending up in the current

No nontrivial patches that have not previously been submitted to an
earlier CF should be entered into the CF. Otherwise new and shiny
patches will take up all the bandwidth from patches that have been
worked on for a long time.

Additionally patches that cannot realistically be finished within the
last commitfest will aggressively be moved to the next commitfest early,
to avoid using up resources that should be used to finish features for
the current release.

== Commitfest Manager ==

The commitfest's manager is determined at the beginning of the
commitfest. Sometimes multiple people will serve that role for a single
CF, to share the load.

Their role is to attempt to ensure that patches in the commitfest are in
an appropriate state, to bring up when that's not the case, and to
attempt to get all patches a fair amount of attention.

What do others think, is this a reasonable description of the *current*
process? Where do you think it is inaccurate?  I'd appreciate if we
could discuss *improvements* to the process separately. Let's first
agree on where we are.


Andres Freund

Reply via email to