diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md index d940ed16..d0bce9b1 100644 --- a/.github/ISSUE_TEMPLATE/feature_request.md +++ b/.github/ISSUE_TEMPLATE/feature_request.md @@ -6,7 +6,8 @@ labels: enhancement assignees: '' --- -**Is your feature request related to a problem? If so, please describe.** +**Is your feature request related to a problem? +If so, please describe.** A clear and concise description of what the problem is. Describe how the current behavior limits you or causes frustration. diff --git a/.github/ISSUE_TEMPLATE/website_issue.md b/.github/ISSUE_TEMPLATE/website_issue.md index bdfcdb4f..e1224cd5 100644 --- a/.github/ISSUE_TEMPLATE/website_issue.md +++ b/.github/ISSUE_TEMPLATE/website_issue.md @@ -10,7 +10,8 @@ assignees: '' A clear and concise description of the problem. **Where?** -Which page, component, or area of the site is affected? Include a URL if applicable. +Which page, component, or area of the site is affected? +Include a URL if applicable. **To Reproduce** Describe the steps needed to reproduce the issue. diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 4bf9796d..4b49725d 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -1,6 +1,7 @@ ## Description -What changed? Why? (the code + comments should speak for itself on the "how") +What changed? +Why? (the code + comments should speak for itself on the "how") We highly recommend including screenshots or a video of what was changed, to collect evidence in a place where we can later reference it. diff --git a/examples/stage0/snippets/loops.java b/examples/stage0/snippets/loops.java new file mode 100644 index 00000000..113fc915 --- /dev/null +++ b/examples/stage0/snippets/loops.java @@ -0,0 +1,53 @@ +/* + * Copyright 2026 FRCSoftware + * + * SPDX-License-Identifier: BSD-3-Clause + */ + +boolean condition = true; + +void main() { + // [whileSyntax] + while (condition) { + // code to run when condition is true + } + // [/whileSyntax] + + // [whileExample] + int i = 0; + while (i < 6) { + System.out.println(i); // prints 0, 1, 2, 3, 4, 5 + i++; + } + // [/whileExample] + + // [whileExample2] + int autoTime = 0; + while (autoTime <= 15){ + System.out.println("AutoMode is happening"); + autoTime++; + } + // [/whileExample2] + + + // [forExample] + for (int i = 0; i < 5; i++){ + System.out.println(i); // prints 0, 1, 2, 3, 4 + } + // [/forExample] + + // [Infinite1] + int timer = 0; + while (timer < 7){ + drivetrain.setThrottle(1); // sets drive motors to full speed + } + // [/Infinite1] + + // [Infinite2] + int timer = 0; + while (timer < 7){ + drivetrain.setThrottle(1); // sets drive motors to full speed + timer++; // increments timer by 1 + } + // [/Infinite2] +} \ No newline at end of file diff --git a/public/learning-course/stage0/loops/ForLoop.webp b/public/learning-course/stage0/loops/ForLoop.webp new file mode 100644 index 00000000..d1acde98 Binary files /dev/null and b/public/learning-course/stage0/loops/ForLoop.webp differ diff --git a/public/learning-course/stage0/loops/WhileLoop.webp b/public/learning-course/stage0/loops/WhileLoop.webp new file mode 100644 index 00000000..74e485d0 Binary files /dev/null and b/public/learning-course/stage0/loops/WhileLoop.webp differ diff --git a/src/content/docs/learning-course/stage0/loops.mdx b/src/content/docs/learning-course/stage0/loops.mdx new file mode 100644 index 00000000..f3dd49c3 --- /dev/null +++ b/src/content/docs/learning-course/stage0/loops.mdx @@ -0,0 +1,169 @@ +--- +title: Loops +description: An Intro loops in Java +prev: false +next: false +codeRegionSources: + default: stage0/snippets/loops.java +--- + +Oftentimes we want to do the same action multiple times in a row. +For instance, if you know your grades are about to be released, you might repeatedly check them until they come out. +In Java we can use loops to do this. + +We will be going over two types of loops which are: + +- while +- for + + + +Conditionals, and loops may seem similar but they have different purposes. +Conditionals are used to make decisions based on whether the condition is true or false. +Loops are used to repeat code until the condition is met. +This can be thought of conditionals make decisions, and loops are for repeating. + +## while + +`while` loops are the most simple type of loops. +If you have used block coding before, this is similar to the repeat block. +If you have taken an CS class, you might already be familiar with a `while` loop. + +The syntax of a `while` loops is as shown: + +```java #whileSyntax + +``` + +You might notice that a `while` loop has a similar syntax to conditionals, which was discussed in the previous section. +A `while` loop's syntax includes: + +- `while` is a keyword +- `( )` holds the condition that is either true or false. + Example: (5 > 1) is a condition and it is true because 5 is greater than 1 +- `{` an open bracket is used to denote the opening of the loop +- `}` a closed bracket is used to denote the end of the loop + +Another way of understanding how a `while` loop works is with the flow chart below + + + +Similar to conditionals, a `while` loop will run the code block inside the `while` loop when the condition is true. +After the code block is run, it goes back to the condition. +If the condition is true, the code block will run again. +This will repeat until the condition is false. +When it's false, the loop will be skipped. +To understand how this works, let's look at an example. + +```java #whileExample + +``` + +In the example, there is an `int` called `i` which holds the value 0. The `while` loop has the condition `i < 6`. +First, the compiler checks if the condition is true. +We know that 0 is less than 6 so the `while` code block runs and the value of `i`, which is currently 0, is printed to the terminal. +The value of `i` is also updated because of `i++` and it changes to 1. +Now the condition checks if 1 is less than 6. We know that it is true, so the value of `i` gets printed and the value of `i` is increased by 1. +This repeats and eventually `i`'s value becomes 6. +6 is not less than 6, therefore the loop is done and the `while` code block does not run. + + + +Lets look at an another example! +In the example below we have: + +```java #whileExample2 + +``` + +Without running the code, what do you think happens? + +`autoTime` is set to 0. The `while` loop's condition is `autoTime <= 15`. +0 is less than 15 so the code enters the `while` code block, and prints outs `Auto is happening`. +`autoTimer++` is run which increases `autoTimer`'s value by one. +The code goes back to the condition, 1 is less than 15, so the code enters the `while` code block again, printing out `Auto is happening`. +Like before, `autoTimer++` runs which increases `autoTimer` by one again making the value be 2. This repeats until `autoTime` is 15. When that happens the condition is false and the `while` loop is skipped. + +## for + +Sometimes, we might want code that loops an exact number of times. +This can be done with a `for` loop. +The syntax of a `for` is as follows: + +{/* rli:ignore */} + +```java +for (statement1; statement2; statement3) { + // code to run when statement 2 is true +} +``` + +In the syntax: + +- `for` is a keyword +- `()` holds the three statements +- `{` an open bracket is used to denote the opening of the loop +- `}` a closed bracket is used to denote the end of the loop + +The three statements are + +- initialization: creates a variable that sets the starting point of the loop. +- condition: a condition, which uses the variable, that is checked before each iteration. + If the condition is true, the code inside the loop runs +- update: updates the variable created in initialization after each iteration + +The best way to explain how `for` loops work is with an example. + +```java #forExample + +``` + +In this example, we create a variable `i` that is set to 0. When `i` is less than 5, the `for` code block runs, printing the value of `i` which is 0. +Then it goes back to the update statement which is `i++`, `i` has increased by 1 and `i`'s value is now 1. +We check the condition, 1 is less than 5, so `for` code block runs, the new value of `i` is printed, `i` is updated and this repeats until `i` is no longer less than 5. +When `i` is no longer less than 5, the `for` loop is skipped. + +Another way of understanding how a for loop works is with the flow chart below + + + +## Be Careful about Infinite Loops + +It is important to make sure that the condition can become false. +If the condition is always true, the loop will always run causing an infinite loop. +Infinite loops can be prevented by ensuring that the value inside the condition changes by incrementing or decrementing. + +```java #Infinite1 + +``` + +In this example, we want our drive train to run for 7 seconds. +We have our variable called `timer` which is set to 0. +0 is less than 7 so the code inside runs and the robot drives forward at full speed. +However, `timer`'s value never changes. +This means `timer` will always be 0. 0 is less than 7 so the loop will continuously run and the robot never stops driving! + +To fix this, we would make sure to increment the timer value as shown below. + +```java #Infinite2 + +``` + +`timer` now increments by 1 each time the loop is run, and the robot will stop driving after 7 seconds. + +## Loops Exercise + +