diff --git a/.github/workflows/linter.yaml b/.github/workflows/linter.yaml
index 554faa4..0544efa 100644
--- a/.github/workflows/linter.yaml
+++ b/.github/workflows/linter.yaml
@@ -3,21 +3,20 @@ name: Linter
 on: [pull_request]
 
 jobs:
-  markdown-linter:
-    name: "Markdown Linter"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
+#  markdown-linter:
+#    name: "Markdown Linter"
+#    runs-on: ubuntu-latest
+#    steps:
+#      - uses: actions/checkout@v2
+#      - name: markdownlint-cli
+#        uses: nosborn/github-action-markdown-cli@v3.2.0
+#        with:
+#          files: .
+#          config_file: .markdownlint.yaml
 
-      - name: markdownlint-cli
-        uses: nosborn/github-action-markdown-cli@v3.2.0
-        with:
-          files: .
-          config_file: .markdownlint.yaml
-
-  markdown-link-check:
-    name: "Markdown Link Checker"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.14
+#  markdown-link-check:
+#    name: "Markdown Link Checker"
+#    runs-on: ubuntu-latest
+#    steps:
+#      - uses: actions/checkout@v2
+#      - uses: gaurav-nelson/github-action-markdown-link-check@1.0.14
diff --git a/README.md b/README.md
index aa98b90..5c15e22 100644
--- a/README.md
+++ b/README.md
@@ -3,10 +3,48 @@
 [![codefactor](https://img.shields.io/codefactor/grade/github/together-java/modernjava)](https://www.codefactor.io/repository/github/together-java/modernjava)
 [![license](https://img.shields.io/github/license/Together-Java/ModernJava)](https://github.com/Together-Java/ModernJava/blob/master/LICENSE)
 
-Book teaching how to write modern and effective Java. It is maintained by the community, anyone can contribute.
+Greetings.
+
+This is a book intended to teach someone the Java language, from scratch. 
+
+You will find that the content makes heavy use of recently released and, for the moment,
+preview features. This is intentional as much of the topic ordering doesn't work
+without at least Java 21.
+
+Right now I have several key areas where I could use some help:
+
+* Writing Challenges. Most of the early sections have challenges students can do to test
+their understanding of the topics covered and for practice. I've shifted my focus away from
+these to make more progress on the main content of the book. Any assistance would be appreciated.
+* Theming. A lot of the chapters are...bland. Purely technical. I find that when I have the imagination to "theme" the subjects they become higher quality and more engaging overall. See
+an anime you liked recently and think you can make the math chapters use the characters from it?
+Give it a shot!
+* Fixing Mechanical Issues. I don't have an editor and I don't often proofread. If you find mechanical errors
+in my grammar or find issues with the way topics are ordered I would welcome fixes.
+
+Notably I do not want to open the floodgates for contributions on the main chapter content
+just yet. This has the downside of slower progress but the upside of a more coherent result.
+
+My primary goals with this are
+
+* Get the ordering of topics right. By this I mean that every topic covered should have had its pre-requitsites covered in the topics previous. While "lesson 1: Inheritance" is clearly wrong
+in this regard, some things are more subtle.
+* Be a template for other people. This is a book. Not everyone likes books, some like youtube videos, some like over priced udemy courses, some attend College, etc. Everyone has different learning paths. I hope this to be of use to anyone looking to make a more up to date Java
+curriculum and hope that the vague order of things (which I consider superior to the content
+produced with the Java of years' past) as carried through.
+* Write as if the newest Java wasn't new. Its obvious when a book was written before Java 8
+because it always has newer additions with "addendum: brand new stuff in Java 8." But 
+the order language features were introduced is hardly a good order to teach them. You have
+to pretend that Java 21 has always been *the* Java. Does it really make sense to show terrible
+C-style switch statements way before switch expressions?
+* Write as if the words Object Oriented Programming, Functional Programming, etc. didn't exist.
+While I understand that these all have definitions and are useful concepts to know about, introducing them early seems to lead to either dogma, rejection of said dogma, or some
+mix thereof. None of them are actually needed to understand the mechanics of and motivation
+behind what we would call "object oriented" or "functional" techniques. They certainly don't
+work as justification for adding getters and setters to every class.
 
 Feel free to join our [discord server](https://discord.gg/together-java-272761734820003841)
-if you have any questions, or require assistance with the project. :relaxed:
+if you have any questions, or require assistance with the project.
 
 ## Getting started
 
diff --git a/ferris.js b/ferris.js
index 5a7f1f6..e74c34c 100644
--- a/ferris.js
+++ b/ferris.js
@@ -54,7 +54,16 @@ function createFerris(type, size) {
   a.setAttribute('target', '_blank')
 
   var toFileName = function (t) {
-    return '../img/' + t.attr + '.svg';
+    // return '../img/' + t.attr + '.svg';
+    if (t.attr == 'panics') {
+      return '../img/duke_armcross.webp'
+    }
+    else if (t.attr == 'does_not_compile') {
+      return '../img/duke_computer.webp'
+    }
+    else if (t.attr == 'not_desired_behavior') {
+      return '../img/duke_finger.webp'
+    }
   }
 
   var img = document.createElement('img')
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 173903d..0371702 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -447,6 +447,8 @@
   - [Integer to a Base 16 String](./integers_ii/integer_to_a_base_16_string.md)
   - [Underscores in Integer Literals](./integers_ii/underscores_in_integer_literals.md)
 
+- [🚧 Construction Zone 🚧]()
+
 # Interactive Programs III
 
 - [Files](./files.md)
@@ -456,64 +458,112 @@
   - [Write to a File](./files/write_to_a_file.md)
   - [Read from a File](./files/read_from_a_file.md)
   - [Create a Folder](./files/creating_a_folder.md)
-  - [Delete a Folder](./files/creating_a_folder.md)
-  - [Delete a File](./files/creating_a_folder.md)
+  - [Delete a Folder](./files/deleting_a_folder.md)
+  - [Delete a File](./files/deleting_a_file.md)
 
 # Data Structures & Algorithms II
 
-- [Hash Maps]()
-- [Hash Sets]()
+- [Hash Maps](./hash_maps.md)
+  - [Filing Cabinets](./hash_maps/filing_cabinets.md)
+  - [Hash Functions](./hash_maps/hash_functions.md)
+  - [Function Range](./hash_maps/function_range.md)
+  - [Buckets](./hash_maps/buckets.md)
+  - [Hash Collision](./hash_maps/hash_collision.md)
+  - [Hash Distribution](./hash_maps/hash_distribution.md)
+  - [Growable Buckets](./hash_maps/growable_buckets.md)
+  - [Keys and Values](./hash_maps/keys_and_values.md)
+  - [Put Items](./hash_maps/put_items.md)
+  - [Get Items](./hash_maps/get_items.md)
+  
 
 # Code Structure IV
 
+- [Object](./objects.md)
+  - [Subtypes](./objects/subtypes.md)
+  - [instanceof](./objects/instanceof.md)
+  - [toString](./objects/toString.md)
+  - [Override toString](./objects/override_toString.md)
+  - [@Override](./objects/override.md)
+  - [equals and hashCode](./objects/equals_and_hashCode.md)
+  - [Override equals and hashCode](./objects/override_equals_and_hashCode.md)
+  - [Variance and Casting](./objects/variance_and_casting.md)
+  - [Subclasses](./objects/subclasses.md)
+- [Generics](./generics.md)
+- [Interfaces](./interfaces.md)
 
-- [Interfaces]()
-  - [@Override]()
-- [Generics]()
-  - [Casting]()
-- [Object]()
-  - [instanceof]()
-  - [toString]()
-  - [equals]()
-  - [hashCode]()
-
-
-<!--
-
-
-
-# Data Types IV
-
-- [StringBuilder](./string_builder.md)
-- [Pattern]()
-
-
-# Concepts
+# Data Types V
 
-- [The Idiot Game](./the_idiot_game.md)
+<!-- Note: Put a joke about the "A train leaves chicago at ..." problems.
+Make them do one. -->
+- [Time](./time.md)
+  - [Instant](./time/instant.md)
+  - [Duration](./time/duration.md)
+  - [LocalDate](./time/local_date.md)
+  - [LocalTime](./time/local_time.md)
+  - [LocalDateTime](./time/local_date_time.md)
+  - [ZonedDateTime](./time/zoned_date_time.md)
+  - [OffsetDateTime](./time/offset_date_time.md)
+- [ArrayList](./array_list.md)
+  - [Ubiquity](./array_list/ubiquity.md)
+  - [Add an item](./array_list/add_an_item.md)
+  - [Size](./array_list/size.md)
+  - [Get an item](./array_list/get_an_item.md)
+  - [Loop over items](./array_list/loop_over_items.md)
+  - [Set an item](./array_list/set_an_item.md)
+  - [Remove an item](./array_list/remove_an_item.md)
+- [HashMap](./hash_map.md)
+- [Multi-Dimensional Arrays](./multi_dimensional_arrays.md)
 
-# Interactive Programs
+# Control Flow IV
+- [Loops III](./loops_iii.md)
+  - [For-each loops]()
+  - [Arrays]()
+  - [Iterable]()
+  - [ArrayList]()
+  - [Reasons to go back]() <!-- -->
+- [Switch III](./switch_iii.md)
+  - [Fallthrough](./switch_iii/fallthrough.md)
+  - [break](./switch_iii/break.md)
+  - [default](./switch_iii/default.md)
+  - [return](./switch_iii/return.md)
+  - [yield](./switch_iii/yield.md)
+- [Recursion](./recursion.md)
+  - [Disclaimer](./recursion/disclaimer.md)
+  - [Base Case](./recursion/base_case.md)
+  - [Comparison to Delegation](./recursion/comparison_to_delegation.md)
+  - [Comparison to Loops](./recursion/comparison_to_loops.md)
 
+# Code Structure V
+- [Class Extension](./class_extension.md)
+- [Abstract Classes](./abstract_classes.md)
 
-# The Computing Environment
+# Concepts II
 
+- [Encapsulation](./encapsulation.md)
+  - [Methods]()
+  - [Classes]()
+  - [Information Hiding]()
 
+# Building
 
+- [Compilation]()
+- [Compile Java Code]()
+  - [Compile a List of Files]()
+  - [Specify Where to Find Sources]()
+  - [Enable Debug Info]()
 
+# Data Types VI
+- [StringBuilder]()
+- [Pattern]()
 
-# Interactive Programs
+<!--
 
 
-- [Command Line Arguments]()
 
-# Code Structure IV
 
+# Concepts
 
-- [Import]()
-- [Packages]()
-  - [Public]()
-  - [Package Private]()
-  
+- [The Idiot Game](./the_idiot_game.md)
 
 # Data Types V
 
@@ -521,11 +571,6 @@
 - [StringBuilder](./stringbuilder.md)
 - [Regular Expressions]()
 
-# Code Structure V
-
-- [toString]()
-- [Interfaces]()
-  - [@Override]()
 
 
 # Code Structure V
@@ -535,6 +580,8 @@
   - [Safety]()
   - [Unsafe Casts]()
 
+[Informal Diagrams]
+
 # Data Types VI
 
 - [Integers II]()
@@ -546,7 +593,6 @@
   - [Add an item]()
   - [Get an item]()
   - [Set an item]()
-  - [Loop over Contents]()
 
 # Control Flow IV
 
@@ -564,10 +610,6 @@
 - [Sets]()
   - [HashSet]()
 
-# Interactive Programs II
-
-- [Files]()
-
 # Metaprogramming
 
 - [Reflection]()
diff --git a/src/abstract_classes.md b/src/abstract_classes.md
new file mode 100644
index 0000000..6a4037d
--- /dev/null
+++ b/src/abstract_classes.md
@@ -0,0 +1 @@
+# Abstract Classes
diff --git a/src/array_list.md b/src/array_list.md
new file mode 100644
index 0000000..0d6784e
--- /dev/null
+++ b/src/array_list.md
@@ -0,0 +1,15 @@
+# ArrayList
+
+Java comes with a generic growable array. It is called
+an `ArrayList`.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("John Wick");
+
+    System.out.println(names);
+}
+```
\ No newline at end of file
diff --git a/src/array_list/add_an_item.md b/src/array_list/add_an_item.md
new file mode 100644
index 0000000..377d1e4
--- /dev/null
+++ b/src/array_list/add_an_item.md
@@ -0,0 +1,23 @@
+# Add an item
+
+To add an item to an `ArrayList` you use the `.add`
+method.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("The Bowery King");
+    names.add("Caine");
+
+    System.out.println(names);
+}
+```
+
+The way this works is conceptually the 
+same as the growable array that we went over earlier.
+
+All you need to know though is that you can add 
+as many items as you will and the container will grow
+dynamically.
diff --git a/src/array_list/get_an_item.md b/src/array_list/get_an_item.md
new file mode 100644
index 0000000..110b467
--- /dev/null
+++ b/src/array_list/get_an_item.md
@@ -0,0 +1,31 @@
+# Get an item
+
+To get an item at a given index in an `ArrayList`
+you should use `.get`
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("Winston Scott");
+
+    String name = names.get(0);
+    System.out.println(name);
+}
+```
+
+If the index you picked is greater than the number of elements in the `ArrayList`
+it will throw an `IndexOutOfBoundsException`
+
+```java,panics
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("Killa Harkan");
+
+    String name = names.get(10);
+    System.out.println(name);
+}
+```
\ No newline at end of file
diff --git a/src/array_list/loop_over_items.md b/src/array_list/loop_over_items.md
new file mode 100644
index 0000000..72bff23
--- /dev/null
+++ b/src/array_list/loop_over_items.md
@@ -0,0 +1,25 @@
+# Loop over Contents
+
+Just like the `.length` and `[]` operations on arrays,
+you can loop over all the elements in an `ArrayList`
+with the combination of `.size()` and `.get(idx)`
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("Sofia Al-Azwar");
+    names.add("Viggo Tarasov");
+    names.add("Iosef Tarasov");
+
+    for (int i = 0; i < names.size(); i++) {
+        String name = names.get(i);
+
+        System.out.println("NAME: " + name);
+    }
+}
+```
+
+Its not a rule, but this is also a convenient use of for loops.
+You can use all the same tricks you learned when looping over arrays here.
\ No newline at end of file
diff --git a/src/array_list/remove_an_item.md b/src/array_list/remove_an_item.md
new file mode 100644
index 0000000..d4be0db
--- /dev/null
+++ b/src/array_list/remove_an_item.md
@@ -0,0 +1,91 @@
+# Remove an item
+
+You can use `.remove` to remove an item
+from an `ArrayList`.
+
+To do this you need to provide it the value you want to remove.
+It will do all the array resizing required internally, even
+if the item is in the middle of a list.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("The Bowry King");
+    names.add("The Elder");
+    names.add("The Harbinger");
+
+    System.out.println(names);
+
+    names.remove("The Elder");
+
+    System.out.println(names);
+}
+```
+
+Alternatively you can remove an item by its index.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("The Bowry King");
+    names.add("The Elder");
+    names.add("The Harbinger");
+
+    System.out.println(names);
+
+    names.remove(2);
+    names.remove(0);
+
+    System.out.println(names);
+}
+```
+
+You need to be careful about that though. If your `ArrayList` holds `Integer`s then
+Java can get confused between the implementation of remove that removes using the item itself
+and the one that removes by index.
+
+```java,not_desired_behavior
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<Integer> numbers = new ArrayList<>();
+    numbers.add(1);
+    numbers.add(2);
+    numbers.add(3);
+
+    System.out.println(numbers);
+
+    // Notice that this removes "2" which is at index 1!
+    numbers.remove(1);
+
+    System.out.println(numbers);
+}
+```
+
+This comes down to `int` and `Integer` being slightly different. When Java
+sees an integer literal it assumes it is an `int`. It is only when circumstances
+are such that it cannot possibly be an `int` that it automatically boxes it 
+into an `Integer`.
+
+It is rare, but if you encounter this issue you can use `Integer.valueOf` to deal with it.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<Integer> numbers = new ArrayList<>();
+    numbers.add(1);
+    numbers.add(2);
+    numbers.add(3);
+
+    System.out.println(numbers);
+
+    numbers.remove(Integer.valueOf(1));
+
+    System.out.println(numbers);
+}
+```
\ No newline at end of file
diff --git a/src/array_list/set_an_item.md b/src/array_list/set_an_item.md
new file mode 100644
index 0000000..766ed00
--- /dev/null
+++ b/src/array_list/set_an_item.md
@@ -0,0 +1,30 @@
+# Set an item
+
+You can set an item at an index with `.set`
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("John Wick");
+
+    names.set(0, "Baba Yaga");
+
+    System.out.println(names);
+    System.out.println(names.get(0));
+}
+```
+
+If the index you provide is out of bounds, you will get an `IndexOutOfBoundsException`.
+
+```java,panics
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+    names.add("John Wick");
+
+    names.set(15, "Baba Yaga");
+}
+```
\ No newline at end of file
diff --git a/src/array_list/size.md b/src/array_list/size.md
new file mode 100644
index 0000000..7f0ed72
--- /dev/null
+++ b/src/array_list/size.md
@@ -0,0 +1,27 @@
+# Size
+
+The you can access the number of elements in an
+`ArrayList` with the `.size()` method.
+
+```java
+import java.util.ArrayList;
+
+void main() {
+    ArrayList<String> names = new ArrayList<>();
+
+    System.out.println(names.size());
+
+    names.add("Vincent Bisset de Gramont");
+    System.out.println(names.size());
+
+    names.add("Mr. Nobody");
+    System.out.println(names.size());
+}
+```
+
+This will tell you the number of elements in the `ArrayList` but
+not the amount of space allocated by the underlying array. 
+
+This is fine because, if you aren't the one making a growable array,
+it doesn't matter. All you need to concern yourself with is what is actually
+there, not any book keeping.
\ No newline at end of file
diff --git a/src/array_list/ubiquity.md b/src/array_list/ubiquity.md
new file mode 100644
index 0000000..cef161b
--- /dev/null
+++ b/src/array_list/ubiquity.md
@@ -0,0 +1,14 @@
+# Ubiquity
+
+Java comes with many classes. Some of these
+you might use a few times (like `LocalTime`), some you 
+will see every day of your coding life (like `String`).
+
+`ArrayList` is in the second category. It turns out
+that a growable list of things is needed for a lot
+of different tasks. It is ubiquitous in code that
+you will see in the real world.
+
+I mention this mostly to make sure you are paying attention.
+Its not particuarly hard, but try not to zone out on these sorts
+of chapters.
\ No newline at end of file
diff --git a/src/class_extension.md b/src/class_extension.md
new file mode 100644
index 0000000..6a64a38
--- /dev/null
+++ b/src/class_extension.md
@@ -0,0 +1 @@
+# Class Extension
diff --git a/src/encapsulation.md b/src/encapsulation.md
new file mode 100644
index 0000000..3bd7237
--- /dev/null
+++ b/src/encapsulation.md
@@ -0,0 +1 @@
+# Encapsulation
diff --git a/src/files/creating_a_folder.md b/src/files/creating_a_folder.md
index 8840e6f..78e4e42 100644
--- a/src/files/creating_a_folder.md
+++ b/src/files/creating_a_folder.md
@@ -1 +1,19 @@
 # Creating a Folder
+
+To create a folder, you can use `Files.createDirectory`.
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+    void main() throws IOExeption {
+        Path folderPath = Path.of("example1");
+        Files.createDirectory(folderPath);
+    }
+}
+```
+
+This, like the other methods in `Files`, throws an `IOException`.
+
+`Files.createDirectory` will fail if the folder already exists.
diff --git a/src/files/deleting_a_file.md b/src/files/deleting_a_file.md
new file mode 100644
index 0000000..ac636a4
--- /dev/null
+++ b/src/files/deleting_a_file.md
@@ -0,0 +1 @@
+# Delete a File
diff --git a/src/files/deleting_a_folder.md b/src/files/deleting_a_folder.md
new file mode 100644
index 0000000..2bb5145
--- /dev/null
+++ b/src/files/deleting_a_folder.md
@@ -0,0 +1 @@
+# Delete a Folder
diff --git a/src/generic_growable_arrays.md b/src/generic_growable_arrays.md
new file mode 100644
index 0000000..9b5525a
--- /dev/null
+++ b/src/generic_growable_arrays.md
@@ -0,0 +1 @@
+# Generic Growable Arrays
diff --git a/src/generic_growable_arrays/arraylist.md b/src/generic_growable_arrays/arraylist.md
new file mode 100644
index 0000000..6b95c2f
--- /dev/null
+++ b/src/generic_growable_arrays/arraylist.md
@@ -0,0 +1 @@
+# ArrayList
diff --git a/src/generic_hash_maps/hash_map b/src/generic_hash_maps/hash_map
new file mode 100644
index 0000000..96e549d
--- /dev/null
+++ b/src/generic_hash_maps/hash_map
@@ -0,0 +1 @@
+# HashMap
diff --git a/src/generics.md b/src/generics.md
new file mode 100644
index 0000000..c7e8cef
--- /dev/null
+++ b/src/generics.md
@@ -0,0 +1,4 @@
+# Generics
+
+```java
+public class 
\ No newline at end of file
diff --git a/src/getting_started.md b/src/getting_started.md
index 95081e6..dd99463 100644
--- a/src/getting_started.md
+++ b/src/getting_started.md
@@ -15,6 +15,16 @@ void main() {
 }
 ```
 
+## Windows
+
+Download the "JDK MSI" from [adoptium.net](https://adoptium.net/temurin/releases/?version=22&os=windows).
+
+Run the installer, selecting all the default options.
+
+## Mac OS
+
+
+
 ## repl.it
 
 [replit.com](https://replit.com) is a pretty common choice for teachers because
diff --git a/src/hash_map.md b/src/hash_map.md
new file mode 100644
index 0000000..96e549d
--- /dev/null
+++ b/src/hash_map.md
@@ -0,0 +1 @@
+# HashMap
diff --git a/src/hash_maps.md b/src/hash_maps.md
new file mode 100644
index 0000000..dc781ef
--- /dev/null
+++ b/src/hash_maps.md
@@ -0,0 +1,33 @@
+# Hash Maps
+
+If you want to find an element in an array you usually
+need to check every element one by one.
+
+```java
+String[] carsCharacters = new String[] {
+    "Tow Mater",
+    "Lightning McQueen",
+    "Doc Hudson"
+};
+
+boolean wasInCars(String name) {
+    for (var characterName : carsCharacters) {
+        if (characterName.equals(name)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void main() {
+    System.out.println(wasInCars("Lightning McQueen"));
+    System.out.println(wasInCars("Blade Ranger"));
+}
+```
+
+For small arrays, this is no biggie. A computer can check over a few dozen things pretty quickly.
+
+But for big arrays, this stinks.
+
+What we want is some way to quickly look up something, regardless of how many things there are to
+check over. This is what a Hash Map gives us.
\ No newline at end of file
diff --git a/src/hash_maps/buckets.md b/src/hash_maps/buckets.md
new file mode 100644
index 0000000..5353323
--- /dev/null
+++ b/src/hash_maps/buckets.md
@@ -0,0 +1,79 @@
+# Buckets
+
+Once you know the range of your hash function,
+the next step is to divide that range into buckets.
+
+A bucket is the name for the place where you will store
+all the values that match that hash key.
+
+
+```java,no_run
+class Bucket {
+
+}
+```
+
+One way to divide your range into buckets is to make an array
+then pick an index into that array by the hash.
+
+```java
+record CarsCharacter(
+    String firstName, 
+    String lastName
+) {}
+
+// Like before, we define our hash function
+// to be the first letter of the last name.
+char hashFunction(
+    CarsCharacter carsCharacter
+) {
+    return carsCharacter.lastName().charAt(0);
+}
+
+class Bucket {
+
+}
+
+// Then, assuming we have some array of buckets
+Bucket[] buckets = new Bucket[] {
+    new Bucket(),
+    new Bucket(),
+    new Bucket()
+};
+
+// We can make logic that takes the result of the hash
+// and gives an index for a bucket.
+int indexFor(char hash) {
+    if (hash >= 'A' && hash <= 'F') {
+        return 0;
+    }
+    else if (hash >= 'G' && hash <= 'N') {
+        return 1;
+    }
+    else {
+        return 2;
+    }
+}
+
+
+void main() {
+    // These two have different hashes but end up in the
+    // same bucket
+    var sally = new CarsCharacter("Sally", "Carrera");
+    System.out.println(hashFunction(sally));
+    System.out.println(indexFor(hashFunction(sally)));
+
+    var doc = new CarsCharacter("Doc", "Hudson");
+    System.out.println(hashFunction(doc));
+    System.out.println(indexFor(hashFunction(doc)));
+
+    var lightning = new CarsCharacter("Lightning", "McQueen");
+    System.out.println(hashFunction(lightning));
+    System.out.println(indexFor(hashFunction(lightning)));
+
+
+}
+```
+
+These are the drawers in our filing cabinet analogy.
+
diff --git a/src/hash_maps/filing_cabinets.md b/src/hash_maps/filing_cabinets.md
new file mode 100644
index 0000000..43f02c9
--- /dev/null
+++ b/src/hash_maps/filing_cabinets.md
@@ -0,0 +1,44 @@
+# Filing Cabinets
+
+The basic concept behind a Hash Map is the same concept as a filing cabinet.
+
+If you grew up in a doctor's office like I did this will make sense. If you didn't, Google
+what a filing cabinet looks like.
+
+Basically, if you have folders for a bunch of people you can separate them into different cabinets.
+
+You start by putting everyone in one cabinet. If you want to find someone's records, you look through
+everything in that cabinet until you find it.[^sorted]
+
+| Cabinet  |
+| -------- | 
+| Lightning McQueen  |
+| Tow Mater |
+| Doc Hudson |
+
+Once you have enough records you separate your folders by something like the patient's last name. So you would
+have your `A-M` and `N-Z` cabinets.
+
+| A-M  | N-Z |
+| -------- | |
+| Lightning McQueen  | Strip Weathers |
+| Tow Mater | |
+| Doc Hudson | |
+| Sally Carrera | |
+| Chick Hicks | |
+
+Then when you want to find someone, you can quicky pick the right cabinet by looking at their last name.
+
+If you got too many people in one cabinet you would then subdivide that cabinet further.
+
+| A-H    | A-M  | N-Z |
+| -------- | ---- |-- |
+| Doc Hudson | Lightning McQueen  | Strip Weathers |
+| Sally Carrera | Tow Mater | |
+| Chick Hicks | | |
+
+And this basic system can scale to thousands of names.
+
+
+
+[^sorted]: For a real filing cabinet system the contents of each cabinet would also be sorted. Ignore that for now.
\ No newline at end of file
diff --git a/src/hash_maps/function_range.md b/src/hash_maps/function_range.md
new file mode 100644
index 0000000..8d569d3
--- /dev/null
+++ b/src/hash_maps/function_range.md
@@ -0,0 +1,11 @@
+# Function Range
+
+Once you have a hash function, you need to determine its range.
+
+The range of a function is the set of values it might return.
+
+If you have a function that might return any `int` then the range will be
+all the values between `Integer.MIN_VALUE` and `Integer.MAX_VALUE`.
+
+If your hash function only returns a number between `0` and `5`, `0` - `5`
+is the range.
diff --git a/src/hash_maps/get_items.md b/src/hash_maps/get_items.md
new file mode 100644
index 0000000..82fdc4a
--- /dev/null
+++ b/src/hash_maps/get_items.md
@@ -0,0 +1,123 @@
+# Get Items
+
+Similarly to get an item from a map
+you need to do the following
+
+1. Compute the hash code of the item.
+2. Find the bucket that item should go in.
+3. Go through each item in the bucket to see if it matches.[^more]
+
+```java
+record CarsCharacter(
+    String firstName, 
+    String lastName
+) {}
+
+class Bucket {
+    private CarsCharacter[] data;
+    private int size;
+
+    Bucket() {
+        this.data = new CarsCharacter[0];
+        this.size = 0;
+    }
+
+    CarsCharacter get(int index) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        return this.data[index];
+    }
+
+    void set(int index, CarsCharacter value) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        this.data[index] = value;
+    }
+
+    int size() {
+        return this.size;
+    }
+
+    void add(CarsCharacter value) {
+        if (size >= this.data.length - 1) {
+            int newLength = this.data.length * 2;
+            if (newLength == 0) {
+                newLength = 2;
+            }
+
+            CarsCharacter[] newArray = new CarsCharacter[newLength];
+            for (int i = 0; i < this.data.length; i++) {
+                newArray[i] = this.data[i];
+            }
+            this.data = newArray;
+        }
+
+        this.data[size] = value;
+        this.size++;
+    }
+}
+
+
+
+class CarsCharacterHashMap {
+    Bucket[] buckets = new Bucket[] {
+        new Bucket(),
+        new Bucket(),
+        new Bucket()
+    };
+
+    int indexFor(char hash) {
+        if (hash >= 'A' && hash <= 'F') {
+            return 0;
+        }
+        else if (hash >= 'G' && hash <= 'N') {
+            return 1;
+        }
+        else {
+            return 2;
+        }
+    }
+
+    char hashFunction(
+        CarsCharacter carsCharacter
+    ) {
+        return carsCharacter.lastName().charAt(0);
+    }
+
+    void put(CarsCharacter character) {
+        // 1. Compute the hash code
+        char hash = hashFunction(character);
+        // 2. Find the bucket
+        Bucket bucket = buckets[indexFor(hash)];
+        // 3. Add to the bucket
+        bucket.add(character);
+    }
+
+    ` get(CarsCharacter character) {
+        // 1. Compute the hash code
+        char hash = hashFunction(character);
+        // 2. Find the bucket
+        Bucket bucket = buckets[indexFor(hash)];
+        // 3. Add to the bucket
+        bucket.add(character);
+    }
+}
+
+void main() {
+    var map = new CarsCharacterHashMap();
+
+    map.put(new CarsCharacter("Sally", "Carrera"));
+    map.put(new CarsCharacter("Doc", "Hudson"));
+    map.put(new CarsCharacter("Lightning", "McQueen"));
+
+    System.out.println(map.buckets[0].size());
+    System.out.println(map.buckets[1].size());
+    System.out.println(map.buckets[2].size());
+}
+```
+
+[^more]: There is more to say on how we determine if an item is a match, but
+we will cover that later. For now just assume calling `.equals` will
+make sense.
diff --git a/src/hash_maps/growable_buckets.md b/src/hash_maps/growable_buckets.md
new file mode 100644
index 0000000..5d33e82
--- /dev/null
+++ b/src/hash_maps/growable_buckets.md
@@ -0,0 +1,62 @@
+# Growable Buckets
+
+As you may have reasoned, a hash map's buckets
+will start out empty but later have elements added to them.
+
+This means that they will need to grow over time.
+
+One way to do this is with a growable array.
+
+```java
+class Bucket {
+    private CarsCharacter[] data;
+    private int size;
+
+    Bucket() {
+        this.data = new CarsCharacter[0];
+        this.size = 0;
+    }
+
+    CarsCharacter get(int index) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        return this.data[index];
+    }
+
+    void set(int index, CarsCharacter value) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        this.data[index] = value;
+    }
+
+    int size() {
+        return this.size;
+    }
+
+    void add(CarsCharacter value) {
+        if (size >= this.data.length - 1) {
+            int newLength = this.data.length * 2;
+            if (newLength == 0) {
+                newLength = 2;
+            }
+
+            CarsCharacter[] newArray = new CarsCharacter[newLength];
+            for (int i = 0; i < this.data.length; i++) {
+                newArray[i] = this.data[i];
+            }
+            this.data = newArray;
+        }
+
+        this.data[size] = value;
+        this.size++;
+    }
+}
+```
+
+Every detail of this is the same as the `GrowableIntArray` we made earlier,
+save the fact that it is called `Bucket` and instead of `int`s it holds
+`CarsCharacter`s.[^makenote]
+
+[^makenote]: Make note of this annoying similarity somewhere in your mind. It will come up later.
\ No newline at end of file
diff --git a/src/hash_maps/hash_collision.md b/src/hash_maps/hash_collision.md
new file mode 100644
index 0000000..001d98b
--- /dev/null
+++ b/src/hash_maps/hash_collision.md
@@ -0,0 +1,14 @@
+# Hash Collision
+
+It is possible for a hash function to give the same
+result for two distinct elements. 
+
+The first letter of both
+"Smith" and "Sanders" is "S", so if the hash function takes the first letter
+of the last name they will have the same hash.
+
+We call this situation a "hash collision." All it means is that these two objects
+will definitely go into the same bucket.
+
+That's allowed to happen, but if _everything_ goes into the same bucket then there
+isn't much point to using a hash map over a growable array.
\ No newline at end of file
diff --git a/src/hash_maps/hash_distribution.md b/src/hash_maps/hash_distribution.md
new file mode 100644
index 0000000..fed0d14
--- /dev/null
+++ b/src/hash_maps/hash_distribution.md
@@ -0,0 +1,13 @@
+# Hash Distribution
+
+When picking a hash function you also need to be worried
+about "hash distribution."
+
+If you open up a doctor's office in South Boston, you might have an issue
+ordering charts by last name only. Your `M` cabinet will be overflowing.[^irish]
+
+For that scenario, using the first letter of the last name is a non-ideal hash function
+because so when many people have last names starting with the same letter, they will
+not be evenly distributed amongst the buckets.
+
+[^irish]: "Mc" and "Mac" are common irish surnames and Boston has a sizable irish population.
\ No newline at end of file
diff --git a/src/hash_maps/hash_functions.md b/src/hash_maps/hash_functions.md
new file mode 100644
index 0000000..5eaa71e
--- /dev/null
+++ b/src/hash_maps/hash_functions.md
@@ -0,0 +1,31 @@
+# Hash Functions
+
+A hash function is something that takes a piece of data
+and extracts a smaller, but predictable, piece of data from it.
+
+```java
+record CarsCharacter(
+    String firstName, 
+    String lastName
+) {}
+
+char hashFunction(
+    CarsCharacter carsCharacter
+) {
+    return carsCharacter.lastName().charAt(0);
+}
+
+void main() {
+    var lightning = new CarsCharacter("Lightning", "McQueen");
+
+    char firstOfLast = hashFunction(lightning);
+    System.out.println(firstOfLast);
+}
+```
+
+Taking the first letter of a last name is an example of this. You can't
+reverse `M` into `McQueen`, but you can take `McQueen` and know to look
+in the bucket labeled `M`.
+
+We need hash functions to decide what "filing cabinet"
+a thing should go in.
\ No newline at end of file
diff --git a/src/hash_maps/keys_and_values.md b/src/hash_maps/keys_and_values.md
new file mode 100644
index 0000000..905120d
--- /dev/null
+++ b/src/hash_maps/keys_and_values.md
@@ -0,0 +1,12 @@
+# Keys and Values
+
+A Hash Map "maps" keys to values. 
+
+In the filing cabinet analogy we are mapping names to charts
+full of all sorts of other information on the person.
+
+For the rest of these examples assume we are trying to map
+`CarsCharacter`s to how many times they won the Piston Cup.[^watchcars]
+
+[^watchcars]: Cars was a delightful movie. Go to your local second hand store, get
+a copy on DVD, and make a night of it.
\ No newline at end of file
diff --git a/src/hash_maps/put_items.md b/src/hash_maps/put_items.md
new file mode 100644
index 0000000..0040610
--- /dev/null
+++ b/src/hash_maps/put_items.md
@@ -0,0 +1,113 @@
+# Put Items
+
+Putting it all together[^getit], we can "put"
+items into our hash map by following these steps.
+
+1. Compute the hash code of the key.
+2. Find the bucket that item should go in.
+3. Add the item to the bucket.
+
+```java
+record CarsCharacter(
+    String firstName, 
+    String lastName
+) {}
+
+class Bucket {
+    private CarsCharacter[] data;
+    private int size;
+
+    Bucket() {
+        this.data = new CarsCharacter[0];
+        this.size = 0;
+    }
+
+    CarsCharacter get(int index) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        return this.data[index];
+    }
+
+    void set(int index, CarsCharacter value) {
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        this.data[index] = value;
+    }
+
+    int size() {
+        return this.size;
+    }
+
+    void add(CarsCharacter value) {
+        if (size >= this.data.length - 1) {
+            int newLength = this.data.length * 2;
+            if (newLength == 0) {
+                newLength = 2;
+            }
+
+            CarsCharacter[] newArray = new CarsCharacter[newLength];
+            for (int i = 0; i < this.data.length; i++) {
+                newArray[i] = this.data[i];
+            }
+            this.data = newArray;
+        }
+
+        this.data[size] = value;
+        this.size++;
+    }
+}
+
+
+
+class CarsCharacterHashMap {
+    Bucket[] buckets = new Bucket[] {
+        new Bucket(),
+        new Bucket(),
+        new Bucket()
+    };
+
+    int indexFor(char hash) {
+        if (hash >= 'A' && hash <= 'F') {
+            return 0;
+        }
+        else if (hash >= 'G' && hash <= 'N') {
+            return 1;
+        }
+        else {
+            return 2;
+        }
+    }
+
+    char hashFunction(
+        CarsCharacter carsCharacter
+    ) {
+        return carsCharacter.lastName().charAt(0);
+    }
+
+    void put(CarsCharacter character) {
+        // 1. Compute the hash code
+        char hash = hashFunction(character);
+        // 2. Find the bucket
+        Bucket bucket = buckets[indexFor(hash)];
+        // 3. Add to the bucket
+        bucket.add(character);
+    }
+}
+
+void main() {
+    var map = new CarsCharacterHashMap();
+
+    map.put(new CarsCharacter("Sally", "Carrera"));
+    map.put(new CarsCharacter("Doc", "Hudson"));
+    map.put(new CarsCharacter("Lightning", "McQueen"));
+
+    System.out.println(map.buckets[0].size());
+    System.out.println(map.buckets[1].size());
+    System.out.println(map.buckets[2].size());
+}
+```
+
+
+[^getit]: ayy
\ No newline at end of file
diff --git a/src/hash_maps/redistribution.md b/src/hash_maps/redistribution.md
new file mode 100644
index 0000000..81463ec
--- /dev/null
+++ b/src/hash_maps/redistribution.md
@@ -0,0 +1 @@
+# Redistribution
diff --git a/src/img/duke_armcross.webp b/src/img/duke_armcross.webp
new file mode 100644
index 0000000..0401d35
Binary files /dev/null and b/src/img/duke_armcross.webp differ
diff --git a/src/img/duke_computer.webp b/src/img/duke_computer.webp
new file mode 100644
index 0000000..f3a11f7
Binary files /dev/null and b/src/img/duke_computer.webp differ
diff --git a/src/img/duke_finger.webp b/src/img/duke_finger.webp
new file mode 100644
index 0000000..4187329
Binary files /dev/null and b/src/img/duke_finger.webp differ
diff --git a/src/interfaces.md b/src/interfaces.md
new file mode 100644
index 0000000..89ce18f
--- /dev/null
+++ b/src/interfaces.md
@@ -0,0 +1 @@
+# Interfaces
diff --git a/src/loops_iii.md b/src/loops_iii.md
index 1cfccb6..7c57168 100644
--- a/src/loops_iii.md
+++ b/src/loops_iii.md
@@ -1 +1,36 @@
 # Loops III
+
+Counting indexes of elements is, while effective, a tad
+exhausting to do every time you want to loop through something.
+
+```java
+~void main() {
+String[] shirts = new String[] {
+    "T-Shirt",
+    "Polo Shirt",
+    "Dress Shirt"
+};
+
+for (int i = 0; i < shirts.length; i++) {
+    String shirt = shirts[i];
+
+    System.out.println(shirt);
+}
+~}
+```
+
+This is where "for-each" loops come in.
+
+```java
+~void main() {
+String[] shirts = new String[] {
+    "T-Shirt",
+    "Polo Shirt",
+    "Dress Shirt"
+};
+
+for (String shirt : shirts) {
+    System.out.println(shirt);
+}
+~}
+```
diff --git a/src/multi_dimensional_arrays.md b/src/multi_dimensional_arrays.md
new file mode 100644
index 0000000..2d2fe10
--- /dev/null
+++ b/src/multi_dimensional_arrays.md
@@ -0,0 +1 @@
+# Multi-Dimensional Arrays
diff --git a/src/objects.md b/src/objects.md
new file mode 100644
index 0000000..6f1ec49
--- /dev/null
+++ b/src/objects.md
@@ -0,0 +1,12 @@
+# Object
+
+You may have heard the phrase "everything is an object" 
+parroted about.
+
+It sounds very silly. Of course things are things, what else would they be?
+
+In Java it has a very specific meaning. There is a class named
+`java.lang.Object` (`Object` for short) which all other classes are
+derived from.
+
+Everything "is" an `Object`.
\ No newline at end of file
diff --git a/src/objects/array_subtypes.md b/src/objects/array_subtypes.md
new file mode 100644
index 0000000..642aaa1
--- /dev/null
+++ b/src/objects/array_subtypes.md
@@ -0,0 +1 @@
+# Array Subtypes
diff --git a/src/objects/equals_and_hashCode.md b/src/objects/equals_and_hashCode.md
new file mode 100644
index 0000000..7ca5cb0
--- /dev/null
+++ b/src/objects/equals_and_hashCode.md
@@ -0,0 +1,2 @@
+# equals and hashCode
+
diff --git a/src/objects/instanceof.md b/src/objects/instanceof.md
new file mode 100644
index 0000000..9a204cb
--- /dev/null
+++ b/src/objects/instanceof.md
@@ -0,0 +1,35 @@
+# instanceof
+
+If you have an `Object` you can recover the actual type
+of the data stored in it using `instanceof`.
+
+```java
+~void main() {
+Object o = "123";
+
+if (o instanceof String) {
+    System.out.println("This object is a String!");
+}
+~}
+```
+
+Inside an `if` you give the name of a field or variable
+whose type is `Object`. Then you write `instanceof`
+followed by the type you want to see if that object
+is an instance of.
+
+You can also give a variable name after the type.
+This will let you call methods from the actual type that are otherwise
+unavailable when all Java knows is that you have an `Object`.
+
+```java
+~void main() {
+Object o = "123";
+
+if (o instanceof String s) {
+    System.out.println(
+        "Can call String methods after recovering the type: " + s.charAt(0)
+    );
+}
+~}
+```
diff --git a/src/objects/override.md b/src/objects/override.md
new file mode 100644
index 0000000..d28e56e
--- /dev/null
+++ b/src/objects/override.md
@@ -0,0 +1,57 @@
+# @Override
+
+If you intend to override a method you should put
+`@Override` above that method.
+
+```java
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    @Override
+    public String toString() {
+        return "Position[x=" + x + ", y=" + y + "]";
+    }
+}
+
+void main() {
+    Object o = new Position(9, 8);
+    System.out.println(o);
+}
+```
+
+This doesn't change anything about how the program works,
+but it is a signal to Java that you intended to be overriding a method.
+If you get something wrong with the name, visibility, return type,
+or argument types of the method then putting `@Override` 
+means Java will warn you about those sorts of issues.
+
+```java,panics
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    // toString on Object doesn't take in an int
+    // but this would otherwise be allowed 
+    // since its technically a distinct method
+    @Override
+    public String toString(int value) {
+        return "Position[x=" + x + ", y=" + y + "]";
+    }
+}
+
+void main() {
+    Object o = new Position(9, 8);
+    System.out.println(o);
+}
+```
\ No newline at end of file
diff --git a/src/objects/override_equals_and_hashCode.md b/src/objects/override_equals_and_hashCode.md
new file mode 100644
index 0000000..ed22994
--- /dev/null
+++ b/src/objects/override_equals_and_hashCode.md
@@ -0,0 +1,2 @@
+# Override equals and hashCode
+
diff --git a/src/objects/override_toString.md b/src/objects/override_toString.md
new file mode 100644
index 0000000..7a16323
--- /dev/null
+++ b/src/objects/override_toString.md
@@ -0,0 +1,52 @@
+# Override toString
+
+To customize the behavior of `toString`
+in your own classes you need to "override"
+the `toString` method from `Object`.
+
+What this means is that you need to define a method
+which has the same name, arguments, return type, and visibility
+as the one defined in `Object`.
+
+That is, a `public` method named `toString` which takes no
+arguments and returns a `String`.
+
+```java
+class Window {
+    public String toString() {
+        return "Window!";
+    }
+}
+
+void main() {
+    Object o = new Window();
+    System.out.println(o);
+}
+```
+
+This is how you can customize the output of `System.out.println`.
+
+It is common practice for a class holding data to
+include the values of its fields in its `toString` representation.
+This can be very helpful for debugging.
+
+```java
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    public String toString() {
+        return "Position[x=" + x + ", y=" + y + "]";
+    }
+}
+
+void main() {
+    Object o = new Position(9, 8);
+    System.out.println(o);
+}
+```
\ No newline at end of file
diff --git a/src/objects/recover_types.md b/src/objects/recover_types.md
new file mode 100644
index 0000000..1e4a58d
--- /dev/null
+++ b/src/objects/recover_types.md
@@ -0,0 +1 @@
+# Recover Types
diff --git a/src/objects/subclasses.md b/src/objects/subclasses.md
new file mode 100644
index 0000000..2c6d9e6
--- /dev/null
+++ b/src/objects/subclasses.md
@@ -0,0 +1,4 @@
+# Subclasses
+
+In the same way that all types are sub-types of `Object`,
+all classes are sub-classes of `Object`.
\ No newline at end of file
diff --git a/src/objects/subtypes.md b/src/objects/subtypes.md
new file mode 100644
index 0000000..ef42e6b
--- /dev/null
+++ b/src/objects/subtypes.md
@@ -0,0 +1,21 @@
+# Subtypes
+
+We consider most everything to be a "subtype"
+of `Object`.
+
+This means that if you have a variable or field that holds an `Object`
+you can assign any data you want into it.
+
+```java
+~void main() {
+String oak = "oak";
+Object tree = oak;
+System.out.println(tree);
+~}
+```
+
+If something is a subtype of `Object`, we would call `Object`
+its "supertype."[^super]
+
+[^super]: Super meaning above and Sub meaning below. God how I feel for people who learn
+english as a second language.
\ No newline at end of file
diff --git a/src/objects/toString.md b/src/objects/toString.md
new file mode 100644
index 0000000..da0d526
--- /dev/null
+++ b/src/objects/toString.md
@@ -0,0 +1,31 @@
+# toString
+
+All `Object`s have a `toString` method. 
+
+This is intended to be a suitable representation for debugging,
+although one may choose to favor different concerns.
+
+For built-in classes the result of their `toString` method is likely
+what you'd expect.
+
+```java
+~class Apple {}
+~void main() {
+Object o = "123";
+
+// If its already a String, toString() doesn't
+// have to do much work
+System.out.println(o.toString());
+
+o = 123;
+// Integers, Longs, etc. all have a representation
+// which looks the same as they do in literal form.
+System.out.println(o.toString());
+
+o = new Apple();
+// And custom classes will, by default, just have the
+// class name followed by gibberish
+System.out.println(o.toString());
+~}
+```
+
diff --git a/src/objects/variance_and_casting.md b/src/objects/variance_and_casting.md
new file mode 100644
index 0000000..9b838ec
--- /dev/null
+++ b/src/objects/variance_and_casting.md
@@ -0,0 +1,5 @@
+# Variance and Casting
+
+While every `String` is an `Object`, not
+all `Object`s are `String`s.
+
diff --git a/src/recursion.md b/src/recursion.md
new file mode 100644
index 0000000..13763d7
--- /dev/null
+++ b/src/recursion.md
@@ -0,0 +1,37 @@
+# Recursion
+
+In a method you can call another method.
+
+```java
+void doOtherThing() {
+    System.out.println("B");
+}
+
+void doThing() {
+    System.out.println("A");
+}
+
+void main() {
+    doThing();
+}
+```
+
+This is at the foundation of most code so should, at this point,
+be a given.
+
+What might not be obvious is that you can call the method currently running.
+
+```java
+void countDown(int value) {
+    System.out.println(value);
+    if (value > 0) {
+        countDown(value - 1);
+    }
+}
+
+void main() {
+    countDown(10);
+}
+```
+
+This is what we call "recursion."
\ No newline at end of file
diff --git a/src/recursion/base_case.md b/src/recursion/base_case.md
new file mode 100644
index 0000000..0b2c4bd
--- /dev/null
+++ b/src/recursion/base_case.md
@@ -0,0 +1,20 @@
+# Base Case
+
+The general structure of a recursive method is that
+it will sometimes call itself and sometimes not.
+
+This makes sense if you think about it. If it always called
+itself, it would never stop calling itself and run forever.
+
+We call the case where the function will not call itself 
+a "base case"
+
+```java,no_run
+if (<SOMETHING>) {
+    <CALL SELF>
+}
+else {
+    // The base case
+    return <VALUE>;
+}
+```
\ No newline at end of file
diff --git a/src/recursion/base_cases.md b/src/recursion/base_cases.md
new file mode 100644
index 0000000..5e9d38f
--- /dev/null
+++ b/src/recursion/base_cases.md
@@ -0,0 +1 @@
+# Base Cases
diff --git a/src/recursion/comparison_to_delegation.md b/src/recursion/comparison_to_delegation.md
new file mode 100644
index 0000000..9ccd004
--- /dev/null
+++ b/src/recursion/comparison_to_delegation.md
@@ -0,0 +1,30 @@
+# Comparison to Delegation
+
+A related technique to recursion is "delegation."
+
+This is when you have one method call a different airity
+version of itself.
+
+```java
+// This method is delegated to
+void seasonFood(int shakes) {
+    for (int i = 0; i < shakes; i++) {
+        System.out.println("1 shake of pepper");
+    }
+}
+
+// by this method, which provides a "default" value of 2
+void seasonFood() {
+    seasonFood(2);
+}
+
+void main() {
+    seasonFood();
+}
+```
+
+This is distinct from recursion since, while the method delegated to
+might have the same name as the one delegating, different
+overloads of methods are considered distinct methods.
+
+`void seasonFood()` is therefore a different method than `void seasonFood(int)`.
\ No newline at end of file
diff --git a/src/recursion/comparison_to_loops.md b/src/recursion/comparison_to_loops.md
new file mode 100644
index 0000000..63f3c34
--- /dev/null
+++ b/src/recursion/comparison_to_loops.md
@@ -0,0 +1,42 @@
+# Comparison to Loops
+
+Everything that can be accomplished by using loops can be accomplished
+using recursion. This means it is always possible to take some
+code using loops and translate it mechanically to code using
+recursion.
+
+```java
+void seasonFoodRecursive(int times) {
+    if (times == 0) {
+        return;
+    }
+    else {
+        System.out.println("seasoning");
+        seasonFoodRecursive(times - 1);
+    }
+}
+
+void seasonFoodIterative(int times) {
+    for (int i = 0; i < times; i++) {
+        System.out.println("seasoning");
+    }
+}
+~
+~void main() {
+~    System.out.println("Recursive");
+~    seasonFoodRecursive(2);
+~    System.out.println("Iterative");
+~    seasonFoodRecursive(2);
+~}
+```
+
+Not everything that can be accomplished by using recursion can be accomplished
+using loops. At least without introducing some data structure to track what would
+otherwise be stored in Java's call stack. The following video goes a little further in depth
+as to why.
+
+<iframe width="560" height="315" src="https://www.youtube.com/embed/i7sm9dzFtEI?si=en1phfHlOSCkoV6r" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe>
+
+
+This is part of why its important to power through recursion. There are things
+that can only be solved with it and there are things that are more easily solved with it.
\ No newline at end of file
diff --git a/src/recursion/disclaimer.md b/src/recursion/disclaimer.md
new file mode 100644
index 0000000..451c890
--- /dev/null
+++ b/src/recursion/disclaimer.md
@@ -0,0 +1,12 @@
+# Disclaimer
+
+Recursion will be annoying to learn.
+
+Sorry.
+
+Its not because its particuarly hard or because its
+beyond your ken. Its just that when you learn loops first, recursion
+tends to be harder to learn than if you started with it.
+
+The good news is that once you get it, after however much
+mental anguish, you won't forget it. And it will be useful, however occasionally.
\ No newline at end of file
diff --git a/src/switch_iii.md b/src/switch_iii.md
new file mode 100644
index 0000000..80eca3f
--- /dev/null
+++ b/src/switch_iii.md
@@ -0,0 +1,31 @@
+# Switch III
+
+The switch statement in Java originally came from a little language you might know
+about called `C`.
+
+In `C` switches work slightly differently than the ones you have seen so far in Java.
+But, due to this history, there is another kind of switch that doesn't use arrows (`->`)
+and instead uses a colon (`:`).
+
+```java
+boolean shouldBeMainCharacter(String name) {
+    switch (name) {
+        case "Gohan":
+            return true;
+        case "Goku":
+        default:
+            return false;
+    }
+}
+void main() {
+    System.out.println(
+        shouldBeMainCharacter("Goku")
+    );
+}
+```
+
+This "C-Style Switch" is important to learn chiefly because, for a long time,
+it was the only switch in Java. Therefore in your coding life you are very likely to
+run into it when reading old code.
+
+It also might be uniquely useful for you once in a blue moon. Who knows.
\ No newline at end of file
diff --git a/src/switch_iii/break.md b/src/switch_iii/break.md
new file mode 100644
index 0000000..c95437e
--- /dev/null
+++ b/src/switch_iii/break.md
@@ -0,0 +1 @@
+# break
diff --git a/src/switch_iii/default.md b/src/switch_iii/default.md
new file mode 100644
index 0000000..36755d2
--- /dev/null
+++ b/src/switch_iii/default.md
@@ -0,0 +1 @@
+# default
diff --git a/src/switch_iii/fallthrough.md b/src/switch_iii/fallthrough.md
new file mode 100644
index 0000000..c3c2261
--- /dev/null
+++ b/src/switch_iii/fallthrough.md
@@ -0,0 +1,4 @@
+# Fallthrough
+
+If the code for a given label does not `break`
+or `return` then 
\ No newline at end of file
diff --git a/src/switch_iii/return.md b/src/switch_iii/return.md
new file mode 100644
index 0000000..bc7f48b
--- /dev/null
+++ b/src/switch_iii/return.md
@@ -0,0 +1 @@
+# return
diff --git a/src/switch_iii/yield.md b/src/switch_iii/yield.md
new file mode 100644
index 0000000..20c1740
--- /dev/null
+++ b/src/switch_iii/yield.md
@@ -0,0 +1 @@
+# yield
diff --git a/src/time.md b/src/time.md
new file mode 100644
index 0000000..814b6cc
--- /dev/null
+++ b/src/time.md
@@ -0,0 +1,8 @@
+# Time
+
+Wikipedia defines "time" as "The continued sequence of existence and events that occurs in an apparently irreversible succession from the past, through the present, and into the future."[^source]
+
+Most everything that interacts with the real world needs to understand information about time.
+As such, Java has various ways to work with data that holds information about time.
+
+[^source]: https://en.wikipedia.org/wiki/Time
\ No newline at end of file
diff --git a/src/time/date.md b/src/time/date.md
new file mode 100644
index 0000000..eef5ce9
--- /dev/null
+++ b/src/time/date.md
@@ -0,0 +1 @@
+# Date
diff --git a/src/time/duration.md b/src/time/duration.md
new file mode 100644
index 0000000..5e7d0b7
--- /dev/null
+++ b/src/time/duration.md
@@ -0,0 +1 @@
+# Duration
diff --git a/src/time/instant.md b/src/time/instant.md
new file mode 100644
index 0000000..96de49a
--- /dev/null
+++ b/src/time/instant.md
@@ -0,0 +1,4 @@
+# Instant
+
+A `java.time.Instant` stores information on a particular moment in time.
+
diff --git a/src/time/local_date.md b/src/time/local_date.md
new file mode 100644
index 0000000..5d9438a
--- /dev/null
+++ b/src/time/local_date.md
@@ -0,0 +1,30 @@
+# LocalDate
+
+A local date is something like "January 10th, 2024."
+
+This just records a day, month, and year. It doesn't know
+in what part of the world it was January 10th 2024, just
+that somewhere the "local" date was that.
+
+You can make a `LocalDate` with `LocalDate.of`.
+
+```java
+import java.time.LocalDate;
+
+void main() {
+    var jan10 = LocalDate.of(2024, 10, 1);
+    System.out.println(jan10);
+}
+```
+
+And you can get the current `LocalDate` in whatever timezone
+your computer is programmed to be in with `LocalDate.now();`
+
+```java
+import java.time.LocalDate;
+
+void main() {
+    var now = LocalDate.now();
+    System.out.println(now);
+}
+```
\ No newline at end of file
diff --git a/src/time/local_date_time.md b/src/time/local_date_time.md
new file mode 100644
index 0000000..5ae094f
--- /dev/null
+++ b/src/time/local_date_time.md
@@ -0,0 +1,20 @@
+# LocalDateTime
+
+What do you get if you combine a `LocalDate` and a `LocalTime`? A `LocalDateTime`!
+
+A `LocalDateTime` stores dates and times.
+
+If you have both a `LocalDate` and a `LocalTime` you can combine them
+with `LocalDateTime.of`.
+
+```java
+import java.time.LocalDate;
+import java.time.LocalTime;
+import java.time.LocalDateTime;
+
+void main() {
+    var jan10 = LocalDate.of(2024, 10, 1);
+    var tenTwentyFour = LocalTime.of(10, 24, 0);
+    System.out.println(LocalDateTime.of(jan10, tenTwentyFour));
+}
+```
\ No newline at end of file
diff --git a/src/time/local_time.md b/src/time/local_time.md
new file mode 100644
index 0000000..2b2d2e6
--- /dev/null
+++ b/src/time/local_time.md
@@ -0,0 +1,29 @@
+# LocalTime
+
+In the same way a local date leaves off context about where
+it was and what time it was, a local time just stores the time.
+
+This means it will hold the exact time during the day, down to the nanoseconds.
+
+You can make a `LocalTime` with `LocalTime.of` giving it the hours, minutes, and
+seconds into the day.
+
+```java
+import java.time.LocalTime;
+
+void main() {
+    var tenTwentyFour = LocalTime.of(10, 24, 0);
+    System.out.println(tenTwentyFour);
+}
+```
+
+And similarly you can get the current time your computer thinks it is with `LocalName.now()`
+
+```java
+import java.time.LocalTime;
+
+void main() {
+    var now = LocalTime.now();
+    System.out.println(now);
+}
+```
\ No newline at end of file
diff --git a/src/time/offset_date_time.md b/src/time/offset_date_time.md
new file mode 100644
index 0000000..b6afe8e
--- /dev/null
+++ b/src/time/offset_date_time.md
@@ -0,0 +1 @@
+# OffsetDateTime
diff --git a/src/time/zoned_date_time.md b/src/time/zoned_date_time.md
new file mode 100644
index 0000000..dd8f24f
--- /dev/null
+++ b/src/time/zoned_date_time.md
@@ -0,0 +1 @@
+# ZonedDateTime