Rustc Contributor Program Major Change Proposal

[doc-jones]

Rustc Contributor Program

Purpose

We propose to run with a pilot version of the RustcContributor program described in this document. The pilot program targets the rust compiler specifically. Assuming it is successful, we expect it to evolve into a permanent program, and to broaden its reach to the stdlib and potentially other Rust projects. The goal is to create a structure for helping people to onboard and contribute to the Rust compiler.

The RustcContributor plan

The plan has three parts that target different experience levels:

• RustContributor::new targets brand new folks and teaches them how to build, run, and test the compiler, as well as an overview of how it works. People apply to participate in ::new and those who are accepted commit to completing the program. The intent is that they will form a cohort of folks who continue to work and support each other going forward.
• RustContributor::grow picks up from ::new, targeting people who have made some contributions and giving structured introductions to different parts of the compiler. The goal is to have these keep running, so there's always some "grow" course happening at any point in time.
• RustContributor::explore targets highly experienced compiler contributors. Unlike new and grow, these sessions don't have much structure or even necessarily a "guide", it's basically just a recording of experienced compiler hackers talking about how some code works. These sessions will happen in an ad-hoc fashion, as people get inspired, and the recordings from them can be used to help form future grow lessons that are more broadly accessible.

Support from the compiler team

To support the program, we will need compiler team members to participate in various ways

• As instructions for new and grow sessions, preparing and delivering material.
• As mentors who attend office hours for new and grow sessions, both over zoom or on Zulip, helping to answer questions.
• As participants in explore sessions.

Running the program itself

Organizing the project will also be a lot of work. With the support of the Rust foundation, we have recruited several people willing to serve as program managers for the pilot program. These people will...

• advertise for new participants, select the cohorts, schedule meetings
• recruit instructors for new, grow, explore sessions
• publish and make available recordings and other artifacts
• survey and gather data on how well the program is working
• and so forth

Assuming the pilot is successful, we will eventually formalize this group into a team of some kind that can continue in a sustained fashion going forward.

First rustc, then expand

This program began as the "rustc reading club", with the idea that we would gather folks to sit down and read rustc code. We found that bridging the experience gaps for that exercise was too difficult, and thus we are proposing this more structured program.

Although this program builds on previous work, it is still very much experimental. A pilot will be run with the support of the Compiler Team and what we learn may be applied to other parts of rust-lang in the future.

Another expansion area of the program will provide alternate paths for graduates of the ::new program to follow. Some will decide to contribute in ways other than writing code. For example, some may want to contribute to the rust-dev-guide, and others may want to take on PM roles. These are additional paths that will be available to participants in the program.

The Rustc Contributor Program will run experimental cohorts described below. This first pilot will consist of ::new, ::grow, and ::explore cohorts.

Curriculum for ::new and ::grow

It is vital that the curriculum for ::new, and ::grow sessions that support graduates of ::new, are more prescribed to aid the instructors of these parts of the program. This will enable more compiler team members to participate as instructors. In areas where the level of expertise for instructors is lower the curriculum should be stronger and more prescribed.

RustcContributor::new

1. Goals: Those who join a ::new cohort will learn the basics of being a contributor to rustc including the general structure of the compiler, the contribution submission process (e.g., build, diagnostics, and testing processes). Cohorts will also be introduced to documentation for the compiler like the rustc-dev-guide.
2. Inputs
   • Cohort members will already know how to write code in Rust.
   • PM to guide the operations of ::new.
   • Compiler team instructors.
   • Mentors to staff office hours - 2 per session.
   • Defined curriculum.
   • Selection process.
   • Compute resources.
3. Outcomes
   • Cohort members who attend all sessions of ::new will be prepared to join ::grow cohorts that are designed for new contributors.
   • Videos will be produced of some parts of ::new sessions. Q&A will not be recorded.

RustcContributor::grow

1. Goals: Those who join a ::grow cohort will have an instructor-led series of tasks at a prescribed experience level (e.g., completed ::new, contributors to other areas of rust-lang) that allow them to understand a compiler module or process. One example of a ::grow cohort will focus on learning Pernosco for inspecting new (to them) code. A different session on Pernosco will focus on using the tool for debugging. Another example might be learning salsa or possibly the name resolver.
2. Inputs
   • A qualified instructor recruited by the compiler team leads.
   • Prerequisite guidelines from the instructor.
   • Mentors to staff office hours - 2 per session.
   • Introduction to relevant documentation.
   • An appropriate set of tasks to meet the goals and outcomes for the session.
   • Compute resource.
3. Outcomes
   • Cohort members who attend all sessions of an instance of ::grow will understand how to inspect and understand the module presented and confidently choose issues for contribution.
   • Videos will be produced of all ::grow sessions and shared publicly.

RustcContributor::explore

1. Goals: Existing compiler contributors will use ::explore to build self forming cohorts to jointly poke at some compiler module that they want to understand better. Alternatively, compiler contributors will recruit a module expert/maintainer to lead them through a tour of the code and answer questions. This differs from ::grow as it requires expert level understanding of the compiler to join the cohort.
2. Inputs: need thoughts of Felix, Wes and Niko here
3. Outcomes: same as above
   • Videos

Measuring Success

1. Goals: We need multiple checks to determine the progress of ::new, ::grow, and ::explore.
2. Inputs
   • Retrospective for each cohort of ::new and ::grow at the end of the session.
   • Participation in a future ::grow cohort following completion of ::new.
   • Automated checks for contributons.
   • Survey 3 mos. following completion of ::new and ::grow.
3. Outcomes
   • Data to provide insight into how the program is doing, reporting to stakeholders and the community, and/or changes that may need to be implemented.

---

Current Filled Roles

• Doc Jones
  • visionary, owns the program
• Felix, Wesley
  • leads of Rust compiler team
  • stakeholders, potential instructors
  • help with recruiting and organizing other volunteers
  • getting the team on board
• Niko
  • potential instructor
  • spirit animal :eagle: :fish:
• Tyler Mandry
  • foundation board member but also an open source contributor
  • stakeholder
  • other roles as id'ed by Tyler
• Jan Schenk, Alice Ceile
  • PMs
• Santiago Pastorino
  • PM for ::explore

Development Tasks - some of these will be the result of early sessions

• Curriculum for ::new
  • will determine the duration needed to meet agreed goals
  • will determine weekly content and tasks to perform
  • how-to docs/handouts?
• Curriulum for ::grow
  • less prescriptive than ::new
  • there may be multiple "types" of sessions and likely this be built as a result of early sessions including instructor and cohort feedback through retrospectives
• Lots o templates
  • Announcements of sessions to include dates, schedule, prerequisites, and so on
  • Sign up forms
  • Calendars and invites
  • Acceptance and next steps emails for ::new
  • Retrospective forms for ::new, ::grow and ::explore
  • surveys

[rustbot]

This issue is not meant to be used for technical discussion. There is a Zulip stream for that. Use this issue to leave procedural comments, such as volunteering to review, indicating that you second the proposal (or third, etc), or raising a concern that you would like to be addressed.

cc @rust-lang/compiler @rust-lang/compiler-contributors

[sladyn98]

Hello, reading this issue seems like this program, has not yet been announced yet. I would like to volunteer to be part of the ::new program as a new contributor to the rust compiler, not sure if there is a timeline for this cohort to being. But excited to see this come to fruition.

[doc-jones]

Hello there @sladyn98! There is a stream on Zulip called RustcContributor::new where you can express your interest and also to get updates. I'm writing one right now. :)

[apiraino]

Closing MCP as per MCP process.

Seems the initiative started anyway and streaming are happening on Zulip on these streams:

• #RustcContributor::explore
• #RustcContributor::new
• #RustcContributor::grow

[apiraino]

Reopening since the RustcContributor initiative MCp will be be updated after the pilots have completed (Zulip comment)

[rustbot]

This issue is not meant to be used for technical discussion. There is a Zulip stream for that. Use this issue to leave procedural comments, such as volunteering to review, indicating that you second the proposal (or third, etc), or raising a concern that you would like to be addressed.

cc @rust-lang/compiler @rust-lang/compiler-contributors

[pnkfelix]

We discussed this MCP during today's T-compiler planning meeting, see: https://rust-lang.zulipchat.com/#narrow/stream/238009-t-compiler.2Fmeetings/topic/.5Bplanning.5D.202023-06-02/near/363063611

We decided that we are going to close this, not as a way to say "do not do this", but rather as a way to say "the team is not investing effort directly into this right now."

(I have some additional opinions on better ways to approach this going forward, you can see the linked zulip chat for some of those thoughts. But this github issue is for tracking administrivia, not technical details, so I'll leave it at that.)

but, p.s.: closing the MCP does not mean "no one is allowed to do anything in this space".

[sladyn98]

Thanks to everyone that invested efforts in this program I had the privilege of attending some sessions and it has helped me bootstrap the compiler and get started on a bunch of PRs I am still a newbie by all means so If anyone is still interested or ever has ideas in this space, I would be interested in becoming a mentee and learning more.