PEP 8002 – Open Source Governance Survey | peps.python.org
PEP 8002 – Open Source Governance Survey PEP 8002 – Open Source Governance Survey Author : Barry Warsaw <barry at python.org>, Łukasz Langa <lukasz at python.org>, Antoine Pitrou <solipsis at pitrou.net>, Doug Hellmann <doug at doughellmann.com>, Carol Willing <willingc at gmail.com> Status : Final Type : Informational Topic : Governance Created : 24-Aug-2018 Table of Contents Abstract Rationale Project choice Rust Key people and their functions Regular decision process Controversial decision process Planning a new release Changes in the process over time OpenStack Key people and their functions Regular decision process Controversial decision process Planning a new release Changes in the process over time Jupyter Key people and their functions Regular decision process Controversial decision process Voting Planning releases Changes in the process over time Django Key people and their functions Regular decision process Controversial decision process Differences between DEPs and PEPs Planning a new release Changes in the process over time TypeScript Key people and their functions Regular decision process Controversial decision process Planning a new release Changes in the process over time Astropy Key people and their functions Regular decision process Code-level decisions Non-code decisions Voting Controversial decision process Ethical issues Planning a new release Changes in the process over time Self-appreciation References Bonus: Microsoft Key people and their functions Regular decision process Controversial decision process Planning a new release Acknowledgements Annex 1: Template questions Copyright Abstract This PEP surveys existing and similar open source and free software projects for their governance models, providing summaries that will serve as useful references for Python’s own selection of a new governance model in the wake of Guido’s retirement .
Rather than an individual PEP for each of these community surveys, they will all be collected here in this PEP. Rationale CPython is not the first open source project to undergo a governance crisis. Other projects have experimented various governance options, sometimes several times during their existence. There are useful lessons to take away of their experience, which will help inform our own decision. Project choice There are many open source projects out there, but it will be most fruitful to survey those which are similar enough to CPython on a couple key metrics: the number of contributors and their activity (there are scaling issues that don’t make the governance models of very small projects very enlightening for our purposes) ; being mostly or partly community-driven (company-driven projects can afford different governance options, since the company hierarchy has power over the main participants) ; being faced with important design decisions that require a somewhat formal decision process.
Rust The governance structure is documented in Rust RFC #1068 . The effective governance process grows organically over time without being entirely codified as RFCs, especially in case of day-to-day operation details. One example is the formation of Domain Working Groups in February 2018. Key people and their functions In the Rust project there are teams responsible for certain areas. For language features there is a “lang team”, for tooling there’s “dev tools” and “Cargo”, and so on.
Contentious issues have facilitators to drive discussion who often aren’t the decision makers. Typically the facilitators are authors of the proposed changes (see “Controversial decision process” below). They ensure all key decision makers are involved along with interested community members. They push towards an agreeable outcome via iteration. In practice this means decisions are rarely escalated to the core team.
The most common role of a contributor is team membership. Issue triage/code review privileges without team membership is rare. Contributors have full commit access, code ownership separation is based on trust. Writing to the compiler repository is frowned upon, all changes go through pull requests and get merged by an integration bot after they were reviewed and approved. New team members are added by nomination by an existing team member.
Regular decision process Primary work happens via GitHub issues and pull requests. Approving a pull request by any team member allows it to be merged without further process. All merged pull requests end up in the next stable version of Rust. Notifying relevant people by mentions is important. Listening to the firehose of e-mails for all GitHub activity is not popular. There are planning and triage meetings open to the public happening on IRC and Discord.
They are not very popular because most of work happens through GitHub. Discussions also happen on official Rust forums ( https://users.rust-lang.org/ and https://internals.rust-lang.org/ ). There is a dedicated moderation team responsible for taking notes and enforcing code of conduct . Controversial decision process Larger or controversial work goes through a RFC process . It allows everyone to express their thoughts and iterates towards a resolution.
At some point when all blocking concerns of relevant team members are addressed, they sign off on the RFC and it reaches a “final comment period”. That does not require consensus amongst all participants, rather there should not be a strong consensus against the proposal. After 10 days the RFC is merged unless any new blocking concerns are raised by team members. A “merge” signifies that work towards implementing the feature and integrating it can now happen without interruption.
An RFC doesn’t have to have a reference implementation for it to be accepted. The other possible results of the “final comment period” are to: postpone the RFC (similar to the Deferred status in PEPs), get it back into discussion if blocking concerns can be addressed, or close it if blocking concerns are not solvable. When an RFC is marked as closed , there is a 7-day grace period to debate whether it should be closed.
In practice registering concerns with an RFC happens very often initially but rarely causes for the RFC to be entirely killed. This process scales well for small-contention changes and/or smaller changes. For the largest controversial changes the discussion gets unwieldy. This is a topic currently (as of August 2018) on the minds of the Rust team (see: “Listening and Trust, part 1” , “Listening and Trust, part 2” , “Listening and Trust, part 3” , “Proposal for a staged RFC process” ).
Planning a new release Every six weeks the Rust compiler is released with whatever it contained at the time. There are no LTS channels or releases yet but this concept is planned to make redistributors able to keep up with development better. Every few years a so-called “Edition” is released. Those are milestone releases with full sets of updated documentation and tooling. They can be backwards incompatible with previous editions.
External packages opt into breaking changes in their crate metadata. The Rust compiler supports all editions that existed prior to its release. Linking between crates of any supported edition is possible. Changes in the process over time The Rust programming language was started by Graydon Hoare who developed it as a personal project for a few years. When Mozilla started sponsoring the project, the team slowly grew with Graydon as a BDFL-style figure.
He left the project in 2013. Rust functions without a BDFL since. The RFC process was put in place later. Initially some design discussions happened during closed-door weekly video meetings which was shut down in May 2015 (before the 1.0 release of Rust), organically replaced with open discussion and direct influence of teams. The number of teams is growing in time. The number of technical decisions made by the core team is decreasing, instead those get delegated to
The rest of this page is on the live site.