diff --git a/examples/stage0/snippets/src/JavaFundamentals.java b/examples/stage0/snippets/src/JavaFundamentals.java
index 150edae5..ac936f06 100644
--- a/examples/stage0/snippets/src/JavaFundamentals.java
+++ b/examples/stage0/snippets/src/JavaFundamentals.java
@@ -3,10 +3,13 @@
  *
  * SPDX-License-Identifier: BSD-3-Clause
  */
+int matchTime = 0;
+
 // [variables]
-int CLIMBER_ID = 51;
-double UP_POSITION = -33.5;
-double DOWN_POSITION = 0;
+int CLIMBER_ID = 51; // an integer named CLIMBER_ID that holds the value 51
+double UP_POSITION = 33.5; // a double named UP_POSITION that holds the value 33.5
+boolean isFinished = false; // a boolean named isFinished that holds the value false
+String autoName = "Side Auto"; // a String named autoName that holds the value "Side Auto"
 // [/variables]
 
 void main() {
@@ -15,10 +18,24 @@ void main() {
     // [/printLiteral]
 
     // [printVariable]
-    int number = 4;
-    System.out.println(number); // prints out the value 4
+    int num = 4;
+    System.out.println(num); // prints out the value 4
     // [/printVariable]
 
+    // [stringConcatenation1]
+    double speed = 1;
+    System.out.println("Left Motor Speed " + speed);
+    //[/stringConcatenation1]
+    
+    // [stringConcatenation2]
+    int first = 6;
+    double second = 2.0;
+
+    System.out.println(first + " " + second); 
+
+    //[/stringConcatenation2]
+
+
     // [singleLineComment]
     // This prints Hello World
     System.out.println("Hello World");
@@ -33,4 +50,14 @@ void main() {
     This is another line */
     System.out.println("Hello World");
     // [/multiLineComment]
+
+    // [goodComment]
+    // Calculate how long is left in the match and show it to the drivers
+    System.out.println(150 - matchTime);
+    // [/goodComment]
+
+    // [badComment]
+    // Print 150 minus matchTime
+    System.out.println(150 - matchTime);
+    // [/badComment]
 }
diff --git a/examples/stage0/snippets/src/Operators.java b/examples/stage0/snippets/src/Operators.java
index aecf4f1a..8ab2c813 100644
--- a/examples/stage0/snippets/src/Operators.java
+++ b/examples/stage0/snippets/src/Operators.java
@@ -10,11 +10,6 @@
 // [/variables]
 
 void main() {
-    // [multiplication]
-    int magicNumber = 6;
-    System.out.println(magicNumber * 2);
-    // [/multiplication]
-
     // [increments]
     int x = 6;
     int y = 7;
@@ -50,4 +45,17 @@ void main() {
     System.out.println(fiveIsGreaterThanThree || nineIsLessThanTwo);
     System.out.println(!fiveIsGreaterThanThree);
     // [/logical]
+
+
+    // [math1]
+    int e = 0;
+    int f = 2;
+    System.out.println(e = f + 10); // prints 12
+    // [/math1]
+
+    // [math2]
+    int magicNumber = 6;
+    System.out.println(magicNumber * 2); // prints 12
+    // [/math2]
+
 }
diff --git a/examples/stage0/solutions/src/Print.java b/examples/stage0/solutions/src/Print.java
index afb41697..550e8f0c 100644
--- a/examples/stage0/solutions/src/Print.java
+++ b/examples/stage0/solutions/src/Print.java
@@ -17,7 +17,7 @@ void main() {
     System.out.println("It knows this because it knows where it isn't.");
 
     // Define a variable `pi` that is equal to 3.14159.
-    // HINT: Make sure to pick the correct datatypes.
+    // HINT: Make sure to pick the correct data types.
     double pi = 3.14159;
     // Define an variable `g` that is equal to 10.
     int g = 10;
@@ -25,13 +25,7 @@ void main() {
     String mode = "autonomous";
 
     // Now, print all three variables in the **same** print statement,
-    // separated by spaces. You can do this by passing in the three variables, and
-    // "adding" an empty string (" ") in between each pair, as if you were adding
-    // two numbers together, using the `+` operator. Ex. [pi + " " + g].
-    // Java recognizes that one of the items being added is a string, and
-    // converts the items on either side to a string before combining everything.
-    // This method of combining strings via the `+` operator is known as string
-    // concatenation.
+    // separated by spaces.
     System.out.println(pi + " " + g + " " + mode);
 
     // Now, change pi to equal 3.142857 (a slightly incorrect approximation of pi
@@ -42,7 +36,7 @@ void main() {
     // Create a variable `degrees` of type `double` and assign it a value of
     // 360. Then, print the variable to observe type narrowing behavior
     // (it prints 360.0 with a decimal part, instead of just 360, since the
-    // variable uses a dataype with decimal parts).
+    // variable uses a data type with decimal parts).
     double degrees = 360;
     System.out.println(degrees);
 }
\ No newline at end of file
diff --git a/examples/stage0/templates/src/Print.java b/examples/stage0/templates/src/Print.java
index d9c5cb2c..7d9eceb1 100644
--- a/examples/stage0/templates/src/Print.java
+++ b/examples/stage0/templates/src/Print.java
@@ -14,7 +14,7 @@ void main() {
 
 
     // Define a variable `pi` that is equal to 3.14159.
-    // HINT: Pick the correct datatypes.
+    // HINT: Pick the correct data types.
 
 
     // Define a variable `g` that is equal to 10.
@@ -25,13 +25,7 @@ void main() {
 
 
     // Now, print all three variables in the **same** print statement,
-    // separated by spaces. You can do this by passing in the three variables, and
-    // "adding" an empty string (" ") in between both pairs, as if you were adding
-    // two numbers together, using the `+` operator. Ex. [pi + " " + g].
-    // Java recognizes that one of the items being added is a string, and
-    // converts the items on either side to a string before combining everything.
-    // This method of combining strings via the `+` operator is known as string
-    // concatenation.
+    // separated by spaces.
 
 
     // Now, change pi to equal 3.142857 (a slightly incorrect approximation of pi
@@ -41,6 +35,6 @@ void main() {
     // Create a variable `degrees` of type `double` and assign it a value of
     // 360. Then, print the variable to observe type narrowing behavior
     // (it prints 360.0 with a decimal part, instead of just 360, since the
-    // variable uses a dataype with decimal parts).
+    // variable uses a data type with decimal parts).
 
 }
\ No newline at end of file
diff --git a/public/learning-course/stage0/conditionals/else.webp b/public/learning-course/stage0/conditionals/else.webp
deleted file mode 100644
index 8927b166..00000000
Binary files a/public/learning-course/stage0/conditionals/else.webp and /dev/null differ
diff --git a/public/learning-course/stage0/conditionals/elseif.webp b/public/learning-course/stage0/conditionals/elseif.webp
deleted file mode 100644
index 4bfa4931..00000000
Binary files a/public/learning-course/stage0/conditionals/elseif.webp and /dev/null differ
diff --git a/public/learning-course/stage0/conditionals/ifstatement.webp b/public/learning-course/stage0/conditionals/ifstatement.webp
deleted file mode 100644
index 86cfa5cf..00000000
Binary files a/public/learning-course/stage0/conditionals/ifstatement.webp and /dev/null differ
diff --git a/src/content/docs/learning-course/stage0/conditionals.mdx b/src/content/docs/learning-course/stage0/conditionals.mdx
index 1229fda6..ae1bd886 100644
--- a/src/content/docs/learning-course/stage0/conditionals.mdx
+++ b/src/content/docs/learning-course/stage0/conditionals.mdx
@@ -8,9 +8,9 @@ codeRegionSources:
 ---
 
 In everyday life, we make decisions based on different situations.
-Such as "If we are hungry, then we get a snack" or "If we are tired, we go to bed".
-Often in code, we want our program to do something similar and make different decisions based on different situations.
-When programming a robot, one example could be "If the timer starts, drive the robot for 5 seconds then stop when the timer reached 15 seconds.
+For example, "If we are hungry, then we get a snack" or "If we are tired, then we go to bed."
+Robots often need to make different decisions depending on the situation.
+For example, "If the timer starts, drive the robot for 5 seconds" or "If the timer is 0, stop driving."
 To add decisions to our code, we use conditionals.
 
 This section will cover three types of conditionals which are:
@@ -26,14 +26,9 @@ This section will cover three types of conditionals which are:
     conditional.](https://www.w3schools.com/java/java_switch.asp)
 </Aside>
 
-Like we mentioned earlier in [Java Fundamentals](/learning-course/stage0/java-fundamentals/), all programming languages have syntax that needs to be followed.
-One part of syntax is keywords.
-As a reminder, a keyword is a reserved word that the compiler uses to run the code.
-In Java, we use the following keywords for conditionals: `if`, `else if`, `else`
-
 ## if
 
-An `if` statement is a basic conditional.
+An `if` statement runs code only if a specified condition is true.
 The syntax for an `if` statement is as follows:
 
 ```java #ifSyntax
@@ -48,8 +43,7 @@ Let's break down what this means:
 - `{` an open curly braces is used to denote the opening of the conditional
 - `}` a closed curly braces is used to denote the end of the conditional
 
-The code in between the opening and closing curly braces are called a "code block".
-A code block a sequence of code that is enclosed in curly braces.
+The code in between the opening and closing curly braces is called a "code block".
 
 <Aside type="tip">
     All conditionals follow a very similar syntax. They all start with a
@@ -60,20 +54,9 @@ A code block a sequence of code that is enclosed in curly braces.
 `if` statements can make decisions based on the `condition` inside the parentheses.
 If `condition` is true, the code inside the `if` block will run.
 If `condition` is false, the code inside the `if` block will be skipped.
-This is also described in the flowchart below
-
-<ContentFigure
-    src="/learning-course/stage0/conditionals/ifstatement.webp"
-    width="400px"
-    height="800px"
-/>
 
 Now let's look at an example.
-In this example, pretend that we have a robot with a distance sensor on it.
-A distance sensor detects and reports how far or how close the robot is to an object.
-We want our robot's drivetrain motors to keep spinning until the robot is 10cm away from an object.
-Our robot is currently 6cm away.
-Looking at the example below, what should happen?
+In this example, this code will only tell the drivetrain to move forward when distance is smaller then 10.
 
 ```java #ifExample
 
@@ -100,15 +83,8 @@ The syntax for an else statement is as follows:
 Here's how this works: if the`if` statement's condition is `true`, then the code inside will run.
 If the `if` statement's condition is `false`, the `if` block will be skipped, and the code inside the `else` block will run.
 
-This is also described in the flowchart below
-
-<ContentFigure
-    src="/learning-course/stage0/conditionals/else.webp"
-    width="600px"
-    height="800px"
-/>
-
-In this example, we now have an `else` statement that sets the motor speed to 0 if `distance` is greater than 20. Since our `distance` is set to 21, what would the code print out?
+In this example, we now have an `else` statement that sets the motor speed to 0 if `distance` is not less than 10.
+Since our `distance` is set to 21, what would the code print out?
 
 ```java #elseExample
 
@@ -120,10 +96,8 @@ The `else` runs and it prints out "Motors are not spinning", and the motors are
 
 ## else if
 
-Sometimes we want our code to have specific logic for multiple cases.
-Often we want the robot to slow down as it approaches its target.
-Let's say we want the robot to drive at half speed when it's 5cm away from its target.
-This can be done by adding an `else if` statement.
+`if` and `else` lets you choose between two options, but what if you wanted to choose between even more options?
+`else if` statements let you choose between as many conditions as you like.
 
 The syntax for an `else if` statement goes as follows:
 
@@ -139,13 +113,6 @@ If `conditionA` is true then the code inside the `if` block will run.
 If `conditionA` if false, then it will go to the `else if` statement.
 If `conditionB` is true, the code inside the `else if` block will run.
 If `conditionB` if false, then it will exit the statement and none of the code will run.
-This is also described in the flowchart below
-
-<ContentFigure
-    src="/learning-course/stage0/conditionals/elseif.webp"
-    width="700px"
-    height="800px"
-/>
 
 In the example, we now have an `else if` statement that sets the motor to half speed if the distance from an object is less than 10cm.
 Our `distance` is now 15cm.
diff --git a/src/content/docs/learning-course/stage0/java-fundamentals.mdx b/src/content/docs/learning-course/stage0/java-fundamentals.mdx
index 4dfe2098..8a8af556 100644
--- a/src/content/docs/learning-course/stage0/java-fundamentals.mdx
+++ b/src/content/docs/learning-course/stage0/java-fundamentals.mdx
@@ -9,41 +9,33 @@ codeRegionSources:
 
 ## Syntax
 
-As you start programming, you might make a mistake or make a typo.
-When that happens, your code will have a red line under it.
-This is because Java has rules called syntax.
-Syntax is a set of rules that have to be followed so that the computer can understand and run your code.
-It’s important to pay attention to the syntax!
-If your code has a red line under it, first check whether the syntax is correct.
-This can be done by researching online or by comparing your code with examples.
-
-You can also learn what’s wrong with your code when you put the cursor over the section of the code with the red line and read what the error message is.
-Error messages will not tell you exactly what's wrong with your code.
-If you’re unsure on what the error message means, you can look it up to get additional context.
-
-<Slides>
-![Slide 1](/learning-course/stage0/java-fundamentals/ErrorExample1.webp) An example of a syntax error (note the squiggly line)
-
-![Slide 2](/learning-course/stage0/java-fundamentals/ErrorExample2.webp) An example of a syntax error popup
-
-</Slides>
+Syntax is the basic set of rules that all programs in a language must follow.
+It's similar to writing.
+In writing, the first word in a sentence has to start with a uppercase letter or all sentence need in a period.
+Java's syntax is very specific, there are different rules for how certain lines of code are written.
+Syntax errors are the most common sorts of errors.
+Whenever the syntax is mentioned, pay attention closely.
 
 ## Variables
 
 Variables are containers that are used to store information in a program.
 This could be a variable that holds the temperature or a variable that holds the speed of the motor.
 
-Variable declarations have the following syntax:
+To make a variable, there are 5 parts:
 
-{/* rli:ignore */}
+1. Data type
+2. Name of the variable
+3. Equals sign
+4. Value
+5. Semi-colon
 
-```java
-Datatype name = value;
-```
+### Data Types
 
 Data types refer to the type of value that our variable has.
-It helps tell our program more information about our variables such as what type of information it holds and how it can be used.
-Data types can include numbers, characters, or a string of words.
+It tells our program more information about our variables such as what type of information it holds and how it can be used.
+Unlike some programming languages such as Python, in Java every variable must have a type.
+This makes your programs more reliable and helps prevent some common errors because the compiler will prevent you from using the wrong type with an error.
+
 Some example data types that are commonly used in FRC programming are:
 
 - int: Integer numbers that are positive or negative.
@@ -56,16 +48,25 @@ Some example data types that are commonly used in FRC programming are:
 - String: Holds a sequence of characters.
   Denoted by double quotes (").
   Example: “Hello World”
-- char: Holds a single character.
-  Denoted by single quotes (').
-  Example: 'A'
 
-The name of your variable can be almost anything you want, but it should be easy to read and make sense to others who may be reading your code.
-One major exception is spaces, which are forbidden in variable names.
-Instead, you should write variables in what's known as camel case (`frontLeftDrive`).
-Upper snake case (`FRONT_LEFT_DRIVE`) should be used instead for constants, which we will learn about later in the course.
-Variable names can have numbers at any point except for the first character.
-(`motor2` is a valid name, `2motor` is not).
+<Aside type="note">
+    When creating a String, make sure the S is capitalized! `string robotName =
+    "Plunk"` will throw an error but `String robotName = "Plunk"` will not.
+</Aside>
+
+### Name
+
+In Java, variable names may only consist of letters, numbers, and underscores (`_`), but variable names cannot start with a number.
+The name of the variable can be whatever you want, however, we recommend making them descriptive and easy to read.
+This will make it much easier for you to understand your own code and for others to help you.
+
+One common variable naming style is camel case, where each word is capitalized except the first.
+For example, `frontLeftDrive`, `currentTemperature`, and `targetPosition` are all camel case.
+Another common variable naming style is upper snake case, where each word is capitalized and an underscore is used in between each word.
+For example: `BACK_LEFT_DRIVE`, and `GEAR_RATIO` are in upper snake case.
+
+When programming a robot, camel case is commonly used for creating variables.
+Upper snake case is used for constants which are variables that are defined once and are not changed.
 
 <Aside type="note">
 Java is a case-sensitive programming language!
@@ -75,14 +76,72 @@ Even though it’s spelled the same, if your variable name is MotorID then you t
 
 </Aside>
 
+Creating variable names can be fun, but the names should be
+As mentioned, we recommend making them descriptive and easy to read
+
+Using an intake motor as an example, here are some bad and good variable names:
+
+<table class="Variable Names">
+    <thead>
+        <tr>
+            <th>Bad</th>
+            <th>Good</th>
+        </tr>
+    </thead>
+    <tbody>
+        <tr>
+            <tr>
+                <td>
+                    `F` Avoid short or one letter variable names. It's not
+                    descriptive and doesn't make it clear what the variable is
+                    for.{' '}
+                </td>
+                <td>
+                    `FrontLeftMotor` Clearly describes what the variable name is
+                    for and it's easy to read.
+                </td>
+            </tr>
+            <td>
+                `Bingo` Avoid using random words. It makes it hard to know what
+                the variable is for.{' '}
+            </td>
+            <td>
+                `BackLeftMotor` The variable name is easy to read and it's
+                descriptive.
+            </td>
+        </tr>
+        <tr>
+            <td>
+                `Motor` Robots have many motors. It's not clear what the motor
+                is used for.
+            </td>
+            <td>
+                `IntakeMotor` Adding a mechanism name makes it clear that the
+                motor belongs to the intake.
+            </td>
+        </tr>
+        <tr>
+            <td>
+                `IntakeMotorForTheTopIntakeRoller` This is too descriptive and
+                the name is too long, which makes it hard to read.
+            </td>
+            <td>
+                `IntakeTopMotor` The variable name is shorter but it's easy to
+                know what the variable is for.{' '}
+            </td>
+        </tr>
+    </tbody>
+</table>
+
+### Semi-colons
+
 In Java, semi-colons `;` are similar to a period in a sentence.
 It is what tells the compiler when a statement ends.
-Semi-colons are commonly used in programming and aren't only for creating variables.
-We will see more examples of this later in the course.
+In most cases, not having a semi-colon at the end of a line will cause an error.
 
-In FRC, variables can be used to hold information about the robot and its different mechanisms.
-The example below shows 3 variables that were used for a climber mechanism, `CLIMBER_ID` is an integer that holds the motor controller ID number which is 51.
-`UP_POSITION` is a double that holds the value -33.5 and `DOWN_POSITION` is a double that holds the value 0.
+### Example
+
+Taking what we learned, the following are four variables that each use a different data type.
 
 ```java #variables
 
@@ -105,18 +164,48 @@ A print statement in Java looks like:
 
 ```
 
-What the print statement does is take information inside the parentheses, in the previous example, it’s “hello!”, and prints it out to the terminal screen.
-When using a print statement, the text that we want to print out goes inside the parentheses and is in quotes.
+The print statement uses information given inside the parentheses, in the previous example, it’s the String “hello!”, and prints it out to the terminal screen.
+When using a print statement to output text, you have to surround the text with quotes, to indicate that you want to work with that text literally.
+A print statement without the quotes will instead interpret the text as a variable name and attempt to print the data stored by that variable.
+This may cause an error if you intended to print out the text literally since the text is likely not an existing variable.
 However, if we are printing out the value of a variable, then we do not need quotes, as shown below.
 
 ```java #printVariable
 
 ```
 
+Often when programming, there will be a lot of print statements that display different information.
+To make it clear what's being printed, a `String` can be added in front of the value and then the `+` sign.
+This method of combining strings via the `+` operator is known as string concatenation.
+Let's look at an example:
+
+```java #stringConcatenation1
+
+```
+
+`speed` is set equal to 1, this will print out `Left Motor Speed 1`.
+Notice the space between `Speed` and the `"`.
+This is done to make the print out easy to read.
+`System.out.println("Left Motor Speed" + speed);` would print out `Left Motor Speed1` which isn't easy to read.
+
+This can also be done using many variables.
+Using an empty string, `" "`, a space can be added in between variables in a print statement.
+Let's look at another example:
+
+```java #stringConcatenation2
+
+```
+
+This example will print out `6 2.0`.
+Java recognizes that one of the items being added is a string, and converts the items on either side to a string before combining everything.
+
 ## Comments
 
 When programming, we use comments to write notes that explain what the code does.
 This helps make the code more readable for others because if they are unsure of what your code does, they can read your comments.
+Writing comments can also help you!
+Leaving comments that explain what code does can be helpful when trying to understand what your code does and when debugging.
+
 Comments are ignored by the compiler, which also means that you can use comments to prevent code from running.
 In Java, there are two types of comments: single-line comments and multi-line comments.
 
@@ -148,6 +237,24 @@ For example, this is a comment with two lines of text.
 
 ```
 
+### Writing Comments
+
+It's best to use comments to explain what the code is trying to do with words, rather then just restating the code.
+For example, this is a useful comment because it explains what the purpose is and how it accomplishes the task.
+
+```java #goodComment
+
+```
+
+This is not a useful comment because it doesn't tell the reader what the purpose of the code is.
+It just restates the code.
+
+```java #badComment
+
+```
+
+There's no need to use comments for every line of code, but if something might be confusing to someone else later (or even yourself), leave a comment!
+
 ## Java Fundamentals Exercise
 
 <Aside type="exercise">
diff --git a/src/content/docs/learning-course/stage0/loops.mdx b/src/content/docs/learning-course/stage0/loops.mdx
index 326f0aad..763fa258 100644
--- a/src/content/docs/learning-course/stage0/loops.mdx
+++ b/src/content/docs/learning-course/stage0/loops.mdx
@@ -43,14 +43,6 @@ A `while` loop includes:
 - `{` to denote the opening of the loop's code block
 - `}` to denote the end of the loop's code block
 
-The following flowchart demonstrates how a while loop works:
-
-<ContentFigure
-    src="/learning-course/stage0/loops/WhileLoop.webp"
-    width="300px"
-    height="300px"
-/>
-
 Like the `if` conditional, the `while` loop will run its code block if the condition is true.
 Unlike the `if` conditional, however, when the code block is done, the `while` loop will evaluate its condition again.
 If the condition is still true, the code block will run again.
diff --git a/src/content/docs/learning-course/stage0/operators.mdx b/src/content/docs/learning-course/stage0/operators.mdx
index f144b10c..ca0d3a35 100644
--- a/src/content/docs/learning-course/stage0/operators.mdx
+++ b/src/content/docs/learning-course/stage0/operators.mdx
@@ -15,9 +15,6 @@ There four different types of operators are:
 - Comparison Operators
 - Logical Operators
 
-Operators are commonly used to change the value of a variable in a loop or conditional.
-These topics will be covered in the next sections!
-
 ## Arithmetic Operators
 
 Arithmetic operators are used to perform basic math on variables.
@@ -28,7 +25,6 @@ These include:
         <tr>
             <th>Operator</th>
             <th>Description</th>
-            <th>Compatible Data Types</th>
             <th>Example</th>
         </tr>
     </thead>
@@ -36,25 +32,21 @@ These include:
         <tr>
             <td>`+`</td>
             <td>Addition: Adds two values together</td>
-            <td> int, double</td>
             <td>`a + b`</td>
         </tr>
         <tr>
             <td>`-`</td>
             <td>Subtraction: Subtracts one value from the other</td>
-            <td>int, double</td>
             <td>`a - b`</td>
         </tr>
         <tr>
             <td>`*`</td>
             <td>Multiplication: Multiplies two values together</td>
-            <td>int, double</td>
             <td>`a * b`</td>
         </tr>
         <tr>
             <td>`/`</td>
             <td>Division: Divides one value from the other</td>
-            <td>int, double</td>
             <td>`a / b`</td>
         </tr>
         <tr>
@@ -62,17 +54,12 @@ These include:
             <td>
                 Remainder: Returns the remainder of two numbers after division
             </td>
-            <td>int, double</td>
             <td>`a % b`</td>
         </tr>
     </tbody>
 </table>
 
-<Aside type="note">
-    Operators in Java follow the order of operations (known as PEMDAS).
-</Aside>
-
-Operators can be used when creating variables or when changing a variable's value after it was initialized.
+Operators can be used anywhere you would use a number, such as when assigning variables.
 In the example below, we have three variables whose values are set using different operators.
 Without running the code, think about what value would each variable hold.
 
@@ -93,29 +80,14 @@ Without running the code, think about what value would each variable hold.
     </div>
 </details>
 
-In the example below, we have an integer variable named `magicNumber` that is set to 6. Using the multiplication operator, the value is adjusted inside the print statement.
-Without running the code, what is the value of `magicNumber`?
-
-```java #multiplication
-
-```
-
-<details class="accordion">
-    <summary>Answer</summary>
-    <div class="content">
-        <p>
-            `magicNumber`'s value remains 6. The value calculated inside
-            `println` only affects what gets printed, since it's never assigned
-            back to `magicNumber` using an equal sign.
-        </p>
-    </div>
-</details>
-
 <Aside type="note">
-    When dividing two integers, the result will be an integer instead of a
+    When dividing two integers, the result will be rounded down to an integer instead of the result being a
     double. Example: `System.out.print(7 / 2);` will print out 3. If you want
     the result to return a `double`, like 3.5, the data type should be a
     `double` instead of an `int`.
+
+    Due to this, it's often better to use `double`s when writing code so you can use decimal values.
+
 </Aside>
 
 ## Assignment Operators
@@ -196,7 +168,6 @@ For now, we can use the operators to change variables without using conditionals
         <tr>
             <th>Operator</th>
             <th>Description</th>
-            <th>Compatible Data Types</th>
             <th>Example</th>
         </tr>
     </thead>
@@ -204,13 +175,11 @@ For now, we can use the operators to change variables without using conditionals
         <tr>
             <td>`++`</td>
             <td>Increment: adds 1 to a variable</td>
-            <td>int, double</td>
             <td>`a++`</td>
         </tr>
         <tr>
             <td>`--`</td>
             <td>Decrement: subtracts 1 from a variable</td>
-            <td>int, double</td>
             <td>`a--`</td>
         </tr>
     </tbody>
@@ -222,14 +191,9 @@ In the example below, we have two variables: `x` which is set to 6 and `y` which
 
 ```
 
-In the first print statement, we have `x++`.
-This means it takes the value of x and increments it by 1 which gives us 7 because 6 + 1 is 7.
-In the second print statement, we have `y--`.
-This means that it takes the value of y, decrements it by 1 which gives us 6 since 7 - 1 is 6.
-
 ## Comparison Operators
 
-Comparison operators are symbols that tell the program how to compare values.
+Comparison operators compare values.
 They can be used to help make decisions and are a main part of conditionals, which are discussed later in this stage.
 
 <table class="Comparison Operators">
@@ -244,13 +208,13 @@ They can be used to help make decisions and are a main part of conditionals, whi
         <tr>
             <td>`==`</td>
             <td>
-                Equal to: Checks if one value is the same values as the other
+                Equal to: Checks if two values are the same
             </td>
             <td>`a == b`</td>
         </tr>
         <tr>
             <td>`!=`</td>
-            <td>Not Equal: Checks if one value is NOT equal to the other</td>
+            <td>Not Equal: Checks if two values are **not** the same</td>
             <td>`a != b`</td>
         </tr>
         <tr>
@@ -294,6 +258,34 @@ In the example below, it returns false because 2 is not greater than 4.
 
 ```
 
+<Aside type="note">
+`==` and `!=` cannot be used to compare the values of `String`s. 
+To compare `String`s, `.equals()` is used.
+Though it's not used, more information can be found [here.](https://www.w3schools.com/java/ref_string_equals.asp)
+
+</Aside>
+
+### Pay attention to equals signs!
+
+When using comparison operators, make sure to use a double equal sign `==` instead of a single equal `=`.
+Unlike in math, a single equal is assignment.
+
+In the example below, the print statement would not run.
+You would get an error message about how the left hand side of an assignment must be a variable.
+{/* rli:ignore */}
+
+```java
+    System.out.println(6 = 8);
+```
+
+Adding the double equal sign, fixes the error because the compiler will read this as comparing the value on the left to the value on the right.
+This will print out `false` because 6 is not equal to 8.
+{/* rli:ignore */}
+
+```java
+    System.out.println(6 == 8);
+```
+
 ## Logical Operators
 
 Logical operators help a program make decisions by using true or false statements.
@@ -363,6 +355,31 @@ Using that information and without running the code, what should the print state
     </div>
 </details>
 
+## Math and Operators
+
+Operators can be used to assign new values to existing variables.
+Arithmetic, and Assignment operators can help perform math and change the values.
+
+Operators can also change the value of variables using the `=` sign.
+In the example, `e`'s value changes to 12 in the print statement.
+`e`'s value is being set to whatever is on the right side of the `=`.
+In this case, it's 12 because `f` is equal to 2, so 2 + 10 is 12.
+
+```java #math1
+
+```
+
+In the example, we have an integer variable named `magicNumber` that is set to 6.
+Using the multiplication operator, the value is adjusted inside the print statement.
+
+```java #math2
+
+```
+
+Unlike the previous example, `magicNumber`'s value remains 6.
+The value calculated inside `println` only affects what gets printed, since it's never assigned back to `magicNumber` using an equal sign.
+This can be confirmed by printing the value of `magicNumber` again.
+
 ## Operators Exercise
 
 <Aside type="exercise">
diff --git a/src/content/docs/learning-course/stage0/stage-overview.mdx b/src/content/docs/learning-course/stage0/stage-overview.mdx
index 325330bf..42c559d2 100644
--- a/src/content/docs/learning-course/stage0/stage-overview.mdx
+++ b/src/content/docs/learning-course/stage0/stage-overview.mdx
@@ -5,13 +5,12 @@ prev: /learning-course/getting-started/forking-and-cloning/
 next: /learning-course/stage0/java-fundamentals/
 ---
 
-Learning the basics of Java is the most important step in learning FRC programming because it builds the foundation.
+Learning Java is the most important step in learning FRC programming.
 Using Java, we can write code that allows a robot to run a motor, adjust speed, and much more.
-While there is a lot to learn when learning Java, FRCSoftware will only cover the basics needed to program a robot.
+While there is a lot to learn when learning Java, Stage 0 will only cover the basics.
 
-Each section will have different activities and exercises to help build up a good understanding of the basics of Java.
-If you’re new to programming, it is highly recommended to go through each step in order.
-This will help ensure that you don’t miss any important information.
+Each page in Stage 0 will cover a different essential topic.
+If you're new to programming, **go through each step in order**.
 
 This stage will cover the following topics