diff --git a/book.toml b/book.toml
index 5a16912..13693d4 100644
--- a/book.toml
+++ b/book.toml
@@ -16,9 +16,10 @@ level = 0         # the depth to start folding
 
 [preprocessor.features]
 command = "python3 features.java"
+# Going to start writing the rest of the book
+# Assuming this is true
+toplevel_anonymous_class = true
 # Not ready
-toplevel_anonymous_class = false
-# Not ready
-simple_io = false
+simple_io = true
 # Turn on when Java 21 released
 java_21 = false
\ No newline at end of file
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index fa5ac49..3fec735 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -132,44 +132,97 @@
     - [Printing the Contents of an Array](./arrays/printing_the_contents_of_an_array.md)
     - [Empty Array](./arrays/empty_array.md)
     - [Difference between Initializer and Literal](./arrays/difference_between_initializer_and_literal.md)
-    - [Challenges](./arrays/challenges)
+    - [Challenges](./arrays/challenges.md)
 
 # Control Flow II
 
-<!--
-- [For](./for.md)
-    - [Comparison to while]()
-    - [i](./for/i.md)
-    - [Relation to Arrays]()
-    - [var]()
-    - [final]()
-- [For Each]()
+- [Loops II](./loops_ii.md)
+    - [For](./loops_ii/for.md)
+    - [For Syntax](./loops_ii/for_syntax.md)
+    - [Counting Up and Down](./loops_ii/for_counting_up_and_down.md)
+    - [Iterate over a String](./loops_ii/iterate_over_a_string.md)
+    - [Iterate over an Array](./loops_ii/iterate_over_an_array.md)
+    - [Comparison to while](./loops_ii/comparison_to_while.md)
+    - [i](./loops_ii/i.md)
+    - [Break](./loops_ii/break.md)
+    - [Continue](./loops_ii/continue.md)
+    - [Delayed Assignment](./loops_ii/delayed_assignment.md)
+    - [Inferred Types](./loops_ii/inferred_types.md)
+    - [Empty Initializers](./loops_ii/empty_initializers.md)
+    - [Empty Expressions](./loops_ii/empty_expressions.md)
+    - [Empty Statements](./loops_ii/empty_statements.md)
+    - [Final Variables](./loops_ii/final_variables.md)
+    - [Labeled Break](./loops_ii/labeled_break.md)
+    - [Labeled Continue](./loops_ii/labeled_continue.md)
+    - [Drawing Right Triangles](./loops_ii/drawing_right_triangles.md)
+    - [Drawing Isosceles Triangles](./loops_ii/drawing_isosceles_triangles.md)
+    - [Challenges](./loops_ii/challenges.md)
+
+# Code Structure
+
+- [Methods](./methods.md)
+    - [Declaration](./methods/declaration.md)
+    - [Invocation](./methods/invocation.md)
+    - [Scope](./methods/scope.md)
+    - [Return](./methods/return.md)
+    - [Unreachable Statements](./methods/unreachable_statements.md)
+    - [main](./methods/main.md)
+- [Arguments](./arguments.md)
+    - [Declaration](./arguments/declaration.md)
+- [Return Values](./return_values.md)
+    - [void](./return_values/void.md)
+    - [Conversion](./return_values/conversion.md)
+    - [Pure Functions](./return_values/pure_functions.md)
+- [Classes](./classes.md)
+    - [Class Declaration](./classes/class_declaration.md)
+    - [Naming Classes](./classes/naming_classes.md)
+    - [Field Declaration](./classes/field_declaration.md)
+    - [Naming Fields](./classes/naming_fields.md)
+    - [new](./classes/new.md)
+    - [Zero Values](./classes/zero_values.md)
+    - [Aliasing](./classes/aliasing.md)
+    - [null](./classes/null.md)
+
+- [Constructors](./constructors.md)
+    - [this](./constructors/this.md)
+    - [The Default Constructor](./constructors/the_default_constructor.md)
+    - [Final Fields](./constructors/final_fields.md)
+    - [Multiple Constructors](./constructors/multiple_constructors.md)
 
-- [Iteration]()
-    - [Iterate over an array]()
+- [Instance Methods](./instance_methods.md)
+    - [Declaration](./instance_methods/declaration.md)
+    - [Invocation](./instance_methods/invocation.md)
+    - [this](./instance_methods/this.md)
+    - [Aliasing](./instance_methods/aliasing.md)
+    - [Derived Values](./instance_methods/derived_values.md)
+
+# Data Types III
 
 - [null](./null.md)
-- [Reference Types]()
-- [Primitive Types]()
-- [Populate array]()
+    - [Checking for null](./null/checking_for_null.md)
+    - [Field Access](./null/field_access.md)
+    - [Instance Methods](./null/instance_methods.md)
 
--->
+- [Arrays II]()
+    - [Default Values]()
+    - [Populate Array]()
+- [Boxed Primitives]()
+    - [Boolean]()
+    - [Character]()
+    - [Integer]()
+    - [Double]()
+
+- [Example: "Growable" Array]()
+
+# Code Structure II
+- [Documentation]()
+    - [Documentation Comments]()
+- [Testing]()
 
 # User Defined Types
 
-- [Classes](./classes.md)
-    - [Primitive Classes](./classes/primitive_classes.md)
-    - [Reference Classes](./classes/reference_classes.md)
-    - [null](./classes/null.md)
-    - [Class Declaration](./classes/class_declaration.md)
-    - [Naming](./classes/naming.md)
-- [Fields](./fields.md)
-    - [Default Values](./fields/default_values.md)
-- [Methods](./methods.md)
-    - [Arguments](./methods/arguments.md)
-    - [Return Values](./methods/return_values.md)
-    - [void](./methods/void.md)
-- [Constructors](./constructors.md)
+- [Primitive Classes](./classes/primitive_classes.md)
+- [Reference Classes](./classes/reference_classes.md)
 
 <!--
 Arrays
diff --git a/src/arguments.md b/src/arguments.md
new file mode 100644
index 0000000..64eaf15
--- /dev/null
+++ b/src/arguments.md
@@ -0,0 +1,21 @@
+# Arguments
+
+If methods always had to do the same thing each time they were run, they wouldn't be that useful.
+
+The way to customize what happens when a method is called is to have them take "arguments."
+Arguments let the caller of the method change what happens when a method runs.
+As part of a method declaration, you can include a comma separated list of "arguments"
+to that method. These arguments let the caller of the method change what happens when a method runs.
+
+```java
+void sayHello(String name) {
+    System.out.println("Hello " + name + "!");
+}
+
+void main() {
+    // Hello Joshua!
+    sayHello("Joshua");
+    // Hello Claire!
+    sayHello("Claire");
+}
+```
diff --git a/src/arguments/declaration.md b/src/arguments/declaration.md
new file mode 100644
index 0000000..5ec05ee
--- /dev/null
+++ b/src/arguments/declaration.md
@@ -0,0 +1,13 @@
+# Declaration
+
+To declare a method take an argument, instead of putting `()` after the method name
+you need to put a comma separated list of argument declarations.
+
+Each argument declaration looks the same as a variable declaration and has both a type and a name.
+
+```java
+// This declares a single argument named "food" that
+// has a type of "String".
+void eat(String food) {
+    System.out.println("I ate " + food);
+}
\ No newline at end of file
diff --git a/src/arrays/challenges.md b/src/arrays/challenges.md
new file mode 100644
index 0000000..9358534
--- /dev/null
+++ b/src/arrays/challenges.md
@@ -0,0 +1 @@
+# Challenges
diff --git a/src/classes.md b/src/classes.md
index 87846ef..60ce908 100644
--- a/src/classes.md
+++ b/src/classes.md
@@ -1 +1,44 @@
 # Classes
+
+Methods can only have one return value. This means that if you wanted to make a method
+that returned two values, such as the location of buried treasure, you would have trouble.
+
+```java
+// Can only declare one "thing" that will be returned
+double getTreasureLocation() {
+    // Can't return two values.
+    return 43.8803, 103.4538
+}
+```
+
+This is the first[^many] use of classes. You can declare your own class which can hold multiple
+values and use that to smuggle them across a method return.
+
+```java
+class Location {
+    double latitude;
+    double longitude;
+}
+
+Location getTreasureLocation() {
+    Location treasure = new Location();
+    treasure.latitude = 43.8803;
+    treasure.longitude = 103.4538;
+    return treasure;
+}
+
+void main() {
+    Location treasure = getTreasureLocation();
+
+    System.out.println(
+        "The treasure is at " + 
+        treasure.latitude +
+        "N, " +
+        treasure.longitude +
+        "W."
+    );
+}
+```
+
+
+[^many]: of many
\ No newline at end of file
diff --git a/src/classes/aliasing.md b/src/classes/aliasing.md
new file mode 100644
index 0000000..81497a6
--- /dev/null
+++ b/src/classes/aliasing.md
@@ -0,0 +1 @@
+# Aliasing
diff --git a/src/classes/declaration.md b/src/classes/declaration.md
new file mode 100644
index 0000000..9d04b01
--- /dev/null
+++ b/src/classes/declaration.md
@@ -0,0 +1,6 @@
+# Declaration
+
+To declare a class, you write the word `class` followed by a name for the class.
+
+You shoul
+
diff --git a/src/classes/field_declaration.md b/src/classes/field_declaration.md
new file mode 100644
index 0000000..78c2026
--- /dev/null
+++ b/src/classes/field_declaration.md
@@ -0,0 +1 @@
+# Field Declaration
diff --git a/src/classes/naming_classes.md b/src/classes/naming_classes.md
new file mode 100644
index 0000000..d1039ed
--- /dev/null
+++ b/src/classes/naming_classes.md
@@ -0,0 +1 @@
+# Naming Classes
diff --git a/src/classes/naming_fields.md b/src/classes/naming_fields.md
new file mode 100644
index 0000000..561fd50
--- /dev/null
+++ b/src/classes/naming_fields.md
@@ -0,0 +1,14 @@
+# Naming Fields
+
+Fields are generally named `camelCase`, the same as local variables.[^break]
+
+```java
+class Example {
+    int x;
+    String name;
+    int[] timesOfRacers;
+    String[] namesOfClowns;
+}
+```
+
+[^break]: If you break a social rule, something Bad happens.
\ No newline at end of file
diff --git a/src/classes/new.md b/src/classes/new.md
new file mode 100644
index 0000000..4f7fd6a
--- /dev/null
+++ b/src/classes/new.md
@@ -0,0 +1 @@
+# new
diff --git a/src/classes/zero_values.md b/src/classes/zero_values.md
new file mode 100644
index 0000000..fd09e2a
--- /dev/null
+++ b/src/classes/zero_values.md
@@ -0,0 +1 @@
+# Zero Values
diff --git a/src/constructors/final_fields.md b/src/constructors/final_fields.md
new file mode 100644
index 0000000..f44f644
--- /dev/null
+++ b/src/constructors/final_fields.md
@@ -0,0 +1 @@
+# Final Fields
diff --git a/src/constructors/multiple_constructors.md b/src/constructors/multiple_constructors.md
new file mode 100644
index 0000000..efcb197
--- /dev/null
+++ b/src/constructors/multiple_constructors.md
@@ -0,0 +1 @@
+# Multiple Constructors
diff --git a/src/constructors/the_default_constructor.md b/src/constructors/the_default_constructor.md
new file mode 100644
index 0000000..98d47b9
--- /dev/null
+++ b/src/constructors/the_default_constructor.md
@@ -0,0 +1 @@
+# The Default Constructor
diff --git a/src/constructors/this.md b/src/constructors/this.md
new file mode 100644
index 0000000..d742220
--- /dev/null
+++ b/src/constructors/this.md
@@ -0,0 +1 @@
+# this
diff --git a/src/drawing_shapes/right_triangles.md b/src/drawing_shapes/right_triangles.md
new file mode 100644
index 0000000..fa13278
--- /dev/null
+++ b/src/drawing_shapes/right_triangles.md
@@ -0,0 +1 @@
+# Right Triangles
diff --git a/src/instance b/src/instance
new file mode 100644
index 0000000..d742220
--- /dev/null
+++ b/src/instance
@@ -0,0 +1 @@
+# this
diff --git a/src/instance_methods.md b/src/instance_methods.md
new file mode 100644
index 0000000..d8122d8
--- /dev/null
+++ b/src/instance_methods.md
@@ -0,0 +1 @@
+# Instance Methods
diff --git a/src/instance_methods/aliasing.md b/src/instance_methods/aliasing.md
new file mode 100644
index 0000000..81497a6
--- /dev/null
+++ b/src/instance_methods/aliasing.md
@@ -0,0 +1 @@
+# Aliasing
diff --git a/src/instance_methods/declaration.md b/src/instance_methods/declaration.md
new file mode 100644
index 0000000..a902009
--- /dev/null
+++ b/src/instance_methods/declaration.md
@@ -0,0 +1 @@
+# Declaration
diff --git a/src/instance_methods/derived_values.md b/src/instance_methods/derived_values.md
new file mode 100644
index 0000000..93afde7
--- /dev/null
+++ b/src/instance_methods/derived_values.md
@@ -0,0 +1 @@
+# Derived Values
diff --git a/src/instance_methods/invocation.md b/src/instance_methods/invocation.md
new file mode 100644
index 0000000..3dae992
--- /dev/null
+++ b/src/instance_methods/invocation.md
@@ -0,0 +1 @@
+# Invocation
diff --git a/src/instance_methods/this.md b/src/instance_methods/this.md
new file mode 100644
index 0000000..d742220
--- /dev/null
+++ b/src/instance_methods/this.md
@@ -0,0 +1 @@
+# this
diff --git a/src/integers/division.md b/src/integers/division.md
index 32fcd5b..bdf0f0e 100644
--- a/src/integers/division.md
+++ b/src/integers/division.md
@@ -19,7 +19,7 @@ So `5 / 2` does not result in `2.5`, but instead just `2`.
 // 5 / 2 is not 2.5, but instead 2.
 int x = 5 / 2;
 // 13 / 3 is not 4.3333, but instead 4.
-int y = 13 / 2;
+int y = 13 / 3;
 
 System.out.println(x);
 System.out.println(y);
diff --git a/src/loops/do_while.md b/src/loops/do_while.md
index b79f22f..cd08b80 100644
--- a/src/loops/do_while.md
+++ b/src/loops/do_while.md
@@ -1,6 +1,8 @@
 # Do
 
-One variation on a while loop is a "do-while loop."
+
+One variation on a `while` loop is a "do-while loop."
+
 
 ```java
 int x = 0;
diff --git a/src/loops_ii.md b/src/loops_ii.md
new file mode 100644
index 0000000..c6b4b1e
--- /dev/null
+++ b/src/loops_ii.md
@@ -0,0 +1,9 @@
+# Loops II
+
+`while` loops are enough to make any looping logic that you might want, but
+they aren't the only kind of loops you will see.
+
+There are tasks which would require a `while` loop, but are common enough that there are other kinds
+of loops that are shortcuts to writing them.
+
+
diff --git a/src/loops_ii/break.md b/src/loops_ii/break.md
new file mode 100644
index 0000000..83e705a
--- /dev/null
+++ b/src/loops_ii/break.md
@@ -0,0 +1,21 @@
+# Break
+
+`break` works the same with `for` loops as it does with `while` loops.
+Any time you hit a line with `break` you will immediately exit the loop.
+
+```java
+for (int i = 0; i < 1000; i++) {
+    if (i == 5) {
+        break;
+    }
+    System.out.println(i);
+}
+System.out.println("Over");
+
+// 0
+// 1
+// 2
+// 3
+// 4
+// Over
+```
\ No newline at end of file
diff --git a/src/loops_ii/challenges.md b/src/loops_ii/challenges.md
new file mode 100644
index 0000000..1f06993
--- /dev/null
+++ b/src/loops_ii/challenges.md
@@ -0,0 +1,100 @@
+# Challenges
+
+Remember the rules for this are
+
+* Try to use only the information given up to this point in this book.
+* Try not to give up until you've given it a solid attempt
+
+You are extremely likely to be quizzed on `for` loops on any standardized tests,
+so these challenges are going to include a lot of repetition and sometimes a tricky
+case to handle. Its for your own good, I hope.
+
+## Challenge 1
+
+Write code that will output every number from 0 to 15, including 0 and 15.
+
+```
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+11
+12
+13
+14
+15
+```
+
+Do it using a `for` loop and again using a `while` loop.
+
+## Challenge 2
+
+Write code that will output every number from 15 to 0, including 0 and 15.
+
+``` 
+15
+14
+13
+12
+11
+10
+9
+8
+7
+6
+5
+4
+3
+2
+1
+0
+```
+
+Do it using a `for` loop and again using a `while` loop.
+
+## Challenge 3
+
+Write code that will output every number from 15 to 0, excluding 0 and 15.
+
+``` 
+14
+13
+12
+11
+10
+9
+8
+7
+6
+5
+4
+3
+2
+1
+```
+
+Do it using a `for` loop and again using a `while` loop.
+
+## Challenge 4.
+
+Write code that will output every third number from 51 to 66.
+
+```
+53
+56
+59
+62
+65
+```
+
+Do it using a `for` loop and again using a `while` loop.
+
+## Challenge 5.
+
diff --git a/src/loops_ii/comparison_to_while.md b/src/loops_ii/comparison_to_while.md
new file mode 100644
index 0000000..1177e37
--- /dev/null
+++ b/src/loops_ii/comparison_to_while.md
@@ -0,0 +1,78 @@
+# Comparison to while
+
+If you were to compare the code needed to loop over an array using a `for` loop
+and the code needed with a `while` loop, there might not seem like much of a difference.
+
+```java
+double[] numbers = { 4.4, 1.1, 4.1, 4.7 };
+
+for (int index = 0; index < numbers.length; index++) {
+    System.out.println(numbers[index]);
+}
+
+int index = 0;
+while (index < numbers.length) {
+    System.out.println(numbers[index]);
+    index++;
+}
+```
+
+This is doubly true when we are looking at toy examples where the only thing done
+with the element is `System.out.println`.
+
+The biggest benefit to a `for` is subtle. With a `while` based loop, the initializer and boolean expression
+can potentially be many lines from the statement which updates the variable.
+
+```java
+int index = 0;
+while (index < numbers.length) {
+    /*
+    Can
+
+
+    potentially
+
+    have
+
+    arbitrary
+
+    code
+
+    you want to run
+
+    a bunch
+
+    of times
+    */
+
+    index++;
+}
+```
+
+Us humans, with our tiny monkey brains, can get very lost when things that are related to eachother are separated
+by long distances.
+
+In this dimension, for loops are superior. All the bits of code that "control the loop" can be right at the top.
+
+```java
+for (int index = 0; index < numbers.length; index++) {
+    /*
+    Can
+
+
+    potentially
+
+    have
+
+    arbitrary
+
+    code
+
+    you want to run
+
+    a bunch
+
+    of times
+    */
+}
+```
\ No newline at end of file
diff --git a/src/loops_ii/continue.md b/src/loops_ii/continue.md
new file mode 100644
index 0000000..f2a3a98
--- /dev/null
+++ b/src/loops_ii/continue.md
@@ -0,0 +1,59 @@
+# Continue
+
+`continue` works slightly differently with `for` loops than how it does with `while` loops.
+
+Any time you hit a line with `continue` you will immediately jump back to the top of the loop, but
+unlike with a `while` loop, the statement which updates your variable will still run.
+
+```java
+for (int i = 0; i < 5; i++) {
+    if (i == 2) {
+        // i++ will still run
+        continue;
+    }
+    System.out.println(i);
+}
+
+// 0
+// 1
+// 3
+// 4
+```
+
+So the above `for` loop is not equivalent to this `while` loop.
+
+```java
+int i = 0;
+while (i < 5) {
+    if (i == 2) {
+        continue;
+    }
+    System.out.println(i);
+
+    i++;
+}
+
+// 0
+// 1
+// ... spins forever ...
+```
+
+It is equivalent to this one.
+
+```java
+int i = 0;
+while (i < 5) {
+    if (i == 2) {
+        i++
+        continue;
+    }
+    System.out.println(i);
+
+    i++;
+}
+
+// 0
+// 1
+// 3
+// 4
+```
\ No newline at end of file
diff --git a/src/loops_ii/delayed_assignment.md b/src/loops_ii/delayed_assignment.md
new file mode 100644
index 0000000..70141d5
--- /dev/null
+++ b/src/loops_ii/delayed_assignment.md
@@ -0,0 +1,35 @@
+# Delayed Assignment
+
+The initializer of a `for` loop can give an initial value to a variable
+declared outside of the loop.
+
+```java
+int number;
+for (number = 0; number < 5; number++) {
+    System.out.println("At: " + number);
+}
+```
+
+You might choose to do this so that after the loop is finished, you can still access the variable.
+
+```java
+int number;
+for (number = 0; number < 5; number++) {
+    System.out.println("At: " + number);
+}
+
+// This will work, we can access the variable still.
+System.out.println("Ended at: " + number);
+```
+
+If you had put both the declaration and initial value inside the initializer, you won't be able
+to use that variable after the loop
+
+```java
+for (int number = 0; number < 5; number++) {
+    System.out.println("At: " + number);
+}
+
+// This will not work. number is no longer available
+System.out.println("Ended at: " + number);
+```
\ No newline at end of file
diff --git a/src/loops_ii/drawing_isosceles_triangles.md b/src/loops_ii/drawing_isosceles_triangles.md
new file mode 100644
index 0000000..e40203c
--- /dev/null
+++ b/src/loops_ii/drawing_isosceles_triangles.md
@@ -0,0 +1,47 @@
+# Drawing Isosceles Triangles
+
+Another fun shape is the isosceles triangle.
+
+```
+  *
+ ***
+*****
+```
+
+For this one, the each row of the triangle needs to have spaces before it to shift it in to the
+center. How much each row needs to be shifted depends on how big the trangle will be overall.
+
+In this case with three rows of `*`s, the top `*` needs two space characters before it
+and the second row needs one space character.
+
+```java
+System.out.println("   *\n  ***\n*****");
+```
+
+So any loop we make needs to take this pattern into account.
+
+```java
+int totalRows = 5;
+for (int row = 1; row <= totalRows; row++) {
+    for (int i = 0; i < totalRows - row; i++) {
+        System.out.print(" ");
+    }
+    for (int i = 0; i < row * 2 - 1; i++) {
+        System.out.print("*");
+    }
+    System.out.println();
+}
+```
+
+```
+    *
+   ***
+  *****
+ *******
+*********
+```
+
+Which can get tricky. For now, you can just study the code that does it for this shape. There will be more things to draw
+in the challenges section.[^reason]
+
+[^reason]: The reason I'm focusing on this isn't because its likely you will get a job drawing shapes, but if you can draw a shape [you can dodge a ball](https://www.youtube.com/watch?v=1ZXHsNqkDI4).
diff --git a/src/loops_ii/drawing_right_triangles.md b/src/loops_ii/drawing_right_triangles.md
new file mode 100644
index 0000000..1257809
--- /dev/null
+++ b/src/loops_ii/drawing_right_triangles.md
@@ -0,0 +1,55 @@
+# Drawing Right Triangles
+
+One of the more fun things to do with `for` loops[^quiz] is to use them to print out shapes.
+
+Say you wanted to draw this right triangle.
+
+```
+*
+**
+***
+```
+
+There is one `*`, then two `*`s on the next line, and three `*`s on the last.
+
+If you were to write the code out to print this explicitly it would look like this.
+
+```java
+System.out.print("*\n**\n**\n");
+```
+
+Where `\n` is explicitly putting in the new lines.
+
+Since counting up `1 -> 2 -> 3` is easy with `for` loops, you can translate this
+
+```java
+for (int numberOfStars = 1; numberOfStars <= 3; numberOfStars++) {
+    for (int i = 0; i < numberOfStars; i++) {
+        System.out.print("*");
+    }
+    // Same as System.out.print("\n");
+    System.out.println();
+}
+```
+
+Which makes it easy to make one of these triangles however tall you want.
+
+```java
+int height = 6;
+for (int numberOfStars = 1; numberOfStars <= height; numberOfStars++) {
+    for (int i = 0; i < numberOfStars; i++) {
+        System.out.print("*");
+    }
+    System.out.println();
+}
+```
+
+```
+*
+**
+***
+****
+*****
+******
+```
+
diff --git a/src/loops_ii/empty_expressions.md b/src/loops_ii/empty_expressions.md
new file mode 100644
index 0000000..7592400
--- /dev/null
+++ b/src/loops_ii/empty_expressions.md
@@ -0,0 +1,31 @@
+# Empty Expressions
+
+You are also allowed to leave the expression part of a `for` loop blank.
+
+```java
+for (int i = 0;;i++) {
+    System.out.println(i);
+}
+// 0
+// 1
+// 2
+// 3
+// ... and so on
+```
+
+This means that each time through there is no check to see if the loop will exit.
+The loop will only exit if there is an explicit `break` somewhere.
+
+```java
+for (int i = 0;;i++) {
+    if (i == 5) {
+        break;
+    }
+    System.out.println(i);
+}
+// 0
+// 1
+// 2
+// 3
+// 4
+```
\ No newline at end of file
diff --git a/src/loops_ii/empty_initializers.md b/src/loops_ii/empty_initializers.md
new file mode 100644
index 0000000..6e1d1ea
--- /dev/null
+++ b/src/loops_ii/empty_initializers.md
@@ -0,0 +1,25 @@
+# Empty Initializers
+
+You are allowed to leave the initializer part of a `for` loop blank
+so long as you still have the `;`.
+
+
+```java
+int number = 0;
+for (;number < 5; number++) {
+    System.out.println(number);
+}
+```
+
+You might choose to do this for the same reasons you might choose to split the declaration
+and assignment of the "loop variable." So that the variable will be accessible after the end of the loop.
+
+This way its initialization and declaration can be on the same line, which might be desirable.
+
+```java
+int number = 0;
+for (;number < 5; number++) {
+    System.out.println(number);
+}
+System.out.println("Still have number: " + number);
+```
\ No newline at end of file
diff --git a/src/loops_ii/empty_statements.md b/src/loops_ii/empty_statements.md
new file mode 100644
index 0000000..e0de604
--- /dev/null
+++ b/src/loops_ii/empty_statements.md
@@ -0,0 +1,51 @@
+# Empty Statements
+
+You can even leave the statement part of a `for` loop blank. This means that at
+the end of an iteration there is nothing guarenteed to run.
+
+```java
+for (int i = 6; i > 2;) {
+    System.out.println(i);
+    i--;
+}
+
+// 6
+// 5
+// 4
+// 3
+// 2
+```
+
+If you leave both the initializer and statement blank, that will be functionally identical to a `while` loop.[^cry]
+
+```java
+int number = 1;
+for (;number < 10;) {
+    System.out.println(number);
+    number *= 2;
+}
+
+// Same logic as above
+int number2 = 1;
+while (number2 < 10) {
+    System.out.println(number2);
+    number2 *= 2;
+}
+```
+
+If you leave the initializer, expression, and statement blank it will be the same as a `while (true)` loop.
+
+```java
+for (;;) {
+    System.out.println("The people stated singing it...");
+}
+// Runs forever
+```
+
+The only difference is that `(;;)` looks somewhat like
+
+- A spider
+- The Pokémon Kabuto
+- A person crying
+
+And that can be fun.
\ No newline at end of file
diff --git a/src/loops_ii/final_variables.md b/src/loops_ii/final_variables.md
new file mode 100644
index 0000000..2d062bd
--- /dev/null
+++ b/src/loops_ii/final_variables.md
@@ -0,0 +1,35 @@
+# Final Variables
+
+The initializer of a `for` loop can also declare `final` variables.
+
+```java
+int i = 0;
+for (final String name = "Bob"; i < 5; i++) {
+    System.out.println(name + ": " + i);
+}
+```
+
+This doesn't have much use with loops that track `int`s and `String`s, but if you
+are feeling clever you can use this ability along with arrays or other things you
+can change without reassigning a variable.
+
+```java
+for (final char[] letters = { 'I', 'O', 'U' }; letters[0] != 'A';) {
+    for (int i = 0; i < letters.length; i++) {
+        letters[i] -= 1;
+        System.out.print(letters[i]);
+    }
+    System.out.println();
+}
+
+// HNT
+// GMS
+// FLR
+// EKQ
+// DJP
+// CIO
+// BHN
+// AGM
+```
+
+There aren't many reasons to do this, but it is in fact not against the law and I cannot stop you.
diff --git a/src/loops_ii/for.md b/src/loops_ii/for.md
new file mode 100644
index 0000000..d1bd550
--- /dev/null
+++ b/src/loops_ii/for.md
@@ -0,0 +1,28 @@
+# For
+
+The `for` loop is a shortcut to writing a `while` loop which
+has distinct steps that
+
+- Declare a variable
+- Check that variable to know whether to stop iterating
+- Update the variable at the end of each iteration
+
+As with many things, this might be easiest to see by looking at an example.
+
+```java
+// Will run 10 times
+for (int number = 0; number < 10; number++) {
+    System.out.println(number);
+}
+```
+
+That `for` loop works about the same as this `while` loop.
+
+```java
+int number = 0;
+while (number < 10) {
+    System.out.println(number);
+
+    number++;
+}
+```
\ No newline at end of file
diff --git a/src/loops_ii/for_counting_up_and_down.md b/src/loops_ii/for_counting_up_and_down.md
new file mode 100644
index 0000000..6de304e
--- /dev/null
+++ b/src/loops_ii/for_counting_up_and_down.md
@@ -0,0 +1,23 @@
+# Counting Up and Down
+
+One of the easiest things to do with a `for` loop is count up to or down from
+a given number.
+
+```java
+// Goes from 1 to 100
+for (int currentNumber = 1; currentNumber <= 100; currentNumber++) {
+    System.out.println(currentNumber);
+}
+
+// Goes from 100 to 1
+for (int currentNumber = 100; currentNumber >= 1; currentNumber--) {
+    System.out.println(currentNumber);
+}
+```
+
+You use the initializer to set some variable to a starting number like `int currentNumber = 1`,
+have the expression check if the number is at the target end number like `currentNumber <= 100`,
+and use the statement to change the number by one like `currentNumber++`.[^test]
+
+[^test]: Very often, if you are given a test on `for` loops it will focus on doing all sorts of counting up, down, and around.
+Be prepared.
diff --git a/src/loops_ii/for_syntax.md b/src/loops_ii/for_syntax.md
new file mode 100644
index 0000000..7b045c2
--- /dev/null
+++ b/src/loops_ii/for_syntax.md
@@ -0,0 +1,39 @@
+# For Syntax
+
+A `for` loop has three distinct parts.
+
+1. An initializer.
+
+2. An expression which evaluates to a `boolean`.
+
+3. A statement.
+
+
+```java
+for (<INITIALIZER> ; <EXPRESSION> ; <STATEMENT>) {
+    <CODE HERE>
+}
+```
+
+The initializer is a statement which declares and initializes a variable
+like `int number = 0`.
+
+The expression is some check like `number < 5` that is checked each iteration
+to know if the loop should continue.
+
+The statement is ran at the end of every iteration, generally updating the variable tracked by the
+initializer and expression.
+
+These can be thought of as being the same as a `while` loop written like so.
+
+```java
+<INITIALIZER>;
+while (<EXPRESSION>) {
+    <CODE HERE>
+
+    <STATEMENT>;
+}
+```
+
+
+
diff --git a/src/loops_ii/i.md b/src/loops_ii/i.md
new file mode 100644
index 0000000..ca01b0e
--- /dev/null
+++ b/src/loops_ii/i.md
@@ -0,0 +1,48 @@
+# i
+
+One thing you will very often see if you read other peoples'
+code is that the variable being tracked in a for loop is often called
+`i`.
+
+```java
+String word = "bird";
+
+for (int i = 0; i < array.length; i++) {
+    char letter = word.charAt(i);
+    System.out.println(letter);
+}
+
+// b
+// i
+// r
+// d
+```
+
+While usually naming variables with single letters isn't a great idea,
+most developers carve out an exception for cases like this. Writing `index` gets
+tedious.
+
+Its also helpful to go `i -> j -> k` when you end up nesting `for` loops.[^jindex]
+
+```java
+char[] letters = { 'A', 'B', 'C' };
+int[] numbers = { 1, 2 };
+
+for (int i = 0; i < letters.length; i++) {
+    for (int j = 0; j < numbers.length; j++) {
+        System.out.print(letters[i]);
+        System.out.println(numbers[j]);
+    }
+}
+
+// A1
+// A2
+// B1
+// B2
+// C1
+// C2
+```
+
+Just do not start naming all your variables single letters.
+
+[^jindex]: `j` and `k` standing for jindex an kindex respectfully.
\ No newline at end of file
diff --git a/src/loops_ii/inferred_types.md b/src/loops_ii/inferred_types.md
new file mode 100644
index 0000000..93a3993
--- /dev/null
+++ b/src/loops_ii/inferred_types.md
@@ -0,0 +1,26 @@
+# Inferred Types
+
+The initializer of a `for` loop works the same as any variable assignment, so
+you still are allowed to use `var` so that the type of the declared variable is inferred.
+
+```java
+for (var i = 0; i < 10; i++) {
+    System.out.println(i);
+}
+```
+
+`var` is the same number of letters as `int` so you aren't gaining much when your `for` loop
+is just counting over numbers. 
+
+But if your `for` loop is doing something more exotic, it might make sense.
+
+```java
+for (var repeated = ""; repeated.length() < 5; repeated = repeated + "a") {
+    System.out.println(repeated);
+}
+
+// a
+// aa
+// aaa
+// aaaa
+```
\ No newline at end of file
diff --git a/src/loops_ii/iterate_over_a_string.md b/src/loops_ii/iterate_over_a_string.md
new file mode 100644
index 0000000..c178a12
--- /dev/null
+++ b/src/loops_ii/iterate_over_a_string.md
@@ -0,0 +1,13 @@
+# Iterate over a String
+
+As was shown with `while` loops, being able to count up and down lets
+you iterate over each character in a `String`.
+
+
+```java 
+String name = "Lavigne";
+
+for (int index = 0; index < name.length(); index++) {
+    System.out.println(name.charAt(index));
+}
+```
\ No newline at end of file
diff --git a/src/loops_ii/iterate_over_an_array.md b/src/loops_ii/iterate_over_an_array.md
new file mode 100644
index 0000000..8d9f2c7
--- /dev/null
+++ b/src/loops_ii/iterate_over_an_array.md
@@ -0,0 +1,14 @@
+# Iterate over an Array
+
+In the same way you can use a `for` loop to go through each character of a `String`,
+you can use it to go through each element in an array.
+
+```java
+int[] numbers = { 4, 1, 6, 9 };
+
+for (int index = 0; index < numbers.length; index++) {
+    System.out.println(numbers[index]);
+}
+```
+
+The only difference from `String`s is that instead of `.length()` and `.charAt(...)`, you use `.length` and `[]`.
\ No newline at end of file
diff --git a/src/loops_ii/labeled_break.md b/src/loops_ii/labeled_break.md
new file mode 100644
index 0000000..82d99a9
--- /dev/null
+++ b/src/loops_ii/labeled_break.md
@@ -0,0 +1,30 @@
+# Labeled Break
+
+Labeled breaks work the same with `for` loops as they do with `while` loops.
+
+```java
+outerLoop:
+for (;;) {
+    for (;;) {
+        break outerLoop;
+    }
+}
+```
+
+This applies also to when `while` loops are nested within `for` loops or the other way around.
+
+```java
+outerForLoop:
+for (int i = 0; i < 10; i++) {
+    System.out.println(i);
+    while (i < 100) {
+        if (i == 5) {
+            break outerForLoop;
+        }
+        i++;
+    }
+    System.out.println(i);
+}
+
+// 0
+```
\ No newline at end of file
diff --git a/src/loops_ii/labeled_continue.md b/src/loops_ii/labeled_continue.md
new file mode 100644
index 0000000..fab02c5
--- /dev/null
+++ b/src/loops_ii/labeled_continue.md
@@ -0,0 +1,27 @@
+# Labeled Continue
+
+Labeled continues also work the same in `for` loops as `while` loops, but with the hopefully expected caveat that
+the statement of a `for` loop will always run when you get to the top of it.
+
+```java
+label:
+for (int i = 0; i < 4; i++) {
+    for (int j = 0; j < 3; j++) { 
+        System.out.println ("" + i + ", " + j);
+        if (i == 2) {
+            // i++ will run
+            continue label;
+        }   
+    }
+}
+// 0, 0
+// 0, 1
+// 0, 2
+// 1, 0
+// 1, 1
+// 1, 2
+// 2, 0
+// 3, 0
+// 3, 1
+// 3, 2
+```
\ No newline at end of file
diff --git a/src/methods.md b/src/methods.md
index 8f83418..7d482bf 100644
--- a/src/methods.md
+++ b/src/methods.md
@@ -1 +1,22 @@
 # Methods
+
+All the code you have seen up until this point has lived inside of `void main() {}`.
+
+```java
+void main() {
+    System.out.println("CODE GO HERE");
+}
+```
+
+This isn't sustainable for a few reasons. One is that code can get big. Putting a thousand lines inside of one place can be a lot, let
+alone the hundreds of thousands you need to be Minecraft or the millions you need to be Google. 
+
+Another is that there is almost always code that you will want to run at multiple places in a program. 
+Copy pasting that code can get old.
+
+This is what methods are for. Methods let you split up your code into smaller, reusable chunks.[^def]
+
+
+
+[^def]: The word method comes from a "method of getting things done." You might also hear methods referred to as "functions".
+
diff --git a/src/methods/arguments.md b/src/methods/arguments.md
index 6c09947..64eaf15 100644
--- a/src/methods/arguments.md
+++ b/src/methods/arguments.md
@@ -1 +1,21 @@
 # Arguments
+
+If methods always had to do the same thing each time they were run, they wouldn't be that useful.
+
+The way to customize what happens when a method is called is to have them take "arguments."
+Arguments let the caller of the method change what happens when a method runs.
+As part of a method declaration, you can include a comma separated list of "arguments"
+to that method. These arguments let the caller of the method change what happens when a method runs.
+
+```java
+void sayHello(String name) {
+    System.out.println("Hello " + name + "!");
+}
+
+void main() {
+    // Hello Joshua!
+    sayHello("Joshua");
+    // Hello Claire!
+    sayHello("Claire");
+}
+```
diff --git a/src/methods/declaration.md b/src/methods/declaration.md
new file mode 100644
index 0000000..91334d9
--- /dev/null
+++ b/src/methods/declaration.md
@@ -0,0 +1,9 @@
+# Declaration
+
+The simplest kind of method is declared by writing `void` followed by some name, `()`, and some code inside of a `{` and `}`.
+
+```java
+void doThing() {
+    System.out.println("Hello from inside a method!");
+}
+```
diff --git a/src/methods/invocation.md b/src/methods/invocation.md
new file mode 100644
index 0000000..9a35cd6
--- /dev/null
+++ b/src/methods/invocation.md
@@ -0,0 +1,32 @@
+# Invocation
+
+Once you've declared a method you can run the code inside of it by writing the
+name of the method followed by `()` in a statement.
+
+```java
+void doThing() {
+    System.out.println("Hello from inside a method!");
+}
+
+void main() {
+    doThing();
+}
+```
+
+Running the code in a method can be called a few things. "Running a method", "Calling a method", or "Invoking a method."[^wizard]
+
+You can call a method multiple times. If you do, then the code inside of it will be run multiple times.
+
+```java
+void doThing() {
+    System.out.println("Hello from inside a method!");
+}
+
+void main() {
+    doThing();
+    doThing();
+}
+```
+
+
+[^wizard]: I like that last one because "invoking" makes me sound like a Wizard.
\ No newline at end of file
diff --git a/src/methods/main.md b/src/methods/main.md
new file mode 100644
index 0000000..aa66614
--- /dev/null
+++ b/src/methods/main.md
@@ -0,0 +1,17 @@
+# main
+
+The `main` method works the same as any other method. Java just treats it special by choosing to
+call it in order to start your programs.
+
+This means you can do anything in your `main` method you can do in any other method, including returning early.
+
+```java
+void main() {
+    int x = 5;
+
+    if (x == 5) {
+        return;
+    }
+
+    System.out.println("WONT RUN");
+}
\ No newline at end of file
diff --git a/src/methods/pure_functions.md b/src/methods/pure_functions.md
new file mode 100644
index 0000000..0b49eec
--- /dev/null
+++ b/src/methods/pure_functions.md
@@ -0,0 +1,25 @@
+# Pure Functions
+
+When a method only uses its arguments in order to compute a return value
+but doesn't otherwise change the outside world, we call those methods
+"pure functions."
+
+```java
+// square just uses x to compute the square of x
+int square(int x) {
+    return x * x;
+}
+```
+
+If a method changes any values non-local to it, such as by assigning values to an array,
+we consider it to be "impure."
+
+```java
+void multiplyAllByTwo(int[] numbers) {
+    for (int i = 0; i < numbers.length; i++) {
+        // 
+        numbers[i] = numbers[i] * 2;
+    }
+}
+
+The term "pure" comes from the notion of "pure mathematics."
\ No newline at end of file
diff --git a/src/methods/return.md b/src/methods/return.md
new file mode 100644
index 0000000..ff1dfa5
--- /dev/null
+++ b/src/methods/return.md
@@ -0,0 +1,42 @@
+# Return
+
+Anywhere inside of a method you can write `return` to immediately exit that method.
+
+```java
+void willReturnEarly() {
+    for (int i = 0; i < 10; i++) {
+        System.out.println(i);
+        if (i == 5) {
+            // Will stop at 5 because we exit the method
+            return;
+        }
+    }
+
+    System.out.println("THIS WONT RUN");
+}
+
+void main() {
+    willReturnEarly();
+}
+```
+
+This will break out of any loops and skip running any other code in the method.
+
+```java
+void escapeFromLoops() {
+    while (true) {
+        for (;;) {
+            for (;;) {
+                while (true) {
+                    // Escape!
+                    return;
+                }
+            }
+        }
+    }
+}
+
+void main() {
+    escapeFromLoops();
+}
+```
\ No newline at end of file
diff --git a/src/methods/return_values.md b/src/methods/return_values.md
index 515be6d..67536f5 100644
--- a/src/methods/return_values.md
+++ b/src/methods/return_values.md
@@ -1 +1,37 @@
 # Return Values
+
+In addition to running some code, a method can return a value to the code that is calling it.
+
+To do this, instead of writing `void` before a method, you should write the name of a type like `int`.
+Then at the end of the method you need to write `return` followed by something which is that type.
+
+```java
+int returnsEight() {
+    return 8;
+}
+```
+
+When the method is called, that expression can be used on the right hand side of an `=` to get the value returned by the method.
+
+```java
+int returnsEight() {
+    return 8;
+}
+
+void main() {
+    int value = returnsEight();
+    System.out.println(value);
+}
+```
+
+The method call can also be used directly in expressions without assigning its value to a variable first.
+
+```java
+String returnsName() {
+    return "Mariah";
+}
+
+void main() {
+    System.out.println(returnsName() + " is my name");
+}
+```
\ No newline at end of file
diff --git a/src/methods/scope.md b/src/methods/scope.md
new file mode 100644
index 0000000..d0a5f0b
--- /dev/null
+++ b/src/methods/scope.md
@@ -0,0 +1,39 @@
+# Scope
+
+Methods can contain any code, including variable declarations.
+
+```java
+void sayMathStuff() {
+    int x = 1;
+    int y = 2;
+    System.out.println("x is " + x);
+    System.out.println("y is " + y);
+    System.out.println("x + y is " + (x + y));
+}
+
+void main() {
+    sayMathStuff();
+}
+```
+
+When a method declares a variable inside of its body, that declaration is "scoped" to that method.
+Other code cannot see that variable.
+
+```java
+void sayMathStuff() {
+    int x = 1;
+    int y = 2;
+    System.out.println("x is " + x);
+    System.out.println("y is " + y);
+    System.out.println("x + y is " + (x + y));
+}
+
+void main() {
+    sayMathStuff();
+    // Error, x doesn't exist here
+    System.out.println(x);
+}
+```
+
+This is why we have called variables "local variables." They are local to the "scope" of the
+method they are declared in.
\ No newline at end of file
diff --git a/src/methods/unreachable_statements.md b/src/methods/unreachable_statements.md
new file mode 100644
index 0000000..b2f014b
--- /dev/null
+++ b/src/methods/unreachable_statements.md
@@ -0,0 +1,35 @@
+# Unreachable Statements
+
+If Java can figure out that some line of code is unreachable because it will always come after a
+`return`, then it will not run your code.
+
+```java
+void doThing() {
+    System.out.println("A");
+    return;
+    // unreachable statement
+    System.out.println("B");
+}
+
+void main() {
+    doThing();
+}
+```
+
+Java is easy to trick though.[^trick]
+
+```java
+void doThing() {
+    System.out.println("A");
+    if (true) {
+        return;
+    }
+    System.out.println("B");
+}
+
+void main() {
+    doThing();
+}
+```
+
+[^trick]: This _will_ always return before the `println`, but Java chooses to not figure that out. It can't be smart enough to see through every `if`, so it doesn't try for any of them.
diff --git a/src/methods/void.md b/src/methods/void.md
index abd5d47..bc10d70 100644
--- a/src/methods/void.md
+++ b/src/methods/void.md
@@ -1 +1,24 @@
 # void
+
+All methods have to declare some return type. `void` is what you write when a method won't return any value.
+
+```java
+// Returns a String
+String title() {
+    return "All Night";
+}
+
+// Returns an int
+int views() {
+    return 4071;
+}
+
+// Doesn't return any value.
+void talkAboutVideo() {
+    System.out.println(title() + " only has " + views() + " views.");
+}
+
+void main() {
+    talkAboutVideo();
+}
+```
\ No newline at end of file
diff --git a/src/null/checking_for_null.md b/src/null/checking_for_null.md
new file mode 100644
index 0000000..b5ca530
--- /dev/null
+++ b/src/null/checking_for_null.md
@@ -0,0 +1 @@
+# Checking for null
diff --git a/src/null/field_access.md b/src/null/field_access.md
new file mode 100644
index 0000000..87c6259
--- /dev/null
+++ b/src/null/field_access.md
@@ -0,0 +1 @@
+# Field Access
diff --git a/src/null/instance_methods.md b/src/null/instance_methods.md
new file mode 100644
index 0000000..d8122d8
--- /dev/null
+++ b/src/null/instance_methods.md
@@ -0,0 +1 @@
+# Instance Methods
diff --git a/src/return b/src/return
new file mode 100644
index 0000000..b98287e
--- /dev/null
+++ b/src/return
@@ -0,0 +1 @@
+# Conversion From Integers
diff --git a/src/return_values.md b/src/return_values.md
new file mode 100644
index 0000000..67536f5
--- /dev/null
+++ b/src/return_values.md
@@ -0,0 +1,37 @@
+# Return Values
+
+In addition to running some code, a method can return a value to the code that is calling it.
+
+To do this, instead of writing `void` before a method, you should write the name of a type like `int`.
+Then at the end of the method you need to write `return` followed by something which is that type.
+
+```java
+int returnsEight() {
+    return 8;
+}
+```
+
+When the method is called, that expression can be used on the right hand side of an `=` to get the value returned by the method.
+
+```java
+int returnsEight() {
+    return 8;
+}
+
+void main() {
+    int value = returnsEight();
+    System.out.println(value);
+}
+```
+
+The method call can also be used directly in expressions without assigning its value to a variable first.
+
+```java
+String returnsName() {
+    return "Mariah";
+}
+
+void main() {
+    System.out.println(returnsName() + " is my name");
+}
+```
\ No newline at end of file
diff --git a/src/return_values/conversion.md b/src/return_values/conversion.md
new file mode 100644
index 0000000..3b5a591
--- /dev/null
+++ b/src/return_values/conversion.md
@@ -0,0 +1,27 @@
+# Conversion
+
+When a value is returned, Java will want to coerce it into
+the type of value that the method says it returns.
+
+If Java knows how to do that conversion, then it can happen automatically.
+
+```java
+// This method declares a return type of double.
+double returnFive() {
+    // x is an int
+    int x = 5;
+    // When it is returned, it will be turned into a double 
+    return x;
+}
+```
+
+But if that conversion might potentially be lossy, as with converting `double`s to `int`s,
+you must do it yourself.
+
+```java
+double returnNine() {
+    double nine = 9.0;
+    // The (int) explicitly converts the double to an int
+    return (int) nine;
+}
+```
\ No newline at end of file
diff --git a/src/return_values/pure_functions.md b/src/return_values/pure_functions.md
new file mode 100644
index 0000000..e8e0b12
--- /dev/null
+++ b/src/return_values/pure_functions.md
@@ -0,0 +1,34 @@
+# Pure Functions
+
+When a method only uses its arguments in order to compute a return value
+but doesn't otherwise change the outside world, we call those methods
+"pure functions."
+
+```java
+// square just uses x to compute the square of x
+int square(int x) {
+    return x * x;
+}
+```
+
+If a method changes any values non-local to it, such as by assigning values to an array,
+we consider it to be "impure."
+
+```java
+void multiplyAllByTwo(int[] numbers) {
+    for (int i = 0; i < numbers.length; i++) {
+        // This assignment is "impure" since it changes
+        // something outside the method.
+        numbers[i] = numbers[i] * 2;
+    }
+}
+```
+
+The term "pure" comes from the notion of "pure mathematics." 
+
+Pure functions are useful in the sense that they can be easier to understand on account of having what
+they do only depend on their inputs. 
+
+They can also be easier to verify. To know if a pure function does
+what you expect it to, you can give it example arguents and check to see that its return values are what
+you expect.
\ No newline at end of file
diff --git a/src/return_values/void.md b/src/return_values/void.md
new file mode 100644
index 0000000..3080a06
--- /dev/null
+++ b/src/return_values/void.md
@@ -0,0 +1,25 @@
+# void
+
+All methods have to declare some return type. `void` is what you write when a method won't return any value.
+
+```java
+// Returns a String
+String title() {
+    return "All Night";
+}
+
+// Returns an int
+int views() {
+    return 4071;
+}
+
+// Doesn't return any value.
+void talkAboutVideo() {
+    System.out.println(title() + " only has " + views() + " views.");
+}
+
+// This is what the void in "void main()" means
+void main() {
+    talkAboutVideo();
+}
+```
\ No newline at end of file
diff --git a/src/strings/access_individual_characters.md b/src/strings/access_individual_characters.md
index edca4d1..1485059 100644
--- a/src/strings/access_individual_characters.md
+++ b/src/strings/access_individual_characters.md
@@ -9,16 +9,16 @@ The second by using `1`, and so on.
 ```java
 String spy = "loid";
 
-char l = spi.charAt(0);
+char l = spy.charAt(0);
 System.out.println(l);
 
-char o = spi.charAt(1);
+char o = spy.charAt(1);
 System.out.println(o);
 
-char i = spi.charAt(2);
+char i = spy.charAt(2);
 System.out.println(i);
 
-char d = spi.charAt(3);
+char d = spy.charAt(3);
 System.out.println(d);
 ```