RFC proposal for Guix

This process is followed when one intends to make "substantial" changes to the Guix project. What constitutes a "substantial" change is evolving based on community norms, but may include the following.

• Any change that modifies Guix API
• Big restructuring of packages
• Introduction or removal of subcommands

Certain changes do not require an RFC:

• Adding, updating packages, removing outdated packages
• Fixing security updates and bugs that don't break interfaces

A patch submission to Debbugs that contains any of the afore-mentioned substantial changes may be asked to first submit a RFC.

1. Clone https://git.savannah.gnu.org/git/guix.git
2. Copy rfc/0000-template.txt to rfc/00XY-good-name.txt where good-name is descriptive but not too long and XY increments
3. Fill RFC
4. Submit to guix-patches@gnu.org

Make sure the proposal is as well-written as you would expect the final version of it to be. It does not mean that all the subtilities must be considered at this point since that is the aim of review discussion. It means that the RFC process is not a prospective brainstorming and the proposal formalize an idea for making it happen.

The submission of a proposal does not require an implementation. However, to improve the chance of a successful RFC, it might be recommended to have an idea for implementing it. If an implementation is attached to the detailed design, it might help the discussion.

At this point, at least one other person must volunteer to be "co-supporter". The aim is to improve the chances that the RFC is both desired and likely to be implemented.

Once supporter and co-supporter(s) are committed in the RFC process, the review discussion starts. Advertisement of the RFC on the mailing-lists guix-devel is mandatory and IRC is recommended.

After a number of rounds of review, the discussion should settle and a general consensus should emerge. If the RFC is successful then authors may contribute to the implementation. This bit is left intentionally vague and should be refined in the future.

A successful RFC is not a rubber stamp, and in particular still does not mean the feature will ultimately be merged; it does mean that in principle all the major stakeholders have agreed to the feature and are amenable to merging it.

An unsuccessful RFC is not a judgment on the value of the work, so a refusal should rather be interpreted as “let’s discuss again with a different angle”. The last state of an unsuccessful RFC is archived under the directory rfcs/unsuccessful/.

A co-supporter is a contributor sufficiently familiar with the project’s practices, hence it is recommended, but not mandatory, to be a contributor with commit access. The co-supporter helps the supporter, they are both charged with keeping the proposal moving through the process. The co-supporter role is to help the proposal supporter by being the timekeeper and helps in pushing forward until process completion.

The co-supporter doesn't necessarily have to agree with all the points of the RFC but should generally be satisfied that the proposed additions are a good thing for the community.

It is up to the supporter and co-supporter to ensure that sufficient discussion is solicited. Let two weeks for people to comment is a good average. Make sure that all have the time for expressing their comments. The proposal is about significant changes, thus more time is better than less.

It is expected from all contributors, and even more so from committers, to help build consensus and make decisions based on consensus. By using consensus, we are committed to finding solutions that everyone can live with.

It implies that no decision is made against significant concerns and these concerns are actively resolved with proposals that work for everyone. A contributor, without or with commit access, wishing to block a proposal bears a special responsibility for finding alternatives, proposing ideas/code or explaining the rationale for the status quo.

To learn what consensus decision making means and understand its finer details, you are encouraged to read https://www.seedsforchange.org.uk/consensus.

Whoever merges the successful RFC should do the following:

1. Fill in the remaining metadata in the RFC header, including links for the original Debbugs submission.
2. Commit everything.

The structure of the RFC is captured by the template; see the file rfc/0000-template.txt. It is recommended to write using markup language as, for example, Org-mode or Markdown or reStructuredText.

None.

There is a risk that the additional process will hinder contribution more than it would help. We should stay alert that the process is only a way to help contribution, not an end in itself.

Of course, group decision-making processes are difficult to manage.

The ease of commenting may bring a slightly diminished signal-to-noise ratio in collected feedback, particularly on easily bike-shedded topics.

There are still questions regarding the desired scope of the process. While we want to ensure that changes which affect the users are well-considered, we certainly don't want the process to become unduly burdensome. This is a careful balance which will require care to maintain moving forward.

Will your proposed change cause a behaviour change? Assess the expected impact on existing code on the following scale:

1. No breakage
2. Breakage only in extremely rare cases (exotic or unknown cases)
3. Breakage in rare cases (user living in cutting-edge)
4. Breakage in common cases

Explain why the benefits of the change outweigh the costs of breakage. Describe the migration path. Consider specifying a compatibility warning for one or more releases. Give examples of error that will be reported for previously-working cases; do they make it easy for users to understand what needs to change and why?

The aim is to explicitly consider beforehand potential Backward Compatibility issue.