Make some changes

Author: SGOTI2

lessons/hello-world.md

@@ -3,8 +3,6 @@ layout: default
 title: Hello World
 ---
 # Hello World
-> # WIP
-
 In the first lesson here, we'll learn the basics of Java.
 
 ## The First Program
@@ -63,37 +61,23 @@ Next, let's make it a bit more complicated. Look at the next piece of code, befo
 ```java
 System.out.println(6 + 7);
 ```
-What it puts on the screen is the number `13`, which you probably guessed it would do. What you can learn from this is that you can do some math in java like so.
-### Comments rq
-To leave a comment on a line of code in Java, you can put a `//` before it and the rest of line will be the comment.
-```java
-System.out.println(2 * 3); // Prints 6
-System.out.println("Do I have rizz?"); 
-// This code won't run because its in a comment
-// System.out.println("I don't run");
-```
-### Quick intro to variables
-We'll be exploring variables more in depth later (in fact it's the next lesson), but I'd like to at least introduce you to them.
+What it puts on the screen is the number `13`, which you probably guessed it would do. What you can learn from this is that you can do some math in java by using some basic symbols. Here's some more examples:
 ```java
-int x = 6 + 7;
-System.out.println(x);
-```
-The code you see above achieves exactly the same result as before, printing `13`. However, as you can see, it assigns it to a variable first. We're going to skip the `int` part for now, but you can see that the variable x is assigned the result of the evaluated expression to the right. You can think of them as variables from math, except they always have a value.
+System.out.println(5 * 3 + 1);         // Prints 16
 
-Below here are a few more examples to get you used to them.
+System.out.println(6 / 2 * (1 + 2));   // Prints 9
+```
+## Comments
+I've also included comments the previous example, any text put after a `//` will not be run. It's helpful for describing what code does inline without having to create a word doc or something. You'll see them all the time in code snippets to tell you what going on but later on, we'll start to not write as many because they will get redundant. In the robot's code, we'll normally write them to explain complicated logic or strange decisions. You can do multi line comments like so, if you would like.
 ```java
-int x = 5 * 3 + 1;
-System.out.println(x);   // Prints 16
-
-int y = 6 / 2 * (1 + 2); // Do it pemdas?
-System.out.println(x);   // It does, prints 9
-
-int sum = x + y;
-System.out.println(sum); // Prints 25
-
-String greeting = "Welcome to programming preseason";
-System.out.println(greeting);
+/* The following line will do the following:
+1. Add 6 and 4 to create 10
+2. Multiply that by 9 to create 90
+3. Subtract 9 to create 81
+4. Display 81 to the screen
+*/
+System.out.println(9 * (6 + 4) - 9);
 ```
-In the next lesson, you're going to learn about what the `int` and `String` are.
+It's `/*` to start a comment and `*/` to end the multi-line comment. Anything in-between will be a comment.
 
 [^1]: (1) Code snippits - Something that always bothered me about learning to program was that they never put where the code actually went. I can see why in hindsight, but I figured I would tell you where code snippits go. In the first code snippit, it's the entire file, you can copy and paste that into a main.java and run it. But for the rest you can't just do that. The 2nd snippit of code is of a function definition, when you see code with definitions like that, you can assume it came from inside of a class. When you don't see any function definitions, it most likely came from inside of a function. In our case, besides the 1st and 2nd snippits, the rest is from within the main function.

lessons/variables.md

@@ -0,0 +1,71 @@
+---
+layout: default
+title: Variables
+---
+# Variables
+In this lesson we'll introduce you to variables.
+
+## What are Variables?
+Variables are arguably the most important thing in programming any language. Variables consist of 3 main components:
+
+1. The type  
+This is what the variable stores, some examples are:
+    * `String` - Stores text, such as "Hello". String values are surrounded by double quotes.
+    * `int` - stores integers (whole numbers), without decimals, such as 123 or -123.
+    * `double` - stores floating point numbers, with decimals, like 19.99 or -3.14159265 (for people with experience, we will not be using `float` in our code).
+    * `char` - stores single characters, such as 'a' or 'B'. Char values are surrounded by single quotes
+    * `boolean` - stores values with two states: `true` or `false`
+
+2. The name  
+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:
+```java
+type name = value;
+```
+
+It's important to note that the value is optional and the following is also a valid format:
+```java
+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";
+System.out.println(message);
+```
+The code above will print the value of the variable `message` which in this case is `"Hello World"`.
+
+```java
+double pi = 3.14159265;
+System.out.println(pi); // Prints 3.14159265
+```
+
+```java
+int number = 67;
+System.out.println(number); // Prints 67
+```
+
+### Assigning Later
+The following is a example of how you can give a variable a value after declaring it.
+```java
+int number;
+number = 45;
+System.out.println(number); // Prints 45
+```
+Notice how after declaring a variable, we don't need to put the type next to it when assigning it a value.
+### Assigning Generally
+We often find it useful to update a variable so here's a example, it's the exact same assigning syntax.
+```java
+int number = 12;
+number = 41;                // Changes number to 41
+System.out.println(number); // Prints 41
+
+number = 67;                // Changes number to 67
+System.out.println(number); // Prints 67
+```