Misc Grammar fixes

Author: Buunie099

lessons/functions-in-classes.md

@@ -50,7 +50,7 @@ private boolean isGamePiecePresent() {
     return retroReflectiveGP.get();
 }
 ```
-Above is a example of how functions might be used. You can see that it will return a boolean of whatever the `retroReflectiveGP` sensor sees. Because it uses private, you would not be able to call this function to get weather the gp is present from outside the class.
+Above is a example of how functions might be used. You can see that it will return a boolean of whatever the `retroReflectiveGP` sensor sees. Because it uses private, you would not be able to call this function to get whether the gamepiece is present from outside the class.
 
 ```java
 public class Elevator extends SubsystemBase {

lessons/hello-world.md

@@ -21,7 +21,7 @@ Output
 Hello World
 ```
 
-The code above, when run, will display "Hello World" in the terminal. Although not the most exciting result, the code to do it might look intimidating. Let's discuss what is going on here.
+The code above, when ran, will display "Hello World" in the terminal. Although not the most exciting result, the code to do it might look intimidating. Let's discuss what is going on here.
 
 ##### Curly Braces
 Curly braces `{}` define code blocks. There are 2 sets of them in this program. They are meant to encapsulate code within a program.
@@ -40,7 +40,7 @@ This is what you are probably thinking about when you think of code. It's what a
 ```java
 System.out.println("Hello World");
 ```
-What this line does it put what's between the parentheses onto the screen. In this case `"Hello World"`, which is what we see when we run the program.
+This line puts what's between the parentheses onto the screen. In this case, `"Hello World"`, which is what we see when we run the program.
 
 At the end of every statement, we put a semicolon `;` to tell the computer that our statement is complete.
 

lessons/logic.md

@@ -25,7 +25,7 @@ Here are some comparison operators:
  - `||`: Or (True: `(1 == 1) || (2 != 2)`, checks if 1 is equal to 1 **or** 2 is equal to 2)
  - `^`: Xor (True: `(1 == 1) ^ (2 != 2)`, True if **only one** of the conditions is true)
 
-### Here's some examples:
+### Here are some examples:
 ```java
 // Reads like: "if one plus one equals two"
 if (1 + 1 == 2) {
@@ -42,7 +42,9 @@ if (1 + 1 == 2 && 3 + 3 == 6) {
     System.out.println("Math is still mathin'");
 }
 ```
-Variables can be used in `if` statements as well, assuming that they are `boolean`'s.
+
+Variables can be used in `if` statements as well, as long as they are `boolean`'s.
+
 ```java
 boolean valid = 1 == 1;
 if (valid) {
@@ -61,8 +63,8 @@ if (elevator.atBottomHardStop() || elevator.atUpperHardStop()) {
     currentMotorState = MotorState.kSTOP;
 }
 ```
-### A Amendum for Non-Primative Types (For Those Who Care)
-Due to the way that java works, when you compare a non-primative type to anything else you are not comparing the value of the variable, but insted the address to the memory of the variable. Some of the consequences of this are that code like `String("abc") == "abc"` are false (String is a non primative type). For strings and others, you can do `String("abc").equals("abc")` to get it to work.
+### A Addendum for Non-Primative Types (For Those Who Care)
+Due to the way that java works, when you compare a non-primative type to anything else you are not comparing the value of the variable, but insted the address to the memory of the variable. Some of the consequences of this is that code like `String("abc") == "abc"` is false (String is a non primative type). For strings and others, you can do `String("abc").equals("abc")` to get it to work.
 ##### For loops
 You can use loops to run code more than once without copy+pasting 800 lines. A straightforward way to do this is a `for` loop. `for` loops run a pre-specified amount of times, defined in the parentheses after `for`. A common syntax you will see is defining a new variable (often `i`), then setting a condition (while `i` is less than `5`), and setting a rule to be followed every loop (commonly `i++`, which increments `i` by 1).
 

lessons/simple-functions.md

@@ -10,18 +10,22 @@ You hopefully know what a function is from various math classes over the years.
 
 ![A desmos graph showing f(x) = 3x](../assets/images/desmos-graphs-simple-functions.png)
 
-This function's y value is always equal to 3 times its x value. Let's see what this would look like in Java.
+This function's y value is always equal to 3 times its x value.
+
+## Java Function
+
+Let's see what that function would look like in Java.
 
 ```java
 double f(double x) {
-    return x * 3.0;
+    return x * 3.0d;
 }
 ```
 
 The first `double` represents the `return` type. This is to signify that the function `return`s a decimal value. `f` is our name. You would usually use something more descriptive such as `triple`. The `double x` is the argument, we specify type and name. It's the x in f(x). The `{ ... }` shows the inside of the function, anything in here happens when the function is 'called'. `return` is often the final line of functions. That's where you put whatever you want to come out of the function, a `double` in our case. `return` additionally ends a functions processing and 'return's to wherever you call it from. Let's see why we want a `return`.
 
 ```java
-double startNumber = 6.0;
+double startNumber = 6.0d;
 
 double endNumber = f(startNumber); // This will evaluate to 18.0
 ```
@@ -31,8 +35,8 @@ This hopefully explains functions. Some more examples are below:
 // Return the absolute value of a number
 double absoluteValue(double number) {
     double finalNumber = number
-    if (number < 0.0) {
-        finalNumber *= -1;
+    if (number < 0.0d) {
+        finalNumber *= -1.0d;
     }
     return finalNumber;
 }

lessons/types.md

@@ -13,7 +13,7 @@ Types are these indicators of, well, type. A real world example could be the typ
 boolean correct = true;
 ```
 
-This example's type is `boolean`. Boolean (also known as bool) values can hold either `true`, or `false`. This is seen with `= true`. Anything other than valid values on the right side of that `=` will probably cause an error. Let's go over some more simple types.
+This example's type is `boolean`. Boolean (also known as bool) values can hold either `true`, or `false`. This is seen with `= true`. Anything other than true or false values on the right side of that `=` will probably cause an error. Let's go over some more simple types.
 
 ```java
 int number = 3;

lessons/variables.md

@@ -21,7 +21,7 @@ This is what the value is stored to, you use this name to reference its value
 3. The value  
 This is what the variable stores, it will be of the same type of the variable
 
-They get arranged like so:
+The parts get arranged like so:
 ```java
 type name = value;
 ```
@@ -32,8 +32,8 @@ type name;
 ```
 If you use this, I would expect that you give it a value soon afterwards.
 
-
 ## Some Examples
+
 If I wanted to make a variable called `message` with a type of `String` and a value of `Hello World` I could do the following.
 ```java
 String message = "Hello World";
@@ -70,7 +70,7 @@ number = 67;                // Changes number to 67
 System.out.println(number); // Prints 67
 ```
 ### Using Variables
-Variables are useful in that they act as their value, here's some examples of variables being used.
+Variables are useful in that they act as their value. Here are some examples of variables being used.
 ```java
 double x = 0.4d + 12.1d;    // After the =, we can put any expression that gives us a value, for example, math operations
 
@@ -85,4 +85,4 @@ x = x + 1;
 
 System.out.println(x); // Prints 2
 ```
-In our next lesson we'll look at functions and how they are useful.
+In our next lesson we'll look at functions and how they are useful.