Create Educator's Guide

src/config/sidebarConfig.ts

@@ -28,6 +28,25 @@ export const sidebarSections: Record<string, SidebarSection[]> = {
     },
   ],
 
+  // Educator's Guide section
+  '/educators-guide': [
+    {
+      label: "Educator's Guide",
+      items: [
+        { label: 'Introduction', slug: 'educators-guide/introduction' },
+        { label: 'The Stages', slug: 'educators-guide/introduction/the-stages' },
+        { label: 'Preparing Yourself', slug: 'educators-guide/introduction/preparation' },
+        { label: 'Stage 0', slug: 'educators-guide/stage0' },
+        { label: 'Stage 1', collapsed: true, items: [
+          { label: 'Overview', slug: 'educators-guide/stage1' },
+          { label: 'Stage 1A', slug: 'educators-guide/stage1/stage1a' },
+          { label: 'Stage 1B', slug: 'educators-guide/stage1/stage1b' },
+        ]},
+        { label: 'Stage 2', slug: 'educators-guide/stage2' },
+      ],
+    },
+  ],
+
   // Other Resources section (maps to /resources in content)
   '/other-resources': [
     {

src/content/docs/educators-guide/introduction/index.mdx

@@ -0,0 +1,51 @@
+---
+title: Educator's Guide Overview
+description: A guide for educators implementing the FRCSoftware.org Learning Course
+---
+
+The FRCSoftware.org Learning Course is a self-paced, comprehensive program that teaches FRC robot programming and Java skills. 
+This guide is intended to help educators effectively implement the course while supporting their students throughout the learning process.
+Designed for accessibility, the course requires minimal prior knowledge of physics or math, making it suitable for students from various backgrounds.
+The emphasis is on building knowledge through consistent practice and review.
+
+## Course Usage
+
+The course is built for self-paced learning, where students can progress at their own speed.
+It utilizes code and robot simulation, a tool standard throughout FRC programming, to enable students to see their work and results quickly and not require a specific robot, or any robot access.
+It can either be used by students to self-tach or in a more classroom-esque setting where it's led by student programming leads or mentors.
+
+<Aside type="note" title="Why Self-Paced?">
+Different people will have different starting points and different things they don't understand or struggle with. 
+Going at a set pace may cause some students to be bored and others to struggle and fall behind.
+</Aside>
+
+The ideal setup is for educators to offload most of the curriculum (concepts, exercises, projects) to the website, freeing them up to give more individualized help and review to each student.
+This is what may be called a “self-paced blended learning” approach, where preferably meeting time or class time is given for students to do the work at their own pace and for educators to review and catch mistakes as students are working through exercises and projects.
+
+This approach helps increase motivation and engagement, reduces gaps in knowledge, builds confidence, and helps make sure every student gets the support they need to learn.
+
+## Course Content
+
+While the initial Java content is taught via general exercises, the majority of the course is focused on teaching FRC programming skills through FRC-relevant exercises, where new skills and concepts are introduced in each project.
+Each section has a bit of explanation on the concepts or skills being introduced in the exercise, with the exercises gradually decreasing in guidance to help students get more confident with writing software.
+
+<Aside type="note" title="Why Java?">
+Java is the most popular language used in FRC by a significant margin ([source](https://community.firstinspires.org/more-reefscape-by-the-numbers-new-legal-devices "FRC Blog: More REEFSCAPE By The Numbers")).
+This means that there's an abundance of public code to refer to and that it's the easiest language to receive help for.
+Additionally, many students learn Java through AP Computer Science in school, giving them exposure to the language already.
+</Aside>
+
+The progression of the course moves from learning how to write Java to programming robots of increasing complexity, starting with individual mechanisms of robots and moving to full robots.
+Students will then learn how to write a robot program from the ground-up, thinking about code structure and how to best write their code for a balance between speed and maintainability.
+
+Additionally, there are various reference sections that don't fall on the main Learning Course. 
+These cover topics that are relevant to FRC programming, such as swerve or vision, but aren't necessarily the core concepts that need to be taught to allow a student to meaningfully contribute in-season.
+Generally, these topics are something only one student on a programming subteam would need to know, while the Learning Course focuses on the concepts every student will want to know to effectively contribute.
+
+The purpose of FRC software is to maximize the robot's capabilities in matches, working hand in hand with the robot's design and the team's strategy. 
+As such, this course places a focus on giving students the tools to write code efficiently and to maximize the use of time once the robot is complete.
+This includes heavy utilization of simulation to develop and validate code, structuring code to be both quick to write and easy to make changes and maintain in-season, and giving students the tools to evaluate when certain control strategies may be necessary or whether a simpler, but easier, strategy is appropriate.
+
+There are infinitely many ways to structure a robot project or control a mechanism, but this course gives what its writers believe to be the best balance of simplicity, maintainability, and capability.
+As such, how your team wrote code in the past isn't necessarily incorrect, it's just not how this course will be teaching.
+The concepts taught in this course should be applicable to most teams' code structure.

src/content/docs/educators-guide/introduction/preparation.mdx

@@ -0,0 +1,25 @@
+---
+title: Preparation
+description: A guide for educators to prepare themselves to deliver the Learning Course to students.
+---
+
+Before using the FRCSoftware.org Learning Course to teach your students, make sure you have an adequate understanding of the concepts covered.
+The best wya to do this is to go through the course yourself; however, the level of involvement with which you do so is dependent on your previous knowledge.
+If you're new to FRC programming or Java, we recommend going pretty deep through the course as much as you can, at least so you're ahead of the students you're helping guide.
+If you're pretty experienced with Java and FRC programming, you might just go through the Educator's Guide to get a complete overview of the course and caught up to date with practice.
+
+<Aside type="note">
+    While the commands v3 library retains many elements from the v2 library, there are many significant changes that impact how it is used and how to best structure code.
+    If you have experience with commands v2 but not v3, a deeper dive into the v3 library is recommended.
+</Aside>
+
+In particular, familiarizing yourself with the development environment, tools, and git is going to be particularly helpful to ensure that your students can focus on the code itself.
+Additionally, having such software on your own computer will allow you to demonstrate things for students without impacting their own code.
+
+## Final Advice
+
+1. Remember that is is ok for students to be at wildly different sections of the course.
+2. Even if a student just gets through stage 1, they would have enough knowledge to be somewhat helpful and easy to guide during build season.
+The more sections they complete, the more autonomous they should be as a developer, making them easier to lead to complete a task.
+3. When helping students, make sure ot not handhold them too much. 
+If you're in a situation where you can get the student to solve a problem by asking some guiding questions, do that.

src/content/docs/educators-guide/introduction/the-stages.mdx

@@ -0,0 +1,38 @@
+---
+title: The Stages
+description: An explanation FRCSoftware.org Learning Course stages for educators
+---
+
+The course progressively builds complexity while reinforcing core concepts of good software development practices, controls fundamentals, and code organization. 
+It starts with basic code to control a 2026 kitbot and progresses through more complex robots and mechanisms.
+
+## Stage Section Overview
+
+**Stage 0: Java Fundamentals**
+ - Sets up students with the development environment and required tooling
+ - Teaches students the Java concepts necessary for FRC software
+
+**Stage 1a: Basic FRC Programming**
+ - Introduces students to many of the development tools which will be used throughout the course and for general FRC development
+ - Provides an overview of FRC electronics
+ - Introduces students to the 2026 Kitbot, which will be utilized throughout Stage 1
+ - Teaches the basics of FRC motor controller and gamepad interaction
+ - Students will have a functional teleoperated kitbot program and a basic auto
+
+**Stage 1b: Introduction to Command-Based Programming**
+ - Introduces command-based programming
+ - Introduces logging and telemetry
+ - Introduces the concept of code structure and working with multiple files
+ - Covers the basics of PID control when applied to simple autonomous driving
+ - Students will have a functional teleoperated kitbot program and a more advanced auto
+
+**Stage 2: 2025 Robot**
+ - Introduces feedforward control and mechanism dynamics
+ - Provides techniques for additional teleoperated automation
+ - Students will write entire `Mechanism`s on their own
+ - Introduces commands v3 state machines
+ - Discusses various code structure and organization choices that will have to be made in any given robot project
+ - Covers one technique to prevent mechanisms from colliding with the rest of the robot
+
+Additionally, all stages will naturally include a significant amount of debugging experience as students write their code.
+Debugging is a critical skill that all students should know as, inevitably, some code won't work as expected on the first try.

src/content/docs/educators-guide/stage0/index.mdx

@@ -0,0 +1,8 @@
+---
+title: "Stage 0: Java Fundamentals"
+description: An overview of Stage 0 for educators
+---
+
+## Overview
+
+WIP

src/content/docs/educators-guide/stage1/index.mdx

@@ -0,0 +1,6 @@
+---
+title: Stage 1 Overview
+description: An overview of Stage 1 for educators
+---
+
+WIP

src/content/docs/educators-guide/stage1/stage1a.mdx

@@ -0,0 +1,6 @@
+---
+title: "Stage 1A: Basic FRC Programming"
+description: An overview of Stage 1A for educators
+---
+
+WIP

src/content/docs/educators-guide/stage1/stage1b.mdx

@@ -0,0 +1,6 @@
+---
+title: "Stage 1B: Introduction to Command-Based Programming"
+description: An overview of Stage 1B for educators
+---
+
+WIP

src/content/docs/educators-guide/stage2/index.mdx

@@ -0,0 +1,6 @@
+---
+title: Stage 2 Overview
+description: An overview of Stage 2 for educators
+---
+
+WIP

src/content/docs/index.mdx

@@ -35,6 +35,12 @@ import HomeCard from '../../components/HomeCard.astro';
     icon="book"
     description="Explains the main features of the website. Recommended to go through before the learning course."
   />
+  <HomeCard
+    title="Educator's Guide"
+    href="/educators-guide/introduction"
+    icon="book"
+    description="A guide for educators implementing the FRCSoftware.org Learning Course."
+  />
   <HomeCard
     title="Contribution"
     href="/contribution/methodsofcontributing"

src/starlightOverrides/Header.astro

@@ -13,7 +13,7 @@ const navLinks = [
   { href: "/feature-guide/", label: "Website Feature Guide" },
   { href: "/getting-started/intro-to-prog/", label: "Getting Started" },
 //   { href: "/learning-course/", label: "Learning Course" },
-//   { href: "/educators-guide/introduction/", label: "Educator's Guide" },
+  { href: "/educators-guide/introduction/", label: "Educator's Guide" },
 //   { href: "/design-handbook/", label: "Design Handbook" },
 //   { href: "/mechanism-examples/", label: "Mechanism Examples" },
 //   { href: "/best-practices/", label: "Best Practices" },