RustcContributor::new Curriculum Outline (DRAFT)

Prerequisites

• Familiarity with the Rust programming language and its syntax
• Basic understanding of how compilers work

Part 1: Setting Up Your Development Environment

1. Installing Rust
   • Overview of Rust installation options (Rustup, package managers, manual installation)
   • Installing Rust using Rustup
2. Setting up the Rust development environment
   • Overview of Rust development tools (Cargo, rustc, RLS, etc.)
   • Installing and configuring development tools (e.g. IDEs, editors, code formatters, linters)
   • Getting familiar with Cargo, Rust's package manager

Part 2: Understanding the Rust Compiler Codebase

1. Overview of the Rust compiler
   • High-level overview of the compiler's components and how they fit together
   • The role of the LLVM backend in the Rust compiler
2. Rustc source code organization

• Understanding the structure of the Rustc source code repository
• How to navigate and search the Rustc source code

3. Understanding Rustc's intermediate representation (IR)
   • Understanding MIR (Mid-level Intermediate Representation) and HIR (High-level Intermediate Representation)
   • How MIR and HIR relate to Rust code and the generated LLVM IR

Part 3: Contributing to the Rust Compiler

1. Identifying good first issues
   • How to find issues that are suitable for newcomers
   • What makes an issue "good" for beginners
2. Contributing code
   • Overview of Rust's contribution process (including code review and testing)
   • How to create a fork of the Rustc repository, make changes, and submit a pull request
   • Writing good commit messages and documentation
   • How to collaborate effectively with the Rust community (Discord, Zulip, Blogs)
3. Writing tests
   • Overview of Rust's testing infrastructure and conventions
   • How to write tests for the Rustc codebase
4. Debugging the Rust Compiler
   • Overview of Rust's debugging tools (GDB, lldb, etc.)
   • How to use debugging tools to diagnose and fix issues in the Rust compiler

Part 4: Additional Topics

1. Rustc development workflows
   • Developing features in feature branches
   • Continuous integration and testing
2. Code organization and architecture
   • Understanding Rustc's overall design and architecture
   • How to refactor and improve Rustc code
3. Contributing to other Rust projects
   • Overview of other Rust projects and how to contribute to them
   • How to apply the skills learned in Rustc development to other Rust projects

Collaborative content creation in a GitHub repo by all compiler contributors is an option for building this curriculum. Written content along with the videos of these sessions would be shared for those unable to attend live sessions. Live sessions would be offered at least once per quarter.

Running a pilot of each section separately would allow us to test each section and determine what is needed. We could reorder any of the sections or omit parts given what is learned from running the pilots.