---
# System prepended metadata

title: Rustc Contributor Program Major Change Proposal

---

# Rustc Contributor Program Major Change Proposal

## 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 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 for the pilot program. These people will...

* advertise for new participants, select the cohorts, schedule meetings
* recuit 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"](https://mojosd.medium.com/what-does-a-rustc-reading-club-do-8c9f9b336ff4), 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](https://mojosd.medium.com/rrc-phase-i-retrospective-74141fb246e4), and thus we are proposing this more structured program.

Although this program is building 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 contrbute 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 key 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 resource.
4. 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.
    - Prequisite 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.
4. 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.
4. 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
    * development of ::explore

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

* Curriculum for ::new
    * will determine 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, agenda, prerequisits and so on
    * Sign up forms
    * Calendars and invites
    * Acceptance and next steps emails for ::new
    * Retrospective forms for ::new, ::grow and ::explore
    * surveys



