RFR: Roles in the OpenJDK [v4]

Wed Aug 11 00:04:32 UTC 2021

On Fri, 18 Jun 2021 13:56:10 GMT, Jesper Wilhelmsson <jwilhelm at openjdk.org> wrote:

>> Added a short intro about OpenJDK describing Groups, Projects, and different roles. The sections on how to progress through the Author, Committer, Reviewer roles needs a broad agreement since that's an area that affects everyone and where there historically has been a lot of debate. This is a first draft, please comment.
>
> Jesper Wilhelmsson has updated the pull request incrementally with one additional commit since the last revision:
> 
>   one of

A couple typos/spelling issues, maybe a bit of editorial suggestions. Updates can be done as part of this PR or in a later one, at your option.

src/index.md line 26:

> 24: :::
> 25: 
> 26: OpenJDK consists of a number of [Groups](https://openjdk.java.net/groups/). Members of a group collaborates on an area of mutual interest. The right hand side bar on the [OpenJDK website](https://openjdk.java.net/) has a list of all groups in OpenJDK. If you're interested in a specific area, this is where you would start your OpenJDK experience. Look at the group's information and wiki pages, and see what projects they sponsor on the [Census page](https://openjdk.java.net/census).

collaborates => collaborate

src/index.md line 34:

> 32: OpenJDK has a few different roles that determine who has the right to do what in the different projects. These roles are defined in the [OpenJDK Bylaws](https://openjdk.java.net/bylaws#project-roles). The roles are earned based on experience and knowledge within each project.
> 33: 
> 34: A Contributor can have different roles in different projects. When you're new to a project you don't yet have a formal role in that specific project, even though you might have earned roles in other OpenJDK projects or have been recognized as a [Contributor](https://openjdk.java.net/bylaws#contributor) or a [Member](https://openjdk.java.net/bylaws#openjdk-member) of OpenJDK. By contributing high-quality content you'll soon be eligible for [OpenJDK roles](https://openjdk.java.net/bylaws#project-roles) in the project. First [Author](https://openjdk.java.net/bylaws#author), then [Committer](https://openjdk.java.net/bylaws#committer), and finally [Reviewer](https://openjdk.java.net/bylaws#reviewer) if you stay active and earn the trust of the community. Trust is an important part of earning these roles. There's a [rough guideline](https://openjdk.java.net/projects/) saying that to become a [Committer](https://openjdk.java.net/bylaws#committer) you should have contributed 8 signific
 ant changes, and to become a [Reviewer](https://openjdk.java.net/bylaws#reviewer) you should have contributed 32 significant changes. In reality it's not as easy as "just" contributing code. You need to build a track record of good decisions and sound judgement and show that you know what differentiates a good change from a not so good one. It's not only correctness of the code that matters, it's also the appropriateness. In the end the trust you've earned is put to the test through a vote.

judgement => judgment

although this might be a difference between American and British spelling, up to you. If you want to use "judgement" throughout that's ok with me (I saw it in at least one other place).

src/index.md line 40:

> 38: Becoming an [Author](https://openjdk.java.net/bylaws#author) is the first step. To achieve this you need to contribute two non-trivial changes to the project in which you wish to become an Author. Once your changes are pushed into the code base and has been vetted enough to determine that the changes were indeed good changes you can go ahead and send an email to the project lead of that particular project and ask to be added as an Author.
> 39: 
> 40: As an Author you have the formal right to produce changesets for inclusion into the projects code base, but you will need a sponsor to perform the actual push. You'll also have write access to [JBS](#jbs---jdk-bug-system).

I think as an author you also have edit access to the wiki.

src/index.md line 44:

> 42: ### Becoming a Committer
> 43: 
> 44: To become a [Committer](https://openjdk.java.net/bylaws#committer) you should show that you can produce non-trivial changes that are accepted for inclusion into the project code base. The number eight has been seen as a formal lower limit on the number of changes, but since the changes must be non-trivial, or "significant" as the [OpenJDK Project description](https://openjdk.java.net/projects/) says, and the definition of significant is extremely subjective, the general recommendation is to wait with a Committer nomination until there's at least 10-12 changes pushed to have some margin for different interpretations of "significant".

I wouldn't say "extremely subjective" but I would agree that it is subjective. It's probably wise to have a few extra commits over the required 8 in case there is some difference of opinion. I think some advice to add here is to seek out a sponsor who will guide you through the process to becoming a Committer. This person might have actually sponsored some commits you developed as an Author. This person would also be responsible for running your Committer vote. They probably will have a better idea of what constitutes a "significant" change.

src/index.md line 67:

> 65: * Repeated follow-up bugfixes from earlier changes
> 66: * Larger changes where only a non-significant portion of the work was done by the Contributor under vote
> 67: * Trivial backports of someone else's changes

Maybe this section belongs in the Committer section? I think it's really the only place where the significance of a commit comes into play.

src/index.md line 77:

> 75: If you have a success story where Java solved your problem, or if you successfully upgraded to a more recent version of the JDK and noticed some improvements, spreading this story through a blog, news article, or some other channel is also a contribution.
> 76: 
> 77: If you're in a position to choose what programming language to use in a project, in a tutorial, or in a class, you have the power to enlarge the Java community in a very direct way, and your colleagues or students will get an opportunity to learn one of the most used programming languages in the world.

This is a good section, talking about contributions in general, not just code like everybody thinks it is.

One thing I'd suggest adding is finding and diagnosing bugs. If you see some misbehavior, or if you see somebody mention some misbehavior on some internet forum, try to track it down. Good bug reports with reproducible test cases are extremely valuable and make excellent contributions.

-------------

Marked as reviewed by smarks (Author).

PR: https://git.openjdk.java.net/guide/pull/60