diff --git a/README.md b/README.md
index 2bf6e44..aa98b90 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,6 @@
 # Modern Java
 
 [![codefactor](https://img.shields.io/codefactor/grade/github/together-java/modernjava)](https://www.codefactor.io/repository/github/together-java/modernjava)
-![Java](https://img.shields.io/badge/Java-19-ff696c)
 [![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.
diff --git a/book.toml b/book.toml
index 0666248..7c59f82 100644
--- a/book.toml
+++ b/book.toml
@@ -1,7 +1,7 @@
 [book]
 title = "Modern Java"
-description = " Book teaching how to write modern and effective Java. It is maintained by the community, anyone can contribute."
-authors = ["Together Java", "Contributions from the Java Community"]
+description = "Book teaching how to write modern and effective Java."
+authors = ["Ethan McCue", "Together Java", "Contributions from the Java Community"]
 language = "en"
 multilingual = false
 
@@ -21,5 +21,3 @@ editable = true
 
 [output.html.code.hidelines]
 java = "~"
-[output.html.code.hidelines]
-java = "~"
diff --git a/ferris.js b/ferris.js
index f78ce4a..5a7f1f6 100644
--- a/ferris.js
+++ b/ferris.js
@@ -53,8 +53,12 @@ function createFerris(type, size) {
   // a.setAttribute('href', 'ch00-00-introduction.html#ferris')
   a.setAttribute('target', '_blank')
 
+  var toFileName = function (t) {
+    return '../img/' + t.attr + '.svg';
+  }
+
   var img = document.createElement('img')
-  img.setAttribute('src', '../img/' + type.attr + '.svg')
+  img.setAttribute('src', toFileName(type))
   img.setAttribute('title', type.title)
   img.classList.add('ferris')
   img.classList.add('ferris-' + size)
diff --git a/src/SUMMARY.md b/src/SUMMARY.md
index 725b3cd..173903d 100644
--- a/src/SUMMARY.md
+++ b/src/SUMMARY.md
@@ -99,11 +99,9 @@
   - [If](./branching_logic/if.md)
   - [Nested Ifs](./branching_logic/nested_ifs.md)
   - [Else](./branching_logic/else.md)
-  - [Else](./branching_logic/else.md)
   - [Else If](./branching_logic/else_if.md)
   - [Relation to Delayed Assignment](./branching_logic/relation_to_delayed_assignment.md)
   - [Scoped Variables](./branching_logic/scoped_variables.md)
-  - [Scoped Variables](./branching_logic/scoped_variables.md)
   - [Conditional Operator](./branching_logic/conditional_operator.md)
   - [Boolean Expressions](./branching_logic/boolean_expressions.md)
   - [Challenges](./branching_logic/challenges.md)
@@ -209,7 +207,6 @@
   - [Boxing Conversion](./boxed_primitives/boxing_conversion.md)
   - [Arrays of Boxed Primitives](./boxed_primitives/arrays_of_boxed_primitives.md)
   - [Challenges](./boxed_primitives/challenges.md)
-  - [Challenges](./boxed_primitives/challenges.md)
 - [Arrays II](./arrays_ii.md)
   - [Initializion with Size](./arrays_ii/initialization_with_size.md)
   - [Default Values](./arrays_ii/default_values.md)
@@ -249,6 +246,13 @@
   - [Usage](./enums/usage.md)
   - [Equality](./enums/equality.md)
   - [Comparison to boolean](./enums/comparison_to_boolean.md)
+- [Strings II](./strings_ii.md)
+  - [lowercase](./strings_ii/lowercase.md)
+  - [UPPERCASE](./strings_ii/UPPERCASE.md)
+  - [Equality ignoring case](./strings_ii/equality_ignoring_case.md)
+  - [Check if empty](./strings_ii/check_if_empty.md)
+  - [Check if blank](./strings_ii/check_if_blank.md)
+  - [Strip extra whitespace](./strings_ii/strip_extra_whitespace.md)
 
 # Control Flow III
 
@@ -277,28 +281,302 @@
   - [Invariants](./constructors/invariants.md)
   - [Overloads](./constructors/overloads.md)
   - [Delegation](./constructors/delegation.md)
+- [Global Fields](./global_fields.md)
+  - [Default Values](./global_fields/default_values.md)
+  - [Final Fields](./global_fields/final_fields.md)
+  - [Field Access](./global_fields/field_access.md)
+  - [Inferred Types](./global_fields/inferred_types.md)
+
+# Concepts
+
+- [Code is Read more than Written](./code_is_read_more_than_written.md)
+  - [Meaning](./code_is_read_more_than_written/meaning.md)
+  - [Implications](./code_is_read_more_than_written/implications.md)
+  - [Information Density](./code_is_read_more_than_written/information_density.md)
+  - [Audience](./code_is_read_more_than_written/audience.md)
+  - [Practice](./code_is_read_more_than_written/practice.md)
+
+# Interactive Programs
+
+- [Standard Input](./standard_input.md)
+  - [Prompting](./standard_input/prompting.md)
+  - [Interpreting Input](./standard_input/interpreting_input.md)
+  - [Reprompting](./standard_input/reprompting.md)
+  - [Leniency](./standard_input/leniency.md)
+  - [Delayed Assignment](./standard_input/delayed_assignment.md)
+  - [Transporting Data](./standard_input/transporting_data.md)
+
+# The Computing Environment
+
+- [Hardware](./hardware.md)
+  - [CPU](./hardware/cpu.md)
+  - [RAM](./hardware/ram.md)
+  - [Hard Drives](./hardware/hard_drives.md)
+  - [Motherboard](./hardware/motherboard.md)
+- [Operating Systems](./operating_systems.md)
+  - [Personal Computers](./operating_systems/personal_computers.md)
+  - [Servers](./operating_systems/servers.md)
+  - [Mobile Phones](./operating_systems/mobile_phones.md)
+  - [Game Consoles](./operating_systems/game_consoles.md)
+  - [Abstractions](./operating_systems/abstractions.md)
+  - [Defaults](./operating_systems/defaults.md)
+- [The Terminal](./the_terminal.md)
+  - [Bash](./the_terminal/bash.md)
+  - [Windows Subsystem for Linux](./the_terminal/windows_subsystem_for_linux.md)
+  - [Chromebooks and School Computers](./the_terminal/chromebooks_and_school_computers.md)
+  - [Commands](./the_terminal/commands.md)
+  - [Directories](./the_terminal/directories.md)
+  - [Listing Files](./the_terminal/listing_files.md)
+  - [Creating Directories](./the_terminal/creating_directories.md)
+  - [Changing Directories](./the_terminal/changing_directories.md)
+  - [Creating Files](./the_terminal/creating_files.md)
+  - [Run Java Programs](./the_terminal/run_java_programs.md)
+  - [Getting Used to it](./the_terminal/getting_used_to_it.md)
 
 
+# Control Flow III
 
-<!--
+- [Exceptions II](./exceptions_ii.md)
+  - [Checked Exceptions](./exceptions_ii/checked_exceptions.md)
+  - [Unchecked Exceptions](./exceptions_ii/unchecked_exceptions.md)
+  - [throws](./exceptions_ii/throws.md)
+  - [Propagating Exceptions](./exceptions_ii/propagating_exceptions.md)
+  - [Rethrowing Exceptions](./exceptions_ii/rethrowing_exceptions.md)
+  - [Exception](./exceptions_ii/exception.md)
+  - [RuntimeException](./exceptions_ii/runtime_exception.md)
+  - [main](./exceptions_ii/main.md)
+- [Switch II](./switch_ii.md)
+  - [Yield](./switch_ii/yield.md)
+  - [Omitted Yield](./switch_ii/omitted_yield.md)
+  - [Exhaustiveness](./switch_ii/exhaustiveness.md)
+  - [Return a Switch](./switch_ii/return_a_switch.md)
+
+# Code Structure IV
+
+- [Multi-File Programs](./multi_file_programs.md)
+  - [The Sources folder](./multi_file_programs/the_sources_folder.md)
+  - [The Main file](./multi_file_programs/the_main_file.md)
+  - [A Second file](./multi_file_programs/a_second_file.md)
+  - [File names](./multi_file_programs/file_names.md)
+  - [The Anonymous Main Class](./multi_file_programs/the_anonymous_main_class.md)
+  - [Global Fields](./multi_file_programs/global_fields.md)
+- [Visibility](./visibility.md)
+  - [Private Methods](./visibility/private_methods.md)
+  - [Private Fields](./visibility/private_fields.md)
+  - [Invariants](./visibility/invariants.md)
+  - [Accessors](./visibility/accessors.md)
+  - [Getters and Setters](./visibility/getter_and_setters.md)
+- [Static Fields](./static_fields.md)
+  - [Declaration](./static_fields/declaration.md)
+  - [Initialization](./static_fields/initialization.md)
+  - [Usage](./static_fields/usage.md)
+  - [Constants](./static_fields/constants.md)
+  - [Controversy](./static_fields/controversy.md)
+  - [Naming](./static_fields/naming.md)
+- [Static Methods](./static_methods.md)
+  - [Declaration](./static_methods/declaration.md)
+  - [Scope](./static_methods/scope.md)
+  - [Naming](./static_methods/naming.md)
+  - [Usage](./static_methods/usage.md)
+  - [Math](./static_methods/math.md)
+  - [Factories](./static_methods/factories.md)
+
+# Data Structures & Algorithms
+
+- [Growable Arrays](./growable_arrays.md)
+  - [Concept](./growable_arrays/concept.md)
+  - [Simple Implementation](./growable_arrays/simple_implementation.md)
+  - [Usage](./growable_arrays/usage.md)
+  - [Performance Problems](./growable_arrays/performance_problems.md)
+  - [Performance Solutions](./growable_arrays/performance_solutions.md)
+  - [Optimized Implementation](./growable_arrays/optimized_implementation.md)
+
+# Interactive Programs II
+
+- [Command Line Arguments](./command_line_arguments.md)
+  - [Accessing Arguments](./command_line_arguments/accessing_arguments.md)
+  - [Conventions](./command_line_arguments/conventions.md)
+
+
+# Code Structure IV
+
+- [Inner Classes](./inner_classes.md)
+  - [Type](./inner_classes/type.md)
+  - [Instances](./inner_classes/instances.md)
+  - [New Operator](./inner_classes/new_operator.md)
+  - [Scope](./inner_classes/scope.md)
+  - [Disambiguation](./inner_classes/disambiguation.md)
+  - [The anonymous main class](./inner_classes/the_anonymous_main_class.md)
+  - [Static Inner Classes](./inner_classes/static_inner_classes.md)
+  - [Private Inner Classes](./inner_classes/private_inner_classes.md)
+- [Packages](./packages.md)
+  - [Declaration](./packages/declaration.md)
+  - [Visibility](./packages/visibility.md)
+  - [Public Classes](./packages/public_classes.md)
+  - [Fully Qualified Class Name](./packages/fully_qualified_class_name.md)
+  - [Import](./packages/import.md)
+  - [The Default Package](./packages/the_default_package.md)
+  - [The Anonymous Main Class](./packages/the_anonymous_main_class.md)
+  - [Public Methods](./packages/public_methods.md)
+  - [Package-Private Methods](./packages/package_private_methods.md)
+  - [Public Fields](./packages/public_fields.md)
+  - [Package-Private Fields](./packages/package_private_fields.md)
+  - [The Default Constructor](./packages/the_default_constructor.md)
+  - [Public Constructors](./packages/public_constructors.md)
+  - [Package-Private Constructors](./packages/package_private_constructors.md)
+  - [Subpackages](./packages/subpackages.md)
+  - [Reverse Domain Name Notation](./packages/reverse_domain_name_notation.md)
 
-- [Strings II](./strings_ii.md)
-  - [length]()
+# Data Types IV
+
+- [Records](./records.md)
+  - [Declaration](./records/declaration.md)
+  - [The Canonical Constructor](./records/the_canonical_constructor.md)
+  - [Component Accessors](./records/component_accessors.md)
+  - [Component Accessor Visibility](./records/component_accessor_visibility.md)
+  - [Printing a Record](./records/printing_a_record.md)
+  - [Check for Equality](./records/check_for_equality.md)
+  - [Return Multiple Values](./records/return_multiple_values.md)
+  - [Shorthand](./records/shorthand.md)
+
+- [Integers II](./integers_ii.md)
+  - [Integer from a String](./integers_ii/integer_from_a_string.md)
+  - [Integer to a String](./integers_ii/integer_to_a_string.md)
+  - [Base 16 Integer Literals](./integers_ii/base_16_integer_literals.md)
+  - [Integer from a Base 16 String](./integers_ii/integer_from_a_base_16_string.md)
+  - [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)
+
+# Interactive Programs III
+
+- [Files](./files.md)
+  - [Paths](./files/paths.md)
+  - [IOException](./files/ioexception.md)
+  - [UncheckedIOException](./files/uncheckedioexception.md)
+  - [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)
+
+# Data Structures & Algorithms II
+
+- [Hash Maps]()
+- [Hash Sets]()
+
+# Code Structure IV
+
+
+- [Interfaces]()
+  - [@Override]()
+- [Generics]()
+  - [Casting]()
+- [Object]()
+  - [instanceof]()
+  - [toString]()
   - [equals]()
-  - [charAt]()
-  - [equalsIgnoreCase]()
+  - [hashCode]()
+
+
+<!--
+
+
+
+# Data Types IV
+
+- [StringBuilder](./string_builder.md)
+- [Pattern]()
+
+
+# Concepts
+
+- [The Idiot Game](./the_idiot_game.md)
+
+# Interactive Programs
+
+
+# The Computing Environment
+
+
+
+
+
+# Interactive Programs
+
+
+- [Command Line Arguments]()
+
+# Code Structure IV
+
+
+- [Import]()
+- [Packages]()
+  - [Public]()
+  - [Package Private]()
   
-- [Multiple Source Files]()
-  - [Why]()
-  - [How]()
-  - [Restrictions]()
-- [The Main Class]()
-  - [The Implicit Main Class]()
 
+# Data Types V
+
+- [Strings III]()
+- [StringBuilder](./stringbuilder.md)
+- [Regular Expressions]()
+
+# Code Structure V
+
+- [toString]()
+- [Interfaces]()
+  - [@Override]()
+
+
+# Code Structure V
+
+- [Generics]()
+  - [Declaration]()
+  - [Safety]()
+  - [Unsafe Casts]()
+
+# Data Types VI
+
+- [Integers II]()
+- [Paths]()
+- [Iterator and Iterable]()
+- [Exceptions II]()
+- [Lists]()
+  - [ArrayList]()
+  - [Add an item]()
+  - [Get an item]()
+  - [Set an item]()
+  - [Loop over Contents]()
+
+# Control Flow IV
 
-- [Multiple Files]()
-- [The Implicit Main Class]()
-- [Private]()
+- [Loops III](./loops_iii.md)
+  - [For Each]()
+
+# Algorithms II
+
+- [Hash Map]()
+
+# Data Types VII
+
+- [Maps]()
+  - [HashMap]()
+- [Sets]()
+  - [HashSet]()
+
+# Interactive Programs II
+
+- [Files]()
+
+# Metaprogramming
+
+- [Reflection]()
+- [Annotations]() -->
+
+
+<!--
+
+  
 
 ## Data Types IV
 
@@ -308,7 +586,6 @@
   - [Documentation Comments]()
 - [Testing]()
 
-- [Example: "Growable" Array]()
 
 # User Defined Types
 
diff --git a/src/boxed_primitives/challenges.md b/src/boxed_primitives/challenges.md
index 9358534..ff0b882 100644
--- a/src/boxed_primitives/challenges.md
+++ b/src/boxed_primitives/challenges.md
@@ -1 +1,30 @@
 # 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
+
+
+## Challenge 1.
+
+Will this code run? Why or why not.
+
+```java
+int compute(int x) {
+    if (x == 0) {
+        return null;
+    }
+    else {
+        return x * x;
+    }
+}
+
+void main() {
+    System.out.println(compute(5));
+}
+```
+
+## Challenge 2.
+
diff --git a/src/branching_logic/challenges.md b/src/branching_logic/challenges.md
index aa102ec..56cb084 100644
--- a/src/branching_logic/challenges.md
+++ b/src/branching_logic/challenges.md
@@ -42,7 +42,7 @@ void main() {
 ## Challenge 4
 
 Write code that will assign the string `The number is {x} even` to `message` if `x` is an even number
-and `The number is {x} odd` if `x` is an even number.
+and `The number is {x} odd` if `x` is an odd number.
 
 So if `x` is 12 the string you should assign `The number 12 is even` to `message`.
 
diff --git a/src/classes/default_values.md b/src/classes/default_values.md
new file mode 100644
index 0000000..0541532
--- /dev/null
+++ b/src/classes/default_values.md
@@ -0,0 +1 @@
+# Default Values
diff --git a/src/code_is_read_more_than_written.md b/src/code_is_read_more_than_written.md
new file mode 100644
index 0000000..14fd731
--- /dev/null
+++ b/src/code_is_read_more_than_written.md
@@ -0,0 +1,9 @@
+# Code is Read more than Written
+
+Now that you more or less can write a full program, it won't be long
+before you write a program of "signficant size."
+
+This makes it a good time to start drip feeding some of the higher level
+concepts around software development.
+
+The first of these is a statement: Code is read more then it is written.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/audience.md b/src/code_is_read_more_than_written/audience.md
new file mode 100644
index 0000000..ffe3747
--- /dev/null
+++ b/src/code_is_read_more_than_written/audience.md
@@ -0,0 +1,20 @@
+# Audience
+
+Consider this opening from an astrophysics paper I picked at random.[^arxiv]
+
+> The dearth of planets with sizes around 1.8 R⊕ is a key demographic feature discovered by the Kepler mission. Two theories have emerged as potential explanations for this valley: photoevaporation and core-powered mass-loss. However, Rogers et al. (2021) shows that differentiating between the two theories is possible using the three-dimensional parameter space of planet radius, incident flux, and stellar mass.
+
+If you aren't an astrophysicist, this probably requires some explanation. If you are an astrophysicist, you 
+probably understood that without issue.
+
+Whenever anyone writes anything, it is important to consider the audience you are writing to. This applies to code just as much as to any other form of writing. 
+
+This is why shorthands like `for (int i = 0; i < length; i++)` are generally considered okay even though
+in most other situations `i` is pretty non-descript. Within the audience of programmers it is a known idiom.
+
+Its also why explaining every single line of code with comments is generally not okay. Programmers know what code
+is, you don't need to baby them through how loops work.[^offense]
+
+[^arxiv]: https://arxiv.org/abs/2302.00009
+
+[^offense]: No offense intended if you are still having trouble with loops. Its common, you will eventually get past it.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/implications.md b/src/code_is_read_more_than_written/implications.md
new file mode 100644
index 0000000..0abfb5f
--- /dev/null
+++ b/src/code_is_read_more_than_written/implications.md
@@ -0,0 +1,10 @@
+# Implications
+
+This means that, sometimes, it makes sense to write code in a way that
+is "harder" than is absolutely needed.
+
+That's a bit of a fuzzy statement, but on the more obvious side it means
+doing things like spending extra time on code formatting, variable naming,
+function contracts, writing comments, etc.
+
+All of those things make it easier to read that code later on.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/information_density.md b/src/code_is_read_more_than_written/information_density.md
new file mode 100644
index 0000000..b93722b
--- /dev/null
+++ b/src/code_is_read_more_than_written/information_density.md
@@ -0,0 +1,25 @@
+# Information Density
+
+An important related concept is information density.
+
+Yes, you can do things like add a comment on every line of code.
+This does mean that a later reader will have context on exactly what
+you were thinking as you were writing the code.[^literate]
+
+The downside is that there can be way more "extra" information than any
+educated person needs to understand the code. That extra information takes up space
+and spreads out the "important" information.
+
+Put another way, if something has a high information density it can be hard to read.
+
+> M.M.A.T.B.C
+
+Same as if it is has too low an information density.
+
+> Dearest sir, it would behoove you to meetest mineself posthaste after the school hours. I would perchance suggest that the location be betwixt the basketball courts.
+
+You want an information density that is "just right"
+
+> Meet me at the basketball court
+
+[^literate]: There is a whole sect of folks who write their programs as actual books. Look up "Literate Programming" to dive deeper in to that.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/meaning.md b/src/code_is_read_more_than_written/meaning.md
new file mode 100644
index 0000000..c18eeda
--- /dev/null
+++ b/src/code_is_read_more_than_written/meaning.md
@@ -0,0 +1,14 @@
+# Meaning
+
+While I'm sure there are some statistics behind this[^ormaybe], its generally accepted that
+the majority of a programmer's time is taken up reading existing code rather than writing new code.
+
+This should make sense intuitively. If you get hired at Microsoft, chances are you won't be given
+a blank slate to make a brand new thing. Often you will be thrust into existing codebases. To make a change
+to an existing codebase, you need to understand the exisiting code.
+
+It gets to the point where you might spend a whole day reading a dozen or so files only to make a 6 line change
+to one of them.
+
+
+[^ormaybe]: Software Development is still a relatively new field. Some things we take for granted may end up not being true after all. It doesn't help that its also pretty poorly researched. Keep an eye out for that.
\ No newline at end of file
diff --git a/src/code_is_read_more_than_written/practice.md b/src/code_is_read_more_than_written/practice.md
new file mode 100644
index 0000000..366da34
--- /dev/null
+++ b/src/code_is_read_more_than_written/practice.md
@@ -0,0 +1,16 @@
+# Practice
+
+If you want to do programming as your job or as part of your job,
+and you want to be competent, it isn't enough to just practice writing code.
+You also need to practice reading.
+
+There are a lot of ways to go about that, but an easy one is to
+read the code of your classmates or of strangers on the internet.
+
+Read their code, try to understand all the (maybe wacky!) choices they made
+while writing it, and try to change it up a little bit.
+
+This will help you get an intuitive sense for what you like in
+a codebase as well as what you do not. It will also, more so than
+the early struggles you go through when learning to write, help you
+understand if you would actually like to do this for work.
\ No newline at end of file
diff --git a/src/command_line_arguments.md b/src/command_line_arguments.md
new file mode 100644
index 0000000..ee0b604
--- /dev/null
+++ b/src/command_line_arguments.md
@@ -0,0 +1,16 @@
+# Command Line Arguments
+
+When you run a program like so
+
+```
+java src/Main.java
+```
+
+Anything you put to the right of `src/Main.java` will be available to your program as a
+"command line argument."[^name]
+
+```
+java src/Main.java example
+```
+
+[^name]: They come from the command line and they are arguments to your program.
\ No newline at end of file
diff --git a/src/command_line_arguments/accessing_arguments.md b/src/command_line_arguments/accessing_arguments.md
new file mode 100644
index 0000000..9a1c251
--- /dev/null
+++ b/src/command_line_arguments/accessing_arguments.md
@@ -0,0 +1,41 @@
+# Accessing Arguments
+
+To access the command line arguments given to your program you need to change your main method.
+
+Instead of 
+
+```java
+void main() {
+
+}
+```
+
+Have your main method take a string array as an argument.
+
+```java
+void main(String[] args) {
+
+}
+```
+
+This `String[]` will hold all the arguments passed.
+
+```
+java src/Main.java Duck Squirrel
+```
+
+```java
+~class Main {
+void main(String[] args) {
+    for (int i = 0; i < args.length; i++) {
+        System.out.println(
+            "Hello Mr. " + args[i]
+        );
+    }
+}
+~}
+~// This is a little ugly
+~void main() {
+~    new Main().main(new String[] { "Duck", "Squirrel" });   
+~}
+```
diff --git a/src/command_line_arguments/conventions.md b/src/command_line_arguments/conventions.md
new file mode 100644
index 0000000..fc919e3
--- /dev/null
+++ b/src/command_line_arguments/conventions.md
@@ -0,0 +1,17 @@
+# Conventions
+
+As it is just a `String[]`, you can interpret the arguments passed to your
+program in any way you choose.
+
+What you will notice, however, from using other tools in your terminal
+is that there are a few socially accepted conventions.
+
+If your tool takes "options" then you would expect `--option-name VALUE` to
+be how you specify it. So two dashes followed by the argument name.
+
+If you need a shorter version then you allow for one dash and sometimes a single
+letter value `-d VALUE`.
+
+And most importantly, if someone types `--help` you should give them the
+available options. Try `java --help` for an example.
+
diff --git a/src/constr b/src/constr
deleted file mode 100644
index a902009..0000000
--- a/src/constr
+++ /dev/null
@@ -1 +0,0 @@
-# Declaration
diff --git a/src/ex b/src/ex
deleted file mode 100644
index f0aebb4..0000000
--- a/src/ex
+++ /dev/null
@@ -1 +0,0 @@
-# Exception Messages
diff --git a/src/exceptions_ii.md b/src/exceptions_ii.md
new file mode 100644
index 0000000..60e3ae0
--- /dev/null
+++ b/src/exceptions_ii.md
@@ -0,0 +1,7 @@
+# Exceptions II
+
+Perhaps unsurprisingly, `RuntimeException` is not the only kind of exception
+that can be thrown.
+
+There is a huge variety of exception types out there, but the most important thing to understand is the distinction between checked and unchecked
+exceptions.
\ No newline at end of file
diff --git a/src/exceptions_ii/checked_exceptions.md b/src/exceptions_ii/checked_exceptions.md
new file mode 100644
index 0000000..4d8ff2e
--- /dev/null
+++ b/src/exceptions_ii/checked_exceptions.md
@@ -0,0 +1,24 @@
+# Checked Exceptions
+
+When a part of your code might throw a "checked" exception, other
+parts of your code need to account for that possibility.
+
+```java,does_not_compile
+int divide(int x, int y) {
+    if (y == 0) {
+        // Will not work because nothing handles the exception
+        throw new Exception();
+    }
+
+    return x / y;
+}
+~void main() {
+~    
+~}
+```
+
+We call them "checked" because you need to "check" for them.
+
+These are _generally_[^thisrule] used when you expect calling code to be able to do something intelligent to recover if the exception is thrown.
+
+[^thisrule]: This rule is merely a suggestion and people's definitions of "something intelligent" and "recover" vary wildly. Expect some things to throw checked exceptions and others to not and just know that you need to check for the checked ones.
diff --git a/src/exceptions_ii/exception.md b/src/exceptions_ii/exception.md
new file mode 100644
index 0000000..a33829e
--- /dev/null
+++ b/src/exceptions_ii/exception.md
@@ -0,0 +1,13 @@
+# Exception
+
+The most vanilla[^vanillacopypasta] checked exception is `Exception`.
+
+If you want a checked exception and do not know of a better one, `Exception` will do.
+
+```java,panics
+void main() throws Exception {
+    throw new Exception("Crash!");
+}
+```
+
+[^vanillacopypasta]: <i>people have the audacity to equate vanilla with “plain”. the fruit of a delicate orchid pollinated by hand. worth its weight in solid gold and beyond. the fussy black-and-cream jewel of the american continent. you sick son of a bitch. imagine a world without vanilla. no blondies. no pound cakes. no crème brûlée, no coke floats. no cream soda. no satiny new york-style cheesecakes. no warm apple pie à la mode. no velvety complexity to bring out complex notes in chocolate desserts. no depth of flavour in your cakes and cookies and milkshakes. all in just a few precious seeds or grams of paste or perfumed teaspoons of liquid black platinum. what you don’t understand could fill the library of alexandria seven times over and then some. you ungrateful bastard i’m going to kill you</i> - [Tumblr user "kirbyofthestars"](https://www.tumblr.com/peaceoutofthepieces/684810307611377664)
\ No newline at end of file
diff --git a/src/exceptions_ii/main.md b/src/exceptions_ii/main.md
new file mode 100644
index 0000000..e9091ff
--- /dev/null
+++ b/src/exceptions_ii/main.md
@@ -0,0 +1,12 @@
+# main
+
+The `main` method can be declared to throw any kind of checked exception.
+
+It is assumed that if an exception makes it all the way there that the way to handle it is crash
+the program.
+
+```java,panics
+void main() throws Exception {
+    throw new Exception("crash");
+}
+```
\ No newline at end of file
diff --git a/src/exceptions_ii/propagating_exceptions.md b/src/exceptions_ii/propagating_exceptions.md
new file mode 100644
index 0000000..0a90bba
--- /dev/null
+++ b/src/exceptions_ii/propagating_exceptions.md
@@ -0,0 +1,36 @@
+# Propagating Exceptions
+
+Say we started out with code like this.
+
+```java
+void dream() {
+    System.out.println("Shin Godzilla's Jaw unhinging like a snake...")
+}
+
+void sleep() {
+    dream();
+}
+
+void main() {
+    sleep();
+}
+```
+
+If a function is declared to throw an exception, that exception will have to "propagate" - meaning spread - to all calling functions.
+
+```java
+void dream() throws Exception {
+    throw new Exception("Something went wrong")
+}
+
+void sleep() throws Exception {
+    dream();
+}
+
+void main() throws Exception {
+    sleep();
+}
+```
+
+`dream` declares that it might throw `Exception` so `sleep` must declare that it might throw `Exception`. Because `sleep` might throw `Exception` now `main` might throw `Exception`.
+
diff --git a/src/exceptions_ii/rethrowing_exceptions.md b/src/exceptions_ii/rethrowing_exceptions.md
new file mode 100644
index 0000000..63089f2
--- /dev/null
+++ b/src/exceptions_ii/rethrowing_exceptions.md
@@ -0,0 +1,47 @@
+# Rethrowing Exceptions
+
+When you catch an exception you have the option of again throwing an exception.
+
+This is useful if you want to have behavior that occurs when something goes wrong but still
+ultimately throw an exception for the rest of the code to deal with.[^examples]
+
+```java,no_run
+void dream() throws Exception {
+    throw new Exception("Oh no");
+}
+
+void sleep() throws Exception {
+    try {
+        dream();
+    }
+    catch (Exception e) {
+        System.out.println("Something went wrong while dreaming");
+        throw e;
+    }
+}
+```
+
+It is also an opportunity to "wrap" checked exceptions into unchecked ones.
+
+```java
+void dream() throws Exception {
+    throw new Exception("Oh no");
+}
+
+void sleep() {
+    try {
+        dream();
+    }
+    catch (Exception e) {
+        throw new RuntimeException(e);
+    }
+}
+
+void main() {
+    sleep();
+}
+```
+
+Which seems crazy, but remember that "the point" of a checked exception is to have the calling code make a choice about how to handle an error condition. If you are okay with just crashing, throwing an unchecked exception is a perfectly valid choice.
+
+[^examples]: These examples are all silly, I know. Once we get to files the mechanics will become useful.
\ No newline at end of file
diff --git a/src/exceptions_ii/runtime_exception.md b/src/exceptions_ii/runtime_exception.md
new file mode 100644
index 0000000..bc10f41
--- /dev/null
+++ b/src/exceptions_ii/runtime_exception.md
@@ -0,0 +1 @@
+# RuntimeException
diff --git a/src/exceptions_ii/throws.md b/src/exceptions_ii/throws.md
new file mode 100644
index 0000000..1cd2716
--- /dev/null
+++ b/src/exceptions_ii/throws.md
@@ -0,0 +1,57 @@
+# throws
+
+One way to handle a checked exception is to add a `throws` to the end
+of your method declaration.
+
+```java
+int divide(int x, int y) throws Exception {
+    if (y == 0) {
+        throw new Exception();
+    }
+
+    return x / y;
+}
+
+~void main() {
+~    
+~}
+```
+
+This will make it so that calling code needs to check for the possibility of that 
+exception being thrown.
+
+```java,does_not_compile
+int divide(int x, int y) throws Exception {
+    if (y == 0) {
+        throw new Exception();
+    }
+
+    return x / y;
+}
+
+void doStuff() {
+    divide(1, 0);
+}
+
+~void main() {
+~    
+~}
+```
+
+You can also declare unchecked exceptions using `throws` but you are never required to.[^doc]
+ 
+```java
+int divide(int x, int y) throws RuntimeException {
+    if (y == 0) {
+        throw new RuntimeException();
+    }
+
+    return x / y;
+}
+
+~void main() {
+~    
+~}
+```
+
+[^doc]: This is one of many things that you might choose to do for the benefit of a human reader that isn't strictly needed for correct Java.
\ No newline at end of file
diff --git a/src/exceptions_ii/unchecked_exceptions.md b/src/exceptions_ii/unchecked_exceptions.md
new file mode 100644
index 0000000..d2c6422
--- /dev/null
+++ b/src/exceptions_ii/unchecked_exceptions.md
@@ -0,0 +1,21 @@
+# Unchecked Exceptions
+
+When a part of your code might throw a "unchecked" exception, other
+parts of your code do not need to account for that possibility.
+
+```java
+int divide(int x, int y) {
+    if (y == 0) {
+        // Will work because you are not forced to handle
+        // an unchecked exception
+        throw new RuntimeException();
+    }
+
+    return x / y;
+}
+~void main() {
+~    
+~}
+```
+
+We call them unchecked because you don't need to check for them.
\ No newline at end of file
diff --git a/src/files.md b/src/files.md
new file mode 100644
index 0000000..b087e37
--- /dev/null
+++ b/src/files.md
@@ -0,0 +1,9 @@
+# Files
+
+Files are how you store information
+on a[^normal] computer so that it can still be there when your program
+is done running.
+
+As such, read files and writing files are tasks you will often want to do.
+
+[^normal]: *normal
\ No newline at end of file
diff --git a/src/files/creating_a_folder.md b/src/files/creating_a_folder.md
new file mode 100644
index 0000000..8840e6f
--- /dev/null
+++ b/src/files/creating_a_folder.md
@@ -0,0 +1 @@
+# Creating a Folder
diff --git a/src/files/ioexception.md b/src/files/ioexception.md
new file mode 100644
index 0000000..e96e72f
--- /dev/null
+++ b/src/files/ioexception.md
@@ -0,0 +1,17 @@
+# IOException
+
+If some code is "doing IO" - by which we mean while it is trying to read some <b>I</b>nput or write some <b>O</b>utput - you should expect it to throw an `IOException`.
+
+This class lives in the `java.io` package so to use it by its simple name you need an import.
+
+```java
+import java.io.IOException;
+
+class Main {
+    void main() throws IOException {
+        throw new IOException("Something went wrong");
+    }
+}
+```
+
+Since reading a file is reading some input and writing to a file is writing some output, this exception is relevant to reading and writing files.
\ No newline at end of file
diff --git a/src/files/paths.md b/src/files/paths.md
new file mode 100644
index 0000000..d0970b6
--- /dev/null
+++ b/src/files/paths.md
@@ -0,0 +1,22 @@
+# Paths
+
+All files and folders on your computer can be located by a "path"
+like "`Downloads/movie.mp4`."
+
+To store a path in a Java program we use the `Path` class from the `java.nio.file`[^nio]
+package. You create these `Path`s by giving a `String` to the `Path.of`
+static method.
+
+```java
+import java.nio.file.Path;
+
+class Main {
+    void main() {
+        Path pathToNotes = Path.of("notes.txt");
+
+        System.out.println(pathToNotes);
+    }
+}
+```
+
+[^nio]: `nio` stands for "new IO." So yes, there was an old IO. We will use that too. Its one of many artifacts from Java's interesting and sordid history. 
\ No newline at end of file
diff --git a/src/files/read_from_a_file.md b/src/files/read_from_a_file.md
new file mode 100644
index 0000000..fe17cbc
--- /dev/null
+++ b/src/files/read_from_a_file.md
@@ -0,0 +1,58 @@
+# Read from a File
+
+To read a file's contents as a `String` you can use the `readString` static method
+from `java.nio.file.Files`.
+
+```java
+Path tasksPath = Path.of("tasks.txt");
+String tasks = Files.readString(tasksPath);
+```
+
+Similarly to `Files.writeString`, this can throw an `IOException` if
+something goes wrong[^filenotfound].
+
+This can be dealt with in the same way. Either declare the `IOException` in a `throws`
+clause or re-throw an unchecked exception.
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+    void main() throws IOExeption {
+        Path tasksPath = Path.of("tasks.txt");
+        String tasks = Files.readString(tasksPath);
+
+        System.out.println(tasks);
+    }
+}
+```
+
+If you choose to re-throw any `IOException` as an unchecked exception then
+it might be helpful to remember that delayed assignment is allowed in that context.[^mostly]
+
+```java
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+    void main() {
+        Path tasksPath = Path.of("tasks.txt");
+
+        String tasks;
+        try {
+            tasks = Files.readString(tasksPath);
+        }
+        catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+
+        System.out.println(tasks);
+    }
+}
+```
+
+[^filenotfound]: Usually we can hand-wave this as "when something goes wrong it throws `IOException`," but this is one of those cases where you might care about what exactly went wrong. Specifically, whether the reason you couldn't read a file because the file wasn't there. We'll use this method as an example when we go deeper into Exceptions
+so there will be a chance to talk about that.
+
+[^mostly]: Mostly just because it can let you "shrink the scope" of the try-catch.
\ No newline at end of file
diff --git a/src/files/uncheckedioexception.md b/src/files/uncheckedioexception.md
new file mode 100644
index 0000000..0a6407e
--- /dev/null
+++ b/src/files/uncheckedioexception.md
@@ -0,0 +1,26 @@
+# UncheckedIOException
+
+The unchecked version of an `java.io.IOException` is `UncheckedIOException`.
+
+You can use this if you have a method which you don't want to propagate `IOException` but
+also want something more specific than `RuntimeException` to re-throw.
+
+
+And just like `IOException`, if you don't want to write 
+out `java.io.UncheckedIOException` more than once you need to add an import.
+
+```java,no_run
+import java.io.IOException;
+import java.io.UncheckedIOException;
+
+class Main {
+    void main() {
+        try {
+            doStuff();
+        }
+        catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+    }
+}
+```
diff --git a/src/files/write_to_a_file.md b/src/files/write_to_a_file.md
new file mode 100644
index 0000000..9f35a27
--- /dev/null
+++ b/src/files/write_to_a_file.md
@@ -0,0 +1,58 @@
+# Write to a File
+
+To write a `String` to a file you can use the `Files` class from the `java.nio.file`
+package. It has a static method named `writeString`.
+
+```java,no_run
+Path tasksPath = Path.of("tasks.txt");
+String tasks = """
+    1. Do dishes
+    2. Do laundry
+    """;
+
+Files.writeString(tasksPath, tasks);
+```
+
+This method can throw an `IOException`, so to handle that you
+can have a `throws` declaration on the method calling it.
+
+```java,no_run
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+    void main() throws IOException {
+        Path tasksPath = Path.of("tasks.txt");
+        String tasks = """
+            1. Do dishes
+            2. Do laundry
+            """;
+
+        Files.writeString(tasksPath, tasks);
+    }
+}
+```
+
+The other option is to catch the `IOException` and re-throw it as an unchecked exception.
+
+```java,no_run
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+class Main {
+    void main() {
+        Path tasksPath = Path.of("tasks.txt");
+        String tasks = """
+            1. Do dishes
+            2. Do laundry
+            """;
+
+        try {
+            Files.writeString(tasksPath, tasks);
+        }
+        catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }    
+    }
+}
+```
\ No newline at end of file
diff --git a/src/floating_point_numbers_ii.md b/src/floating_point_numbers_ii.md
new file mode 100644
index 0000000..57ad3ca
--- /dev/null
+++ b/src/floating_point_numbers_ii.md
@@ -0,0 +1 @@
+# Floating Point Numbers II
diff --git a/src/global_fields.md b/src/global_fields.md
new file mode 100644
index 0000000..dbf4718
--- /dev/null
+++ b/src/global_fields.md
@@ -0,0 +1,20 @@
+# Global Fields
+
+You can make field declarations outside of a class.
+This makes these fields "global" to the program.
+
+We call things global when they are available at every point
+in the "world" of our program.[^wonthold]
+
+```java
+int number = 0;
+
+void main() {
+    System.out.println(number);
+    number++;
+    System.out.println(number);
+}
+```
+
+[^wonthold]: This explanation is I think a correct description of what it means
+to be global, but what I am showing won't really hold up as a global thing the more you learn.
\ No newline at end of file
diff --git a/src/global_fields/default_values.md b/src/global_fields/default_values.md
new file mode 100644
index 0000000..c4beb57
--- /dev/null
+++ b/src/global_fields/default_values.md
@@ -0,0 +1,14 @@
+# Default Values
+
+Just like regular fields in classes, global fields will initialize to their default
+value unless explicitly initialized.
+
+```java
+int x;
+int y = 5;
+
+void main() {
+    System.out.println(x);
+    System.out.println(y);
+}
+```
diff --git a/src/global_fields/field_access.md b/src/global_fields/field_access.md
new file mode 100644
index 0000000..581ed17
--- /dev/null
+++ b/src/global_fields/field_access.md
@@ -0,0 +1,25 @@
+# Field Access
+
+
+You can access global fields by writing their name. This works from within
+top level methods as well as instance methods of classes.[^different]
+
+```java
+final String monster = "Dracula";
+
+class Mash {
+    void itWasThe() {
+        System.out.println(monster + " and his son");
+    }
+}
+
+void main() {
+    System.out.println(monster + " was there");
+
+    Mash mash = new Mash();
+    mash.itWasThe();
+}
+```
+
+[^different]: This is so convenient it is actually going to be a bummer once you learn what is going on here
+and can't do it for most of your programs anymore.
\ No newline at end of file
diff --git a/src/global_fields/final_fields.md b/src/global_fields/final_fields.md
new file mode 100644
index 0000000..a7d398d
--- /dev/null
+++ b/src/global_fields/final_fields.md
@@ -0,0 +1,14 @@
+# Final Fields
+
+And just like regular final fields, you always need to give an initial value to
+global final fields.
+
+```java
+final int x = 0;
+
+void main() {
+    System.out.println(x);
+}
+```
+
+Final fields of course cannot be changed.
\ No newline at end of file
diff --git a/src/global_fields/inferred_types.md b/src/global_fields/inferred_types.md
new file mode 100644
index 0000000..5f8a2f1
--- /dev/null
+++ b/src/global_fields/inferred_types.md
@@ -0,0 +1,12 @@
+# Inferred Types
+
+Just like other field declarations, `var` cannot be used 
+for inferring the type of a global field. You need to explicitly write out the type.
+
+```java,does_not_compile
+var x = 5;
+
+void main() {
+    System.out.println(x);
+}
+```
\ No newline at end of file
diff --git a/src/growable_arrays.md b/src/growable_arrays.md
new file mode 100644
index 0000000..6f63844
--- /dev/null
+++ b/src/growable_arrays.md
@@ -0,0 +1,15 @@
+# Growable Arrays
+
+Arrays are fixed size collections of elements. This means when we make an array
+that is 5 elements big it will always be 5 elements big.
+
+```java
+~void main() {
+int[] numbers = new int[5];
+~}
+```
+
+Something that turns out to be extremely useful is to have something with most of the properties of an array - such as being able quickly get and set arbitrary elements by index - but that can grow over time.
+
+The rest of this section I will walk you through how we can accomplish that.
+
diff --git a/src/growable_arrays/concept.md b/src/growable_arrays/concept.md
new file mode 100644
index 0000000..03dd732
--- /dev/null
+++ b/src/growable_arrays/concept.md
@@ -0,0 +1,10 @@
+# Concept
+
+The concept behind a growable array is that we
+store an array as a field and use it for operations like getting
+and setting elements.
+
+The extra wrinkle is that when someone wants to "add" an element
+we make a new, bigger, array and copy all the existing elements to it.
+Then we put the element you wanted to add at the end.
+
diff --git a/src/growable_arrays/optimized_implementation.md b/src/growable_arrays/optimized_implementation.md
new file mode 100644
index 0000000..38ce10d
--- /dev/null
+++ b/src/growable_arrays/optimized_implementation.md
@@ -0,0 +1,65 @@
+# Optimized Implementation
+
+So with that context we can update the simple implementation as follows.
+
+Note the use of `IndexOutOfBoundsException`. It is an unchecked exception that
+comes with Java specifically for when an index is out of bounds.[^obvious]
+
+```java
+class GrowableIntArray {
+    private int[] data;
+    // We need a different variable to store the size
+    // since the array's size will different than we want.
+    private int size;
+
+    GrowableIntArray() {
+        this.data = new int[0];
+        this.size = 0;
+    }
+
+    int get(int index) {
+        // Now that we manage the size, we need to do
+        // "bounds checks" ourselves
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        return this.data[index];
+    }
+
+    void set(int index, int value) {
+        // For setting as well
+        if (index >= size) {
+            throw new IndexOutOfBoundsException(index);
+        }
+        this.data[index] = value;
+    }
+
+    int size() {
+        // We use the size we store rather than the length of the array
+        return this.size;
+    }
+
+    void add(int value) {
+        // if we won't have enough room in the array, make a new one.
+        if (size >= this.data.length - 1) {
+            // Overallocate by 2x
+            int newLength = this.data.length * 2;
+            if (newLength == 0) {
+                newLength = 2; // Unfortunately 0 * 2 is 0, so account for that
+            }
+
+            int[] newArray = new int[newLength];
+            for (int i = 0; i < this.data.length; i++) {
+                newArray[i] = this.data[i];
+            }
+            this.data = newArray; 
+        }
+
+        // And at this point we know the array is big enough
+        this.data[size] = value;
+        this.size++;
+    }
+}
+```
+
+[^obvious]: I love obvious and circular statements like this, if you haven't noticed.
\ No newline at end of file
diff --git a/src/growable_arrays/performance_problems.md b/src/growable_arrays/performance_problems.md
new file mode 100644
index 0000000..bf3f5b1
--- /dev/null
+++ b/src/growable_arrays/performance_problems.md
@@ -0,0 +1,73 @@
+# Performance Problems
+
+While the code as is _works_, it will not perform well.
+
+Since we copy the underlying array every time someone adds a new element it can be expensive to add a lot of elements.
+
+Pretend we were going to add a hundred elements to the growable array.
+
+```java
+~class GrowableIntArray {
+~    // Store an int[] internally
+~    private int[] data;
+~
+~    GrowableIntArray() {
+~        // Make sure to initialize it correctly
+~        this.data = new int[0];
+~    }
+~
+~    // When someone wants to get an item, get it from the array
+~    int get(int index) {
+~        return this.data[index];
+~    }
+~
+~    // Same deal when someone wants to set an item at an index.
+~    void set(int index, int value) {
+~        this.data[index] = value;
+~    }
+~
+~    // And we need an accessor for the size so that someone
+~    // can loop over the array.
+~    int size() {
+~        return this.data.length;
+~    }
+~
+~    void add(int value) {
+~        // Copy the old array to a new, bigger one
+~        int[] newArray = new int[this.data.length + 1];
+~        for (int i = 0; i < this.data.length; i++) {
+~            newArray[i] = this.data[i];
+~        }
+~
+~        // Then put the new element at the end
+~        newArray[newArray.length - 1] = value;
+~
+~        // And swap the array
+~        this.data = newArray; 
+~    }
+~}
+~
+~
+class Main {
+    void main() {
+        var array = new GrowableIntArray();
+
+        for (int i = 0; i < 100; i++) {
+            array.add(i);
+        }
+
+        System.out.println(array.size());
+    }
+}
+```
+
+For the each element we need to make a copy of an array. So when we add the first element we need to make an array 1 element big. The second, copy that 1 element array and make a new
+2 element one.
+
+So if you do napkin math on the things that need to happen you get this
+
+```
+1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 + 10 + 11 + 12 ...
+```
+
+Which is just a crazy number of copies. It means calling `.add` on an already big list will be slow and calling `.add` a lot of times to make a big list will be very slow.
\ No newline at end of file
diff --git a/src/growable_arrays/performance_solutions.md b/src/growable_arrays/performance_solutions.md
new file mode 100644
index 0000000..cf1ef3e
--- /dev/null
+++ b/src/growable_arrays/performance_solutions.md
@@ -0,0 +1,14 @@
+# Performance Solutions
+
+If the problem with the simple implementation is that we make too many copies,
+the solution is to make fewer copies.
+
+The easiest way to do this is to "over-allocate." Make our internal array bigger than
+we actually need it to be. That way most of the time when you call `.add` it will be
+fast.
+
+We can't - or at least shouldn't - over allocate right away. If every growable array secretly has enough room for millions of elements that would be silly. Better to over-allocate as we go.
+
+Exactly how much we should make the internal array bigger than we need is more art than science. People have found that doubling the size each time is a pretty good tradeoff[^important].
+
+[^important]: This data structure is crazy important. Maybe the most common one used in the world. Java has it built-in and we'll get to that later. 
\ No newline at end of file
diff --git a/src/growable_arrays/simple_implementation.md b/src/growable_arrays/simple_implementation.md
new file mode 100644
index 0000000..0cba141
--- /dev/null
+++ b/src/growable_arrays/simple_implementation.md
@@ -0,0 +1,48 @@
+# Simple Implementation
+
+Following the previous description to the letter will get you
+something like this.
+
+Take some time to read it through.
+
+```java
+class GrowableIntArray {
+    // Store an int[] internally
+    private int[] data;
+
+    GrowableIntArray() {
+        // Make sure to initialize it correctly
+        this.data = new int[0];
+    }
+
+    // When someone wants to get an item, get it from the array
+    int get(int index) {
+        return this.data[index];
+    }
+
+    // Same deal when someone wants to set an item at an index.
+    void set(int index, int value) {
+        this.data[index] = value;
+    }
+
+    // And we need an accessor for the size so that someone
+    // can loop over the array.
+    int size() {
+        return this.data.length;
+    }
+
+    void add(int value) {
+        // Copy the old array to a new, bigger one
+        int[] newArray = new int[this.data.length + 1];
+        for (int i = 0; i < this.data.length; i++) {
+            newArray[i] = this.data[i];
+        }
+
+        // Then put the new element at the end
+        newArray[newArray.length - 1] = value;
+
+        // And swap the array
+        this.data = newArray; 
+    }
+}
+```
\ No newline at end of file
diff --git a/src/growable_arrays/usage.md b/src/growable_arrays/usage.md
new file mode 100644
index 0000000..812b05c
--- /dev/null
+++ b/src/growable_arrays/usage.md
@@ -0,0 +1,65 @@
+# Usage
+
+Using the class we defined would look something like this.
+
+```java
+~class GrowableIntArray {
+~    // Store an int[] internally
+~    private int[] data;
+~
+~    GrowableIntArray() {
+~        // Make sure to initialize it correctly
+~        this.data = new int[0];
+~    }
+~
+~    // When someone wants to get an item, get it from the array
+~    int get(int index) {
+~        return this.data[index];
+~    }
+~
+~    // Same deal when someone wants to set an item at an index.
+~    void set(int index, int value) {
+~        this.data[index] = value;
+~    }
+~
+~    // And we need an accessor for the size so that someone
+~    // can loop over the array.
+~    int size() {
+~        return this.data.length;
+~    }
+~
+~    void add(int value) {
+~        // Copy the old array to a new, bigger one
+~        int[] newArray = new int[this.data.length + 1];
+~        for (int i = 0; i < this.data.length; i++) {
+~            newArray[i] = this.data[i];
+~        }
+~
+~        // Then put the new element at the end
+~        newArray[newArray.length - 1] = value;
+~
+~        // And swap the array
+~        this.data = newArray; 
+~    }
+~}
+~
+~
+class Main {
+    void main() {
+        // To start we don't know how many elements there are
+        var array = new GrowableIntArray();
+
+        // Each time we add an element the array "grows"
+        array.add(1);
+        array.add(2);
+        array.add(3);
+
+        // And we can loop over it like so
+        for (int i = 0; i < array.size(); i++) {
+            System.out.println(array.get(i));
+        }
+    }
+}
+```
+
+Important to note that while we see it as if it was a growable array, no actual arrays are "growing." We are just faking it.
\ No newline at end of file
diff --git a/src/hardware.md b/src/hardware.md
new file mode 100644
index 0000000..a50384e
--- /dev/null
+++ b/src/hardware.md
@@ -0,0 +1,9 @@
+# Hardware
+
+That was a long stretch of Java, so I think you've earned a bit of a detour into
+general computing knowledge.
+
+I won't be offended if you skim or skip these sections. Depending on who you are,
+this might be a bit obvious.
+
+First lets cover hardware. The actual physical components that make up your computer.
\ No newline at end of file
diff --git a/src/hardware/cpu.md b/src/hardware/cpu.md
new file mode 100644
index 0000000..19eb919
--- /dev/null
+++ b/src/hardware/cpu.md
@@ -0,0 +1,9 @@
+# CPU
+
+At the core of every computer is a CPU.
+
+This stands for "central processing unit." This is the rock that wizards taught how to think.
+
+If you send the right electrical signals into a CPU it can do all sorts of math and it can do it quickly.
+
+Inside a computer this looks like a little metal square.
\ No newline at end of file
diff --git a/src/hardware/hard_drives.md b/src/hardware/hard_drives.md
new file mode 100644
index 0000000..28f1910
--- /dev/null
+++ b/src/hardware/hard_drives.md
@@ -0,0 +1,15 @@
+# Hard Drives
+
+RAM sticks have a few issues in the memory department. 
+
+First, they can only hold around 8-64 gigabytes of
+info. Any more than that and they can get pretty slow.[^latency]
+
+Second, when you turn off the computer they lose anything they are storing. This is a problem when
+you are writing an essay and need to turn off the computer half way through.
+
+Hard drives are like RAM in that they remember stuff. The difference is that hard drives
+can store a lot more of it (terrabytes) and the data isn't lost when power is turned off.
+
+[^latency]: The key word here is "latency". When the CPU needs info in RAM it needs to wait for RAM
+to find it. It takes longer to find something in a bigger pile of stuff, no matter how smart you are about it.
\ No newline at end of file
diff --git a/src/hardware/motherboard.md b/src/hardware/motherboard.md
new file mode 100644
index 0000000..dbd69e0
--- /dev/null
+++ b/src/hardware/motherboard.md
@@ -0,0 +1,8 @@
+# Motherboard
+
+All of these parts, and the parts I didn't mention, are connected to
+a big circuit board called a "motherboard."
+
+The motherboard connects the CPU, RAM, and any hard drive(s) such that they
+can "talk" to eachother. The details of how it does this aren't super important, so just imagine
+that a tiny wizard lives inside it.
\ No newline at end of file
diff --git a/src/hardware/ram.md b/src/hardware/ram.md
new file mode 100644
index 0000000..09bf39e
--- /dev/null
+++ b/src/hardware/ram.md
@@ -0,0 +1,13 @@
+# RAM
+
+CPUs can do math real fast, but they can't remember much stuff.[^likeme]
+
+This is what RAM is for. RAM stands for "random access memory." The random access
+part just means that a CPU can ask for any bit of info at any time.
+
+Most computers nowadays have an even number of RAM sticks. This is for interesting reasons I
+don't fully understand.
+
+[^likeme]: In 8th grade I had someone physically hand me a piece of paper with their name and
+fun facts about them because I had kept forgetting their name the entire year. I don't know what
+Sam is up to now, but I remember that she likes pistachio ice cream.
\ No newline at end of file
diff --git a/src/img/armcross.webp b/src/img/armcross.webp
new file mode 100644
index 0000000..eb03db0
Binary files /dev/null and b/src/img/armcross.webp differ
diff --git a/src/img/computer_bad.webp b/src/img/computer_bad.webp
new file mode 100644
index 0000000..99eaeb9
Binary files /dev/null and b/src/img/computer_bad.webp differ
diff --git a/src/img/eyeclose.webp b/src/img/eyeclose.webp
new file mode 100644
index 0000000..1e7c957
Binary files /dev/null and b/src/img/eyeclose.webp differ
diff --git a/src/inner_classes.md b/src/inner_classes.md
new file mode 100644
index 0000000..7047c61
--- /dev/null
+++ b/src/inner_classes.md
@@ -0,0 +1,13 @@
+# Inner Classes
+
+You can declare a class within another class.
+
+```java,no_run
+class Car {
+    class Speedometer {
+
+    }
+}
+```
+
+We call these inner classes.
diff --git a/src/inner_classes/disambiguation.md b/src/inner_classes/disambiguation.md
new file mode 100644
index 0000000..eafb54b
--- /dev/null
+++ b/src/inner_classes/disambiguation.md
@@ -0,0 +1,63 @@
+# Disambiguation
+
+If you are within an inner class and want to use a field
+from the instance it was created in but that field has the same
+name as a field in the inner class - like the following.
+
+```java,no_run
+class Car {
+    int speed = 0;
+
+    class Speedometer {
+        // Speed is declared here, but it is
+        // a different field
+        int speed = 5; 
+    }
+}
+```
+
+You can disambiguate between the fields by using the name of the containing class
+followed by `.this`. 
+
+```java,no_run
+class Car {
+    int speed = 0;
+
+    class Speedometer {
+        // Speed is declared here, but it is
+        // a different field
+        int speed = 5; 
+
+        void saySpeed() {
+            System.out.println(speed); // 5
+            System.out.println(this.speed); // 5
+            System.out.println(Car.this.speed); // 0
+        }
+    }
+}
+```
+
+```java
+~class Car {
+~    int speed = 0;
+~
+~    class Speedometer {
+~        // Speed is declared here, but it is
+~        // a different field
+~        int speed = 5; 
+~
+~        void saySpeed() {
+~            System.out.println(speed); // 5
+~            System.out.println(this.speed); // 5
+~            System.out.println(Car.this.speed); // 0
+~        }
+~    }
+~}
+class Main {
+    void main() {
+        var car = new Car();
+        var speedometer = car.new Speedometer();
+        speedometer.saySpeed();
+    }
+}
+```
\ No newline at end of file
diff --git a/src/inner_classes/instance_new.md b/src/inner_classes/instance_new.md
new file mode 100644
index 0000000..7db5f90
--- /dev/null
+++ b/src/inner_classes/instance_new.md
@@ -0,0 +1,3 @@
+# Instance New
+
+
diff --git a/src/inner_classes/instances.md b/src/inner_classes/instances.md
new file mode 100644
index 0000000..8591984
--- /dev/null
+++ b/src/inner_classes/instances.md
@@ -0,0 +1,46 @@
+# Instances
+
+To make an instance of an inner class you can use `new` to invoke its constructor
+like any other class.
+
+```java,no_run
+class Car {
+    class Speedometer {
+
+    }
+
+    Speedometer getSpeedometer() {
+        return new Speedometer();
+    }
+}
+```
+
+The restriction is that an inner class can only be constructed from an instance
+method of the containing class.
+
+This means that, in the example above, you cannot make an instance of `Speedometer`
+unless you first have an instance of `Car`.
+
+```java
+class Main {
+    void main() {
+        var car = new Car();
+        var speedometer = car.getSpeedometer();
+
+        System.out.println(speedometer);
+
+        // But this will not work
+        // var speedometer = new Car.Speedometer();
+    }
+}
+~
+~class Car {
+~    class Speedometer {
+~
+~    }
+~
+~    Speedometer getSpeedometer() {
+~        return new Speedometer();
+~    }
+~}
+```
\ No newline at end of file
diff --git a/src/inner_classes/new_operator.md b/src/inner_classes/new_operator.md
new file mode 100644
index 0000000..6755155
--- /dev/null
+++ b/src/inner_classes/new_operator.md
@@ -0,0 +1,33 @@
+# New Operator
+
+If you want to make an instance of an inner class
+without making a method on the class containing it,
+you can use the "new operator."
+
+Whereas you make an instance of a regular class by saying 
+something like `new ClassName()`, you can make an instance of an
+inner class by using `.new` on a variable that holds an instance
+of the containing class.
+
+Thats a confusing verbal description, but it kinda makes sense once you see it.
+
+```java
+class Car {
+    class Speedometer {
+    }
+}
+```
+
+```java
+~class Car {
+~    class Speedometer {
+~    }
+~}
+class Main {
+    void main() {
+        Car car = new Car();
+        Car.Speedometer speedometer = car.new Speedometer();
+        System.out.println(speedometer);
+    }
+}
+```
diff --git a/src/inner_classes/private_inner_classes.md b/src/inner_classes/private_inner_classes.md
new file mode 100644
index 0000000..7f31cc7
--- /dev/null
+++ b/src/inner_classes/private_inner_classes.md
@@ -0,0 +1,20 @@
+# Private Inner Classes
+
+Both `static` and regular inner classes can be marked as `private`.
+
+```java
+class Human {
+    // No other class can see this human's thoughts
+    private class Thoughts {
+
+    }
+
+    // Nor can they see their feelings
+    private static class Feelings {
+
+    }
+}
+```
+
+Within the class they are defined, a private inner class works as normal. The
+difference is that code outside the class cannot make instances of them.
\ No newline at end of file
diff --git a/src/inner_classes/scope.md b/src/inner_classes/scope.md
new file mode 100644
index 0000000..68b13a2
--- /dev/null
+++ b/src/inner_classes/scope.md
@@ -0,0 +1,61 @@
+# Scope
+
+Within an inner class all fields and methods of the instance it was created in
+are available.
+
+```java,no_run
+class Car {
+    int speed = 0;
+
+    class Speedometer {
+        int getSpeed() {
+            return speed;
+        }
+    }
+
+    Speedometer getSpeedometer() {
+        return new Speedometer();
+    }
+}
+```
+```java,no_run
+~class Car {
+~    int speed = 0;
+~
+~    class Speedometer {
+~        int getSpeed() {
+~            return speed;
+~        }
+~    }
+~
+~    Speedometer getSpeedometer() {
+~        return new Speedometer();
+~    }
+~}
+class Main {
+    void main() {
+        Car car = new Car();
+        Car.Speedometer = car.getSpeedometer();
+    }
+}
+```
+One mental model for this is that its as if the inner class
+holds a reference to the one it was created in.
+
+```java,no_run
+class Car {
+    int speed = 0;
+}
+
+class CarSpeedometer {
+    private final Car madeBy;
+
+    CarSpeedometer(Car madeBy) {
+        this.madeBy = madeBy;
+    }
+
+    int getSpeed() {
+        return madeBy.speed;
+    }
+}
+```
\ No newline at end of file
diff --git a/src/inner_classes/static_inner_classes.md b/src/inner_classes/static_inner_classes.md
new file mode 100644
index 0000000..90133ef
--- /dev/null
+++ b/src/inner_classes/static_inner_classes.md
@@ -0,0 +1,37 @@
+# Static Inner Classes
+
+If you mark an inner class as `static` then it becomes
+much closer to a normal class.
+
+```java,no_run
+class Car {
+    static class Speedometer {
+
+    }
+}
+```
+
+You can make instances of it directly without an instance of the outer class.
+
+```java,no_run
+Car.Speedometer speedometer = new Car.Speedometer();
+```
+
+And it cannot access fields of the instance it was made in, because it was not made in an instance.
+
+```java,no_run
+class Car {
+    int speed; // Speedometer can't magically get this anymore
+
+    static class Speedometer {
+
+    }
+}
+```
+
+I would wager that this is the most common kind of inner class to see
+in real code, despite requiring more words to define[^theme].
+
+[^theme]: A theme that will start to emerge is that the "best" code sometimes has
+a few extra modifiers on it and the "default" behavior isn't what you want. Static
+inner classes are way less magic.
\ No newline at end of file
diff --git a/src/inner_classes/the_anonymous_main_class.md b/src/inner_classes/the_anonymous_main_class.md
new file mode 100644
index 0000000..792ac79
--- /dev/null
+++ b/src/inner_classes/the_anonymous_main_class.md
@@ -0,0 +1,53 @@
+# The anonymous main class
+
+If you remember when I first showed you classes, you were working inside
+the anonymous main class.
+
+```java,no_run
+class Muppet {
+    String name;
+}
+
+void main() {
+    Muppet kermit = new Muppet();
+    kermit.name = "Kermit The Frog";
+}
+```
+
+This means that all the classes you made were, in reality, inner classes.
+
+```java,no_run
+class Main {
+    class Muppet {
+        String name;
+    }
+
+    void main() {
+        Muppet kermit = new Muppet();
+        kermit.name = "Kermit The Frog";
+    }
+}
+```
+
+Which is how they would have access to any "global fields" you declared
+and why static factory methods would not work.
+
+```java,no_run,does_not_compile
+class Main {
+    class Muppet {
+        String name;
+
+        static Muppet fromName(String name) {
+            // You cannot make an instance of an inner class
+            // from within a static method, so this wouldn't work.
+            Muppet muppet = new Muppet();
+            muppet.name = name;
+            return muppet;
+        }
+    }
+
+    void main() {
+        Muppet kermit = Muppet.fromName("Kermit The Frog");
+    }
+}
+```
\ No newline at end of file
diff --git a/src/inner_classes/type.md b/src/inner_classes/type.md
new file mode 100644
index 0000000..ffd1409
--- /dev/null
+++ b/src/inner_classes/type.md
@@ -0,0 +1,30 @@
+# Type
+
+The type of an inner class, when used as a variable or as a field,
+is the name of the containing class followed by a `.` and the
+name of the inner class.
+
+```java,no_run
+class Car {
+    class Speedometer {}
+}
+```
+
+So a field containing an instance of `Speedometer` would have the type `Car.Speedometer`.
+
+```java,no_run
+Car.Speedometer speedometer = ...;
+```
+
+The exception is if the inner class is referenced within the class that declares it.
+In that context you just need to write the name of the class;
+
+```java
+class Car {
+    // Car.Speedometer is not required
+    // (it will work though)
+    Speedometer speedometer;
+
+    class Speedometer {}
+}
+```
\ No newline at end of file
diff --git a/src/instanc b/src/instanc
deleted file mode 100644
index 7eff5f5..0000000
--- a/src/instanc
+++ /dev/null
@@ -1 +0,0 @@
-# Invoke Other Methods
diff --git a/src/instance b/src/instance
deleted file mode 100644
index d742220..0000000
--- a/src/instance
+++ /dev/null
@@ -1 +0,0 @@
-# this
diff --git a/src/integer_ii/integer_to_a_base_16_string.md b/src/integer_ii/integer_to_a_base_16_string.md
new file mode 100644
index 0000000..f609cba
--- /dev/null
+++ b/src/integer_ii/integer_to_a_base_16_string.md
@@ -0,0 +1 @@
+# Integer to a Base 16 String
diff --git a/src/integers_ii.md b/src/integers_ii.md
new file mode 100644
index 0000000..47bc3fd
--- /dev/null
+++ b/src/integers_ii.md
@@ -0,0 +1,5 @@
+# Integers II
+
+Integers never stop being relevant and, now that we
+have covered static methods, we are ready to cover
+some of the more useful ones that exist for working with integers.
\ No newline at end of file
diff --git a/src/integers_ii/base_16_integer_literals.md b/src/integers_ii/base_16_integer_literals.md
new file mode 100644
index 0000000..e00e500
--- /dev/null
+++ b/src/integers_ii/base_16_integer_literals.md
@@ -0,0 +1,36 @@
+# Base 16 Integer Literals
+
+In polite society we use a base 10 number system[^everything]. This means
+we start counting at `0` and go up by one until we reach `9`. 
+
+`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`
+
+Then when we go up one more we put a `1` at the front and "wrap around."
+
+`10`, `11`, `12`, etc.
+
+In a base 16 number system, sometimes called "hexadecimal", you keep going a little
+bit more before wrapping around.
+
+`0`, `1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `A`, `B`, `C`, `D`, `E`, `F`, `10`, `11`, ..., `A5`, ..., `5F`, ... etc.
+
+To write an integer literal in Java which contains a hexadecimal number you write `0x` before the number.
+
+```java
+~void main() {
+int sixteen = 0x10;
+System.out.println(sixteen);
+
+int twoHundredFiftyFive = 0xFF;
+System.out.println(twoHundredFiftyFive);
+~}
+```
+
+Hexadecimal numbers like this are very common when you are writing code that
+deals with colors in RGB - Red, Green, Blue - format. `0xFFFFFF` is white, `0xFF0000` is red, `0xCCCCFF` is periwinkle, etc.
+
+
+
+
+[^everything]: Okay to be real with you, every number system is a base 10 system.
+Even if what you call "10" is what we would call "sixteen", you always wrap around your base when you write "10." If that doesn't make sense it doesn't matter, but its fascinating to me.
\ No newline at end of file
diff --git a/src/integers_ii/integer_from_a_base_16_string.md b/src/integers_ii/integer_from_a_base_16_string.md
new file mode 100644
index 0000000..d401347
--- /dev/null
+++ b/src/integers_ii/integer_from_a_base_16_string.md
@@ -0,0 +1,32 @@
+# Integer from a Base 16 String
+
+If you have a `String` which contains text that can be interpreted as a base 16 integer, you can convert it into an `int` by using `parseInt` and giving the
+number `16` as an extra argument.
+
+```java
+~void main() {
+String text = "C";
+
+int twelve = Integer.parseInt(text, 16);
+
+System.out.println(twelve);
+~}
+```
+
+This will not work if the number is prefixed by `0x` like it would be in your code.
+
+```java,panics
+~void main() {
+Integer.parseInt("0xC", 16);
+~}
+```
+
+If you want to handle both hexadecimal numbers and regular base 10 numbers you should instead use `Integer.decode`.
+
+```java
+~void main() {
+System.out.println(Integer.decode("0xC"));
+System.out.println(Integer.decode("0x19"));
+System.out.println(Integer.decode("19"));
+~}
+```
\ No newline at end of file
diff --git a/src/integers_ii/integer_from_a_string.md b/src/integers_ii/integer_from_a_string.md
new file mode 100644
index 0000000..0920866
--- /dev/null
+++ b/src/integers_ii/integer_from_a_string.md
@@ -0,0 +1,43 @@
+# Integer from a String
+
+If you have a `String` which contains text that can be interpreted
+as an integer you can convert it to an `int` using the `parseInt`
+static method on `Integer`.
+
+```java
+~void main() {
+String text = "123";
+
+int oneTwoThree = Integer.parseInt(text);
+
+System.out.println(oneTwoThree);
+~}
+```
+
+If what is in the `String` cannot be converted to an `int` that method
+will throw a `NumberFormatException`.
+
+```java,panics
+~void main() {
+String word = "music";
+
+int value = Integer.parseInt(word);
+~}
+```
+
+If you want to handle input from a user that might not be interpretable
+as an integer, you can use `try`/`catch` alongside delayed assignment.
+
+```java
+~void main() {
+String word = "seltzer";
+
+int value;
+try {
+    value = Integer.parseInt(word);
+} catch (NumberFormatException e) {
+    value = 8; // Default value
+}
+~}
+```
+
diff --git a/src/integers_ii/integer_to_a_base_16_string.md b/src/integers_ii/integer_to_a_base_16_string.md
new file mode 100644
index 0000000..fe2f3f1
--- /dev/null
+++ b/src/integers_ii/integer_to_a_base_16_string.md
@@ -0,0 +1,14 @@
+# Integer to a Base 16 String
+
+If you have an integer you want to turn into a `String` in base 16
+integer you can use the `toHexString` method on `Integer`.
+
+```java
+~void main() {
+int x = 29411;
+String xStr = Integer.toHexString(x);
+
+// 72e3
+System.out.println(xStr);
+~}
+```
\ No newline at end of file
diff --git a/src/integers_ii/integer_to_a_string.md b/src/integers_ii/integer_to_a_string.md
new file mode 100644
index 0000000..c381362
--- /dev/null
+++ b/src/integers_ii/integer_to_a_string.md
@@ -0,0 +1,28 @@
+# Integer to a String
+
+If you have an integer you want to turn into a `String` you have two options.
+
+One is to "add it" to an empty string.
+
+```java
+~void main() {
+int x = 4;
+String xStr = "" + x;
+
+System.out.println(xStr);
+~}
+```
+
+The other is to use the `toString` static method on `Integer`.
+
+
+```java
+~void main() {
+int x = 4;
+String xStr = Integer.toString(x);
+
+System.out.println(xStr);
+~}
+```
+
+I personally find the second one more direct, but opinions can reasonably vary.
\ No newline at end of file
diff --git a/src/integers_ii/underscores_in_integer_literals.md b/src/integers_ii/underscores_in_integer_literals.md
new file mode 100644
index 0000000..f661cd7
--- /dev/null
+++ b/src/integers_ii/underscores_in_integer_literals.md
@@ -0,0 +1,27 @@
+# Underscores in Integer Literals
+
+When you are writing large numbers `1000000000` isn't very
+visually distinct from `10000000000`.
+
+To help with the legibility you are allowed to insert underscores
+between digits in an integer literal.
+
+```java
+~void main() {
+int x = 1_000_000_000;
+int y = 10_000_000_000;
+
+System.out.println(x);
+System.out.println(y);
+~}
+```
+
+This works with hexadecimal integer literals as well.
+
+```java
+~void main() {
+int white = 0xFF_FF_FF;
+
+System.out.println(Integer.toHexString(white));
+~}
+```
\ No newline at end of file
diff --git a/src/loops/challenges.md b/src/loops/challenges.md
index 8ab05c3..3ed33fc 100644
--- a/src/loops/challenges.md
+++ b/src/loops/challenges.md
@@ -111,18 +111,8 @@ void main() {
 }
 ```
 
-## Challenge 7
-
-What will this program output when run? Write down your guess and then try running it.
-
-```java,editable
-void main() {
-    <CODE HERE>
-}
-```
 
-
-## Challenge 8
+## Challenge 7
 
 Write code that will output each character of `name` on its own line.
 
@@ -145,7 +135,7 @@ void main() {
 ```
 
 
-## Challenge 9
+## Challenge 8
 
 Write code that will output each character of `name` on its own line, starting with the last
 character and going backwards.
@@ -173,7 +163,7 @@ void main() {
 ```
 
 
-## Challenge 10
+## Challenge 9
 
 Write code that will take a number and if it is divisible by two, divides it by two.
 If it is not, multiplies it by three and adds one.
@@ -226,7 +216,7 @@ void main() {
 ```
 
 
-## Challenge 11
+## Challenge 10
 
 Write code that outputs every third number from `37` to `160`.
 
@@ -237,7 +227,7 @@ void main() {
 ```
 
 
-## Challenge 12
+## Challenge 11
 
 Write code that outputs the number of vowels in `name`. Treat `y` as a vowel.
 
@@ -253,7 +243,7 @@ void main() {
 ```
 
 
-## Challenge 13
+## Challenge 12
 
 Write code that outputs `{name} is mostly vowels` if the number of vowels in `name` is greater
 than the number of consonants. and `{name} is mostly consonants` if the opposite is true.
@@ -272,7 +262,7 @@ void main() {
 ```
 
 
-## Challenge 14
+## Challenge 13
 
 Rewrite the following code to not have the `shouldBreak` variable
 and instead to use a labeled break.
@@ -284,7 +274,7 @@ void main() {
     int y = 0;
 
     boolean shouldBreak = false;
-    while (shouldBreak && x < 100) {
+    while (!shouldBreak && x < 100) {
         while (y < 100) {
             System.out.println("x is " + x);
             System.out.println("y is " + y);
diff --git a/src/loops_iii.md b/src/loops_iii.md
new file mode 100644
index 0000000..1cfccb6
--- /dev/null
+++ b/src/loops_iii.md
@@ -0,0 +1 @@
+# Loops III
diff --git a/src/multi_file_programs.md b/src/multi_file_programs.md
new file mode 100644
index 0000000..78accc1
--- /dev/null
+++ b/src/multi_file_programs.md
@@ -0,0 +1,11 @@
+# Multi-File Programs
+
+For many reasons, it makes sense to split programs into multiple files.
+
+This is one of those things that is easier to show than tell, so to follow along
+make a blank folder on your computer.
+
+```
+$ mkdir program
+$ cd program
+```
\ No newline at end of file
diff --git a/src/multi_file_programs/a_second_file.md b/src/multi_file_programs/a_second_file.md
new file mode 100644
index 0000000..48e7370
--- /dev/null
+++ b/src/multi_file_programs/a_second_file.md
@@ -0,0 +1,43 @@
+# A Second file
+
+In files that are not `Main.java` you can put other code, but
+only in the form of a class.
+
+By this I mean, while in `Main.java` you are able to write something like this.
+
+```java
+void sayHello() {
+    System.out.println("Hello");
+}
+
+void main() {
+    sayHello();
+}
+```
+
+In a file named `Ball.java` you need to put all code inside a `Ball` class.
+
+```java
+class Ball {
+    // You can write constructors, methods, fields, etc.
+    final int size;
+
+    Ball(int size) {
+        this.size = size;
+    }
+}
+
+// But you cannot have any "top level" methods or things outside
+// of the Ball class
+```
+
+Then from `Main.java` you can make an instance of `Ball`
+
+```java
+void main() {
+    var ball = new Ball(10);
+    System.out.println("The ball is " + ball.size + "cm across");
+}
+```
+
+When you run `java src/Main.java` it will find `src/Ball.java` and use the code in there.
\ No newline at end of file
diff --git a/src/multi_file_programs/file_names.md b/src/multi_file_programs/file_names.md
new file mode 100644
index 0000000..8c6365d
--- /dev/null
+++ b/src/multi_file_programs/file_names.md
@@ -0,0 +1,17 @@
+# File names
+
+When you make a file called `Ball.java` you should expect to find a class named `Ball` inside of it.
+
+This is a general rule. When you split code into multiple files each file should be
+a class and the name of the class should match the name of the file.
+
+So if I want to write a `Position` class
+
+```java
+class Position {
+    int x;
+    int y;
+}
+```
+
+That should go in its own file named `Position.java`.
\ No newline at end of file
diff --git a/src/multi_file_programs/global_fields.md b/src/multi_file_programs/global_fields.md
new file mode 100644
index 0000000..9c707a7
--- /dev/null
+++ b/src/multi_file_programs/global_fields.md
@@ -0,0 +1,32 @@
+# Global Fields
+
+Global fields, accordingly, were always a lie.
+
+```java
+int number = 0;
+
+void main() {
+    System.out.println(number);
+    number++;
+    System.out.println(number);
+}
+```
+
+They are just normal fields in the anonymous main class.
+
+```java
+class Main {
+    int number = 0;
+
+    void main() {
+        System.out.println(number);
+        number++;
+        System.out.println(number);
+    }
+}
+```
+
+This means that once you move to programs in multiple files they are no longer global
+to your program - just the code in the main class.[^bummer]
+
+[^bummer]: Huge bummer, but we will learn how to make actually global things later.
\ No newline at end of file
diff --git a/src/multi_file_programs/the_anonymous_main_class.md b/src/multi_file_programs/the_anonymous_main_class.md
new file mode 100644
index 0000000..a893e43
--- /dev/null
+++ b/src/multi_file_programs/the_anonymous_main_class.md
@@ -0,0 +1,30 @@
+# The Anonymous Main Class
+
+Surprise! Everything in Java is actually in a class.
+
+This includes the code in `Main.java`.
+
+```java
+void main() {
+    System.out.println("What, really?");
+}
+```
+
+Everything we've written so far has been in what is called "the anonymous main class."
+We call it anonymous because we never gave it a name. 
+
+We call it the main class because you are only allowed to skip naming a class if it is the one you use to start your program, and that requires a `void main()` method.
+
+If you take any code we've produced up until now and put wrap it with `class Main {}` it will continue to work as-is.
+
+```java
+class Main {
+    void main() {
+        System.out.println("yep.");
+    }
+}
+```
+
+What Java will do is run `new Main().main();` to start your program.
+
+
diff --git a/src/multi_file_programs/the_main_file.md b/src/multi_file_programs/the_main_file.md
new file mode 100644
index 0000000..eb550a5
--- /dev/null
+++ b/src/multi_file_programs/the_main_file.md
@@ -0,0 +1,28 @@
+# The Main file
+
+Inside your `src` folder make a file called `Main.java`. This is the file where
+we are going to write the "start" of the program.
+
+All the Java code you've written up until now will work if you put it into this file.
+
+```java
+void main() {
+    System.out.println("Hello, world!");
+}
+```
+
+So you should now have something that looks like this.
+
+```
+project/
+  src/
+    Main.java
+```
+
+To run your program, use the `java` command.
+
+```
+$ java src/Main.java
+Hello, world!
+```
+
diff --git a/src/multi_file_programs/the_sources_folder.md b/src/multi_file_programs/the_sources_folder.md
new file mode 100644
index 0000000..03ad7f0
--- /dev/null
+++ b/src/multi_file_programs/the_sources_folder.md
@@ -0,0 +1,23 @@
+# The Sources folder
+
+When people work on "a project" - meaning a program made to
+accomplish some task - there will often be more than just Java code involved.
+
+To deal with this its common to make a folder to put Java code into. I prefer the name
+`src` for this.
+
+```
+$ mkdir src
+```
+
+And inside this `src` folder we will put the code.[^layouts]
+
+So you should have this
+
+```
+project/ <- Open this in your text editor
+  src/ <- Code will go here
+```
+
+[^layouts]: There are different ways to layout a project. All are valid. You can call the `src` folder `STUFF` - it ultimately doesn't matter. This is just another one of those social conventions.
+
diff --git a/src/operating_systems.md b/src/operating_systems.md
new file mode 100644
index 0000000..c4a111e
--- /dev/null
+++ b/src/operating_systems.md
@@ -0,0 +1,7 @@
+# Operating Systems
+
+The exact electrical signals you need to send to make a computer "work"
+are, obviously, a bit complicated.
+
+This is where operating systems come in. Operating systems are programs that "operate"
+all the parts that make up your computer.
\ No newline at end of file
diff --git a/src/operating_systems/abstractions.md b/src/operating_systems/abstractions.md
new file mode 100644
index 0000000..ede42ad
--- /dev/null
+++ b/src/operating_systems/abstractions.md
@@ -0,0 +1,19 @@
+# Abstractions
+
+The most important jobs of an operating system is to "abstract"
+over the hardware.
+
+You shouldn't need to know what brand network card you have in order
+to write code that connects to the internet. You shouldn't need to know
+what kind of hard drive will be on the machine to store data.
+
+We call these abstractions because they take things that are concrete,
+like a dozen specific models of hard drive and the exact bits to send to do their operations, 
+and make an "abstract model" of their commonalities.[^deeper]
+
+This lets programmers write programs that will run on any machine that has the right operating system.
+It doesn't help writing programs that will run on any operating system because different operating systems
+provide different abstractions over the same hardware. The code to write to a hard drive in Windows is different than it is in Mac OS.
+
+[^deeper]: There are deeper and shallower versions of this explanation which we will
+get to. There will be plenty of time to talk about this concept as it relates to Java and other things.
diff --git a/src/operating_systems/defaults.md b/src/operating_systems/defaults.md
new file mode 100644
index 0000000..aaa6647
--- /dev/null
+++ b/src/operating_systems/defaults.md
@@ -0,0 +1,22 @@
+# Defaults
+
+A social aspect of operating systems is that they control the "default"
+experience people have with computers.
+
+Installing an operating system is prohibitvely difficult, so computer manufacturers
+install one before selling a device. When they choose Windows and Windows comes
+with Internet Explorer built in, people use Internet Explorer.[^lawsuit]
+
+There are a lot of kinda grim things that follow from this, and you should dig deeper,
+but I bring it up to mention the 1980s.
+
+The personal computers available then, like the [Commodore 64](https://en.wikipedia.org/wiki/Commodore_64),
+only had text based interfaces. In many practical ways, people were closer to the world of programming.[^movies] 
+
+So think about that whenever you feel like you have a lot left to learn. A lot of what you do and do not know
+about computers was dictated for you by the fact that you grew up interacting with them on a touch screen
+instead of on a terminal. Things are not as intimiating as they seem.
+
+[^lawsuit]: https://en.wikipedia.org/wiki/United_States_v._Microsoft_Corp.
+
+[^movies]: Ever wonder why the kid in [WarGames](https://en.wikipedia.org/wiki/WarGames) was a hacking wizz? The kids in basically every 80s movie? And yet all most of us can pull off is opening Google.
diff --git a/src/operating_systems/game_consoles.md b/src/operating_systems/game_consoles.md
new file mode 100644
index 0000000..ed62833
--- /dev/null
+++ b/src/operating_systems/game_consoles.md
@@ -0,0 +1,11 @@
+# Game Consoles
+
+Game Consoles generally always do their own wacky thing.
+
+For the same reasons as mobile devices, you will have a lot of trouble
+trying to program on a game console. They are special made to run Halo.[^age]
+
+[^age]: Yeah, Halo sucks now. Halo 3 was art. Obtuse, beautiful, orchestral art. I am old enough to have lived
+in the age of dreams and to know of their dimming.
+
+
diff --git a/src/operating_systems/mobile_phones.md b/src/operating_systems/mobile_phones.md
new file mode 100644
index 0000000..26428d5
--- /dev/null
+++ b/src/operating_systems/mobile_phones.md
@@ -0,0 +1,8 @@
+# Mobile Phones
+
+Android and iOS are the major players in the mobile device world.
+
+You will find doing the tasks a programmer needs to exceedingly difficult on these.
+This is because the interfaces made by these operating systems are designed for use
+by the general public on small devices. Working with a keyboard and editing a Java
+program aren't tasks that are prioritized.
diff --git a/src/operating_systems/personal_computers.md b/src/operating_systems/personal_computers.md
new file mode 100644
index 0000000..3053443
--- /dev/null
+++ b/src/operating_systems/personal_computers.md
@@ -0,0 +1,11 @@
+# Personal Computers
+
+For "personal computers", which I am defining as the sort of computers that have a keyboard
+and a screen, the most common operating system is Windows. The second most common is Mac OS.
+
+These are both produced by massive corporations in order to sell pre-installed on computers.
+As such, they give you a graphical interface that you navigate with a mouse/touchpad and keyboard.
+This is what people have found comfortable and what most are used to.
+
+To write code and do other programmer things you have to install programs but once you know what
+you need to install its pretty easy.
\ No newline at end of file
diff --git a/src/operating_systems/servers.md b/src/operating_systems/servers.md
new file mode 100644
index 0000000..d5766dd
--- /dev/null
+++ b/src/operating_systems/servers.md
@@ -0,0 +1,12 @@
+# Servers
+
+For servers, the kind of machines you run in a datacenter
+to host websites, the most common operating system is Linux.
+
+Because so many jobs are writing websites to host on servers, you will eventually
+need to learn how to work with Linux.
+
+That will be a fun adventure. An adventure I implore you not to explore by bricking[^def]
+your family's or a school's computer trying to install Linux on it. Only mess with your own stuff.
+
+[^def]: I.E. making useless
\ No newline at end of file
diff --git a/src/packages.md b/src/packages.md
new file mode 100644
index 0000000..a951fc9
--- /dev/null
+++ b/src/packages.md
@@ -0,0 +1,14 @@
+# Packages
+
+Every class in Java "lives" in a package.
+
+A package is a way to group individual classes.
+
+```java,no_run
+package dungeon;
+
+class BugBear {
+
+}
+```
+
diff --git a/src/packages/declaration.md b/src/packages/declaration.md
new file mode 100644
index 0000000..bf005fc
--- /dev/null
+++ b/src/packages/declaration.md
@@ -0,0 +1,31 @@
+# Declaration
+
+To put a class into a package you need to do two things.
+
+First, put a "package declaration" at the top of the file. This looks like the word `package` followed by the name of the package and a `;`
+
+```java,no_run
+package dungeon;
+
+class BugBear {
+
+}
+```
+
+Then you need to make sure that the `.java` file is in a folder matching the name of
+that package.
+
+So, for the example above, if your code was previously laid out like this
+
+```
+src/
+   BugBear.java
+```
+
+It needs to be changed to this.
+
+```
+src/
+  dungeon/
+    BugBear.java
+```
\ No newline at end of file
diff --git a/src/packages/fully_qualified_class_name.md b/src/packages/fully_qualified_class_name.md
new file mode 100644
index 0000000..b366a1a
--- /dev/null
+++ b/src/packages/fully_qualified_class_name.md
@@ -0,0 +1,29 @@
+# Fully Qualified Class Name
+
+In order to use a public class from a different package you can
+write out the "fully qualified class name."[^fqcn]
+
+This is the name of the class prefixed with the package it is in.
+
+```java,no_run
+package village;
+
+public class Villager {}
+```
+
+```java,no_run
+package dungeon;
+
+class Dwarf {
+    // Works because we write out the full name
+    // and because Villager is public.
+    village.Villager meet() {
+        return new village.Villager();
+    }
+}
+```
+
+This hints that the "real name" of a class isn't what you write after `class`, but instead both that and the package name glued together.
+
+[^fqcn]: People also often call this the "FQCN". Its a fun acronym to write, but I
+have no clue how to say it out loud. "Faquacün?"
\ No newline at end of file
diff --git a/src/packages/import.md b/src/packages/import.md
new file mode 100644
index 0000000..b717cdf
--- /dev/null
+++ b/src/packages/import.md
@@ -0,0 +1,28 @@
+# Import
+
+If you don't want to write out the fully qualified class name everywhere, and few do,
+then you can use an `import`.
+
+To import a class you write `import` followed by the fully qualified class name.
+This makes it so that the "simple" class name will be usable.
+
+```java,no_run
+package village;
+
+public class Villager {}
+```
+
+```java,no_run
+package dungeon;
+
+// For the rest of the file, you can
+// just write "Villager" and Java will know
+// what you mean.
+import village.Villager;
+
+class Dwarf {
+    Villager meet() {
+        return new Villager();
+    }
+}
+```
\ No newline at end of file
diff --git a/src/packages/package_private_constructors.md b/src/packages/package_private_constructors.md
new file mode 100644
index 0000000..0112d71
--- /dev/null
+++ b/src/packages/package_private_constructors.md
@@ -0,0 +1,28 @@
+# Package-Private Constructors
+
+A constructor without any other modifier is "package-private" in the
+same way as methods and fields.[^private]
+
+```java
+package dungeon;
+
+public class Slime {
+    final int size;
+
+    // This constructor is public, 
+    // code in other packages can use it.
+    public Slime() {
+        this.size = 5;
+    }
+
+    // This constructor is package-private,
+    // code in other packages cannot use it.
+    Slime(int size) {
+        this.size = size;
+    }
+}
+```
+
+[^private]: Your spider-sense might be tingling wondering if `private` constructors
+are a thing. They are! I'll talk about them more in-depth later, but they can be
+surprisingly useful.
\ No newline at end of file
diff --git a/src/packages/package_private_fields.md b/src/packages/package_private_fields.md
new file mode 100644
index 0000000..3b64095
--- /dev/null
+++ b/src/packages/package_private_fields.md
@@ -0,0 +1,13 @@
+# Package-Private Fields
+
+Fields that are marked neither `public` nor `private` are "package-private."
+
+```java
+package village;
+
+public class Well {
+    // Neither of these can be used outside of the "village" package
+    static final int NUMBER_OF_DEMONS = 4;
+    boolean exorcismPerformed;
+}
+```
\ No newline at end of file
diff --git a/src/packages/package_private_methods.md b/src/packages/package_private_methods.md
new file mode 100644
index 0000000..d42f927
--- /dev/null
+++ b/src/packages/package_private_methods.md
@@ -0,0 +1,22 @@
+# Package-Private Methods
+
+If a method is neither `public` or `private` then it can
+be used only by code in the same package.
+
+We call these methods "package-private" because they are
+"private" to code outside the package.
+
+```java
+package village;
+
+public class Villager {
+    void isNotVisible() {
+        System.out.println("""
+            This method can be called from code in the 'village'
+            package, but not from other packages.
+            """);
+    }
+}
+```
+
+Which again applies to static methods as well.
diff --git a/src/packages/public_classes.md b/src/packages/public_classes.md
new file mode 100644
index 0000000..5981542
--- /dev/null
+++ b/src/packages/public_classes.md
@@ -0,0 +1,11 @@
+# Public Classes
+
+To be able to use a class in one package from a different package,
+you must first mark that class as `public`.
+
+```java,no_run
+package village;
+
+// Now other packages will be able to see it
+public class Villager {}
+```
\ No newline at end of file
diff --git a/src/packages/public_constructors.md b/src/packages/public_constructors.md
new file mode 100644
index 0000000..7f65830
--- /dev/null
+++ b/src/packages/public_constructors.md
@@ -0,0 +1,35 @@
+# Public Constructors
+
+For a constructor you write to be usable across packages[^youguessed] it needs
+to be marked `public`.
+
+```java,no_run
+package dungeon;
+
+public class Skeleton {
+    public final int bones;
+
+    public Skeleton() {
+        this.bones = 206;
+    }
+}
+```
+
+```java,no_run
+package village;
+
+import dungeon.Skeleton;
+
+class Main {
+    void main() {
+        // Now this works
+        var skeleton = new Skeleton();
+
+        // And we get the right number of bones!
+        System.out.println(skeleton.bones);
+    }
+}
+```
+
+
+[^youguessed]: You guessed it!
\ No newline at end of file
diff --git a/src/packages/public_fields.md b/src/packages/public_fields.md
new file mode 100644
index 0000000..c616d52
--- /dev/null
+++ b/src/packages/public_fields.md
@@ -0,0 +1,14 @@
+# Public Fields
+
+Similarly to methods, for a field to be used from a different package
+it must be marked `public`.
+
+```java
+package village;
+
+public class Well {
+    // Both of these you can use from a different package
+    public static final int DEPTH = 10;
+    public int remainingWater;
+}
+```
diff --git a/src/packages/public_methods.md b/src/packages/public_methods.md
new file mode 100644
index 0000000..9e24dcc
--- /dev/null
+++ b/src/packages/public_methods.md
@@ -0,0 +1,34 @@
+# Public Methods
+
+Even though a class might itself be marked `public`, the methods
+within it will not be unless they are also `public`.
+
+```java,no_run
+package village;
+
+// Now other packages will be able to see it
+public class Villager {
+    public void isVisible() {
+        System.out.println("This method is callable from another package.");
+    }
+
+    void isNotVisible() {
+        System.out.println("This method is not.")
+    }
+}
+```
+
+This applies also to static methods.
+
+```java,no_run
+package village;
+
+public class Well {
+    public static int drawWater() {
+        System.out.println("""
+            You need this to be both public and static to
+            be able to write Well.drawWater()
+            """);
+    }
+}
+```
diff --git a/src/packages/reverse_domain_name_notation.md b/src/packages/reverse_domain_name_notation.md
new file mode 100644
index 0000000..40f1128
--- /dev/null
+++ b/src/packages/reverse_domain_name_notation.md
@@ -0,0 +1,24 @@
+# Reverse Domain Name Notation
+
+Part of the point of putting classes into packages
+is to avoid conflicts when using code written by other people.
+
+If you want a class named `RiceCooker` and you want to use a code that someone
+on the internet wrote which just so happens to also have a class named `RiceCooker`,
+that only works if you both put your classes in different packages.
+
+Making sure different people cooperate is a hard problem, so the social convention
+that emerged was to name packages using a "reverse domain name notation."
+
+Only one person could own a domain name - like `google.com` - at a time. So all
+code coming out of Google[^shared] would start with a package name which is the reverse
+of that - `com.google`.[^thisiswhy] 
+
+Nowadays people also tend to accept unique prefixes based on accounts you might have on a site. So you might see things like `com.github.their_username_here` for people who have an account with a service like `Github`.
+
+It isn't perfect, nothing would be, but its socially dominant so you should be aware of it. If the code you are writing won't be shared with others you do not need to do this sort of thing yourself.
+
+
+[^shared]: That might be mixed with other code written by different companies or by different people.
+
+[^thisiswhy]: This is why many tools will have your starter project have classes in the `com.example` package
\ No newline at end of file
diff --git a/src/packages/subpackages.md b/src/packages/subpackages.md
new file mode 100644
index 0000000..e10a0f2
--- /dev/null
+++ b/src/packages/subpackages.md
@@ -0,0 +1,26 @@
+# Subpackages
+
+Packages can also have subpackages.
+
+What this looks like is for any package with a `.` in its name - say `my.fun.project` -
+you need a new folder.
+
+So if you have a class like this
+
+```java
+package my.fun.project;
+
+public class Apple {}
+```
+
+It should be in a folder structure like this
+
+```
+src/
+  my/
+    fun/
+      project/
+        Apple.java
+```
+
+And the fully qualified class name would be `my.fun.project.Apple`.
\ No newline at end of file
diff --git a/src/packages/the_anonymous_main_class.md b/src/packages/the_anonymous_main_class.md
new file mode 100644
index 0000000..56617e1
--- /dev/null
+++ b/src/packages/the_anonymous_main_class.md
@@ -0,0 +1,34 @@
+# The Anonymous Main Class
+
+You are only allowed to make an anonymous main class
+inside the default package.
+
+```java,no_run
+// Allowed
+void main() {
+    System.out.println("Hello, world");
+}
+```
+
+```java,does_not_compile
+// Not Allowed
+package myprogram;
+
+void main() {
+    System.out.println("Hello, world");
+}
+```
+
+This means that for classes in packages you have to wrap them in 
+an explicitly named class like everything else.
+
+```java,no_run
+// Allowed
+package myprogram;
+
+class Main {
+    void main() {
+        System.out.println("Hello, world");
+    }
+}
+```
\ No newline at end of file
diff --git a/src/packages/the_default_constructor.md b/src/packages/the_default_constructor.md
new file mode 100644
index 0000000..c6c6a3c
--- /dev/null
+++ b/src/packages/the_default_constructor.md
@@ -0,0 +1,53 @@
+# The Default Constructor
+
+If a class is `public` and has a default constructor - i.e. the constructor you
+get when you don't specify one - then the default constructor you get will be
+`public`.
+
+```java,no_run
+package dungeon;
+
+public class Skeleton {
+    // No constructor specified
+}
+```
+
+```java,no_run
+package village;
+
+import dungeon.Skeleton;
+
+class Main {
+    void main() {
+        // We can say `new Skeleton()` here
+        var skeleton = new Skeleton();
+    }
+}
+```
+
+If you write out a constructor yourself this will not be the case.
+
+```java,no_run
+package dungeon;
+
+public class Skeleton {
+    public final int bones;
+
+    Skeleton() {
+        this.bones = 206;
+    }
+}
+```
+
+```java,no_run
+package village;
+
+import dungeon.Skeleton;
+
+class Main {
+    void main() {
+        // Now "new Skeleton()" will not work.
+        var skeleton = new Skeleton();
+    }
+}
+```
\ No newline at end of file
diff --git a/src/packages/the_default_package.md b/src/packages/the_default_package.md
new file mode 100644
index 0000000..d4dcdce
--- /dev/null
+++ b/src/packages/the_default_package.md
@@ -0,0 +1,27 @@
+# The Default Package
+
+When your classes don't have a package declaration at, we say those are in the "default package."
+
+```java,no_run
+// No package declaration means default package
+public class Elf {
+
+}
+```
+
+Classes in the default package cannot be imported by classes
+in named packages, regardless of if those classes are public.
+
+```java,no_run
+package villager;
+
+public class Villager {
+    // No way to reference Elf directly,
+    // even if Elf is public
+}
+```
+
+Because of this restriction[^andmore] you will mostly use the default package
+when you are feeling lazy or are making a smaller program.
+
+[^andmore]: And more to come!
\ No newline at end of file
diff --git a/src/packages/visibility.md b/src/packages/visibility.md
new file mode 100644
index 0000000..8439d44
--- /dev/null
+++ b/src/packages/visibility.md
@@ -0,0 +1,34 @@
+# Visibility
+
+By default, a class can only see the other classes 
+in its package.
+
+```java,no_run
+package dungeon;
+
+class BugBear {
+
+}
+```
+
+```java,no_run
+package village;
+
+class Villager {
+
+}
+```
+
+```java,no_run
+package dungeon;
+
+class Dwarf {
+    BugBear fight() {
+        // Can "see" BugBear and thus call its constructor,
+        // access visible fields and methods, etc.
+        return new BugBear();
+    }
+
+    // Cannot see Villager because it is in a different package.
+}
+```
\ No newline at end of file
diff --git a/src/rant.md b/src/rant.md
deleted file mode 100644
index e69de29..0000000
diff --git a/src/records.md b/src/records.md
new file mode 100644
index 0000000..8fb0e3c
--- /dev/null
+++ b/src/records.md
@@ -0,0 +1,8 @@
+# Records
+
+If you have a class whose only purpose is to ferry data around,
+you can instead use a `record`.
+
+```java
+record Person(String name, int age) {}
+```
\ No newline at end of file
diff --git a/src/records/check_for_equality.md b/src/records/check_for_equality.md
new file mode 100644
index 0000000..70d4cc1
--- /dev/null
+++ b/src/records/check_for_equality.md
@@ -0,0 +1,21 @@
+# Check for Equality
+
+To check if the components of a record match with another, you can use the `equals`
+method.
+
+```java
+record Elf(boolean pretentious) {}
+```
+```java
+~record Elf(boolean pretentious) {}
+class Main {
+    void main() {
+        var elfOne = new Elf(true);
+        var elfTwo = new Elf(true);
+        
+        System.out.println(elfOne.equals(elfTwo));
+    }
+}
+```
+
+This is similar to how you check whether `String`s are equal.
\ No newline at end of file
diff --git a/src/records/component_accessor_visibility.md b/src/records/component_accessor_visibility.md
new file mode 100644
index 0000000..488be93
--- /dev/null
+++ b/src/records/component_accessor_visibility.md
@@ -0,0 +1,22 @@
+# Component Accessor Visibility
+
+The accessor methods of a record are always public, so all the packages
+that can see the class can access its components.
+
+```java,no_run
+package dungeon;
+
+public record Dragon(double wingspan) {}
+```
+
+```java,no_run
+import dungeon.Dragon;
+
+void main() {
+    var dragon = new Dragon(224.5);
+    System.out.println(
+        // Method is visible.
+        dragon.wingspan()
+    );
+}
+```
\ No newline at end of file
diff --git a/src/records/component_accessors.md b/src/records/component_accessors.md
new file mode 100644
index 0000000..05910c9
--- /dev/null
+++ b/src/records/component_accessors.md
@@ -0,0 +1,24 @@
+# Component Accessors
+
+For each record component, an accessor
+method will be available that has the name of that component.
+
+You use these to access the values of components.
+
+```java,no_run
+record Dog(String name) {}
+```
+
+```java
+~record Dog(String name) {}
+class Main {
+    void main() {
+        var dog = new Dog("Hunter");
+
+        // .name() accessor is available
+        String name = dog.name();
+
+        System.out.println(name);
+    }
+}
+```
diff --git a/src/records/declaration.md b/src/records/declaration.md
new file mode 100644
index 0000000..0c19b0e
--- /dev/null
+++ b/src/records/declaration.md
@@ -0,0 +1,19 @@
+# Declaration
+
+To declare a record you write the word `record` followed by a
+class name, a list of "record components" in parentheses, and a pair of `{}`.
+
+The list of record components should be reminiscent of function arguments.
+
+```java
+record Person(String name, int age) {}
+```
+
+Having an empty list of record components is also allowed.[^astowhy]
+
+```java
+record Pants() {}
+```
+
+[^astowhy]: As to why you might want to give an empty list of record components,
+its nuanced. For now its just for fun.
\ No newline at end of file
diff --git a/src/records/printing_a_record.md b/src/records/printing_a_record.md
new file mode 100644
index 0000000..48ebc85
--- /dev/null
+++ b/src/records/printing_a_record.md
@@ -0,0 +1,29 @@
+# Printing a Record
+
+When printing out a record, the output will include
+each of the components of the record.
+
+```java
+record Goblin(String name, int hp) {}
+```
+```java
+~record Goblin(String name, int hp) {}
+class Main {
+    void main() {
+        var goblin = new Goblin("Gobbo", 11);
+
+        System.out.println(goblin);
+    }
+}
+```
+```
+Goblin[name=Gobbo, hp=11]
+```
+
+This is more intelligable than what you would get by default from a regular class.[^possible]
+
+```
+Goblin@609db43b
+```
+
+[^possible]: It is possible to make a regular class print differently, but we'll get to that later.
\ No newline at end of file
diff --git a/src/records/return_multiple_values.md b/src/records/return_multiple_values.md
new file mode 100644
index 0000000..e8e0028
--- /dev/null
+++ b/src/records/return_multiple_values.md
@@ -0,0 +1,28 @@
+# Return Multiple Values
+
+One of the initial reasons I gave for wanting to use a class
+was returning multiple values from a method.
+
+A record is likely better for that purpose than a regular class.
+
+```java
+record Location(double latitude, double longitude) {}
+
+Location findTreasureIsland() {
+    return new Location(40.2085, -3.713);
+}
+
+void main() {
+    Location treasureIsland = findTreasureIsland();
+    System.out.println(
+        "Treasure island is located at " +
+            location.latitude() +
+            " " +
+            location.longitude() +
+            "."
+    );
+}
+```
+
+Regular classes are, of course, still useful. Its just for classes which only
+hold some data together (and nothing else interesting) getting a constructor and accessors automatically is very convenient.
\ No newline at end of file
diff --git a/src/records/shorthand.md b/src/records/shorthand.md
new file mode 100644
index 0000000..920a55a
--- /dev/null
+++ b/src/records/shorthand.md
@@ -0,0 +1,40 @@
+# Shorthand
+
+One way to think about records is that they are "shorthand"[^nonnative]
+for a regular class.
+
+So the following record
+
+```java,no_run
+public record Cat(boolean spayed, int weight) {}
+```
+
+is shorthand for a regular class that looks like this.
+
+```java,no_run
+// There are a few parts that I left off here
+// so this isn't 100% accurate.
+public class Cat {
+    private final boolean spayed;
+    private final int weight;
+
+    public Cat(boolean spayed, int weight) {
+        this.spayed = spayed;
+        this.weight = weight;
+    }
+
+    public boolean spayed() {
+        return this.spayed;
+    }
+
+    public int weight() {
+        return this.weight;
+    }
+
+    // + the magic that makes it print nicer
+    // + the magic that lets you use .equals
+    // + a little more that will be relevant later
+}
+```
+
+[^nonnative]: For you non-native English speakers, a shorthand is a shortened form of something. TTYL is "shorthand" for "Talk to you later." 
\ No newline at end of file
diff --git a/src/records/the_canonical_constructor.md b/src/records/the_canonical_constructor.md
new file mode 100644
index 0000000..92a7eae
--- /dev/null
+++ b/src/records/the_canonical_constructor.md
@@ -0,0 +1,17 @@
+# The Canonical Constructor
+
+A record is always given a constructor which matches
+its list of record components.
+
+```java,no_run
+record Person(String name, int age) {}
+
+void main() {
+    // This call to new Person(...) matches up with 
+    // the record declaration.
+    var person = new Person("Ancient Dragon Man", 2000);
+}
+```
+
+Similar to the "default constructor" given to regular classes, this
+is what you get for "free" with the declaration of a record.
\ No newline at end of file
diff --git a/src/records/why.md b/src/records/why.md
new file mode 100644
index 0000000..110e6a0
--- /dev/null
+++ b/src/records/why.md
@@ -0,0 +1 @@
+# Why
diff --git a/src/retu b/src/retu
deleted file mode 100644
index abd5d47..0000000
--- a/src/retu
+++ /dev/null
@@ -1 +0,0 @@
-# void
diff --git a/src/standard_input.md b/src/standard_input.md
new file mode 100644
index 0000000..928a99a
--- /dev/null
+++ b/src/standard_input.md
@@ -0,0 +1,20 @@
+# Standard Input
+
+Programs are pretty boring if they just make a machine warm and do some math.
+
+There are a lot of ways to make a program interactive, but the easiest is to read
+from what is called "standard input."
+
+This function will be added to Java in a future version, but until then
+copy paste this at the very top of all the code in this section.
+
+```java,no_run
+import java.util.Scanner;
+
+Scanner scanner = new Scanner(System.in);
+
+String input(String message) {
+    System.out.print(message);
+    return scanner.nextLine();
+}
+```
\ No newline at end of file
diff --git a/src/standard_input/delayed_assignment.md b/src/standard_input/delayed_assignment.md
new file mode 100644
index 0000000..b6d5618
--- /dev/null
+++ b/src/standard_input/delayed_assignment.md
@@ -0,0 +1,91 @@
+# Delayed Assignment
+
+When you have variables declared inside of that loop cannot be seen from the outside.
+This poses a problem when you are asking someone a question in a loop but want their response to be
+visible later on in the program.
+
+One strategy for this is to declare any response-holding variables outside the loop.
+
+The problem with this is that Java isn't smart enough to know that you always initialize those variables.
+
+```java,no_run,does_not_compile
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String name;
+    while (true) {
+        String name = input("What is your name? ");
+        if (name.isBlank()) {
+            System.out.println("Name cannot be blank!");
+            continue;
+        }
+
+        break;
+    }
+
+    System.out.println("Hello " + name);
+}
+```
+
+To get around this you can either give an explicit default value.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String name = null;
+    while (true) {
+        String name = input("What is your name? ");
+        if (name.isBlank()) {
+            System.out.println("Name cannot be blank!");
+            continue;
+        }
+
+        break;
+    }
+
+    System.out.println("Hello " + name);
+}
+```
+
+Or you can use the `do` version of a while loop. 
+In this context our old friend delayed assignment becomes an option again. This is because Java *is* smart enough
+to see that the code in the loop will run at least once.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String name;
+    do {
+        String name = input("What is your name? ");
+        if (name.isBlank()) {
+            System.out.println("Name cannot be blank!");
+            continue;
+        }
+
+        break;
+    } while (true);
+
+    System.out.println("Hello " + name);
+}
+```
\ No newline at end of file
diff --git a/src/standard_input/interpreting_input.md b/src/standard_input/interpreting_input.md
new file mode 100644
index 0000000..657c9bd
--- /dev/null
+++ b/src/standard_input/interpreting_input.md
@@ -0,0 +1,28 @@
+# Interpreting Input
+
+When you call `input` the human on the other side can type whatever they want.
+
+This means that, depending on the question you asked, you might need to interpret
+what they typed as something other than a generic `String`.
+
+In its most basic form this will look like seeing if one `String` equals another `String`.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    while (true) {
+        String shouldExit = input("Exit the program? (y/n)");
+        if (shouldExit.equals("y")) {
+            break;
+        }
+    }
+}
+```
\ No newline at end of file
diff --git a/src/standard_input/leniency.md b/src/standard_input/leniency.md
new file mode 100644
index 0000000..61e97f9
--- /dev/null
+++ b/src/standard_input/leniency.md
@@ -0,0 +1,36 @@
+# Leniency
+
+It can make sense to be lenient with your users when interpreting their input.[^idiots]
+
+This means accounting for common mistakes people make like having extra spaces or capitalizing things incorrectly.
+
+For this purpose, methods like `strip` and `equalsIgnoreCase` are useful.
+
+```java,no_run
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    while (true) {
+        String response = input("Answer me: yes or no").strip();
+        if (response.equalsIgnoreCase("yes")) {
+            System.out.println("aight");
+        }
+        else if (response.equalsIgnoreCase("no")) {
+            System.out.println("cool");
+        }
+        else {
+            System.out.println("try again");
+            continue;
+        }
+
+        break;
+    }
+}
+```
+
+[^idiots]: People are idiots. Their fingers are fat and their wills are weak.
\ No newline at end of file
diff --git a/src/standard_input/prompting.md b/src/standard_input/prompting.md
new file mode 100644
index 0000000..d6595cf
--- /dev/null
+++ b/src/standard_input/prompting.md
@@ -0,0 +1,25 @@
+# input
+
+To prompt a user for information you use the `input` function.
+
+The `input` function takes a `String` to output as a prompt. This will
+work the same as if the `String` was passed to `System.out.print`.
+
+The program will then wait until a human types some text and clicks the enter key.
+Whatever they typed will be returned to the program as a `String`.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String name = input("What is your name? ");
+    System.out.println("Hello, " + name);
+}
+```
\ No newline at end of file
diff --git a/src/standard_input/reprompting.md b/src/standard_input/reprompting.md
new file mode 100644
index 0000000..54fe71c
--- /dev/null
+++ b/src/standard_input/reprompting.md
@@ -0,0 +1,38 @@
+# Reprompting
+
+If you ask someone a yes or no question and they respond with "huh?" you might want to ask them again.
+
+This is a good use case for loops. You ask a question and, if the answer you get is acceptable,
+you proceed as normal. If it is not then you loop back and ask again.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    while (true) {
+        String response = input("Answer me: yes or no");
+        if (response.equals("yes")) {
+            System.out.println("okay then!");
+        }
+        else if (response.equals("no")) {
+            System.out.println("also fine!");
+        }
+        else {
+            System.out.println("Not a valid response");
+            // Will go back to the top of the loop
+            continue;
+        }
+
+        // If a "continue" is not hit, exit the loop
+        break;
+    }
+}
+```
+
diff --git a/src/standard_input/transporting_data.md b/src/standard_input/transporting_data.md
new file mode 100644
index 0000000..af13954
--- /dev/null
+++ b/src/standard_input/transporting_data.md
@@ -0,0 +1,125 @@
+# Transporting Data
+
+If you ask someone multiple questions you likely will get multiple variables
+worth of information.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String firstName = input("What is your first name? ");
+    String lastName = input("What is your last name? ");
+
+    System.out.println("Hello " + firstName + " " + lastName + ".");
+}
+```
+
+This is fine and dandy so long as you immediately use those variables. But once you add in
+reprompting logic code can get pretty lengthy.
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+void main() {
+    String firstName;
+    do {
+        firstName = input("What is your first name? ");
+
+        if (firstName.isBlank()) {
+            System.out.println("First name cannot be blank.");
+        }
+
+        break;
+    } while (true);
+
+    String lastName;
+    do {
+        lastName = input("What is your first name? ");
+
+        if (lastName.isBlank()) {
+            System.out.println("First name cannot be blank.");
+        }
+
+        break;
+    } while (true);
+
+    System.out.println("Hello " + firstName + " " + lastName + ".");
+}
+```
+
+And once code gets lengthy it is sometimes useful to separate it into smaller functions.
+
+I mention all this as a reminder that when you want to return multiple values from a function
+you can use a class.[^dto]
+
+```java,no_run
+~import java.util.Scanner;
+~
+~Scanner scanner = new Scanner(System.in);
+~
+~String input(String message) {
+~    System.out.print(message);
+~    return scanner.nextLine();
+~}
+~
+class Person {
+    String firstName;
+    String lastName;
+
+    Person(String firstName, String lastName) {
+        this.firstName = firstName;
+        this.lastName = lastName;
+    }
+}
+
+Person askForName() {
+    String firstName;
+    do {
+        firstName = input("What is your first name? ");
+        
+        if (firstName.isBlank()) {
+            System.out.println("First name cannot be blank.");
+        }
+        
+        break;
+    } while (true);
+
+    String lastName;
+    do {
+        lastName = input("What is your first name? ");
+
+        if (lastName.isBlank()) {
+            System.out.println("First name cannot be blank.");
+        }
+
+        break;
+    } while (true);
+    
+    return new Person(firstName, lastName);
+}
+
+void main() {
+    Person person = askForName();
+
+    System.out.println("Hello " + person.firstName + " " + person.lastName + ".");
+}
+```
+
+
+
+[^dto]: When you make a class just to make objects which transfer data between different parts of your program we
+call those DTOs - data transfer objects. You will learn better ways to make DTOs in the future.
\ No newline at end of file
diff --git a/src/static_fields.md b/src/static_fields.md
new file mode 100644
index 0000000..3e05fc1
--- /dev/null
+++ b/src/static_fields.md
@@ -0,0 +1,10 @@
+# Static Fields
+
+To have a field be truly global for your program you can mark it as static.
+
+```java
+class Count {
+    static int value;
+}
+```
+
diff --git a/src/static_fields/constants.md b/src/static_fields/constants.md
new file mode 100644
index 0000000..cf3b01c
--- /dev/null
+++ b/src/static_fields/constants.md
@@ -0,0 +1,17 @@
+# Constants
+
+Because static fields are global to the entire program, they are the
+preferred mechanism for storing "constants."
+
+Constants are things that you don't expect to change, so you would also
+mark such fields as `final`.
+
+```java
+class MathConstants {
+    static final double PI = 3.14;
+}
+
+// Then in other parts of your code you can reference MathConstants.PI
+```
+
+
diff --git a/src/static_fields/controversy.md b/src/static_fields/controversy.md
new file mode 100644
index 0000000..3871458
--- /dev/null
+++ b/src/static_fields/controversy.md
@@ -0,0 +1,27 @@
+# Controversy
+
+Static fields are culturally controversial. Specifically static fields
+which can change.
+
+```java
+class Counter {
+    static int value = 0;
+}
+```
+
+In the example above, any part of the code can change the value at any time by writing to `Counter.value`.
+
+This is "fine" in small to mid-sized programs, but once you have a hundred thousand lines
+it can become difficult to reason about what code changes that field and when.
+
+For this reason[^and] you will probably get a lot of mean comments if you share code that uses a static field you can change.
+
+Using static fields for constants is less controverial.
+
+```java
+class Constants {
+    static final int DAYS_IN_A_WEEK = 7;
+}
+```
+
+[^and]: Well, in addition to the generally rampant immaturity of programmers.
\ No newline at end of file
diff --git a/src/static_fields/declaration.md b/src/static_fields/declaration.md
new file mode 100644
index 0000000..01f9bb7
--- /dev/null
+++ b/src/static_fields/declaration.md
@@ -0,0 +1,10 @@
+# Declaration
+
+To declare a field as static, add the `static` keyword to its declaration.
+
+```java
+class Count {
+    static int value;
+}
+```
+
diff --git a/src/static_fields/initialization.md b/src/static_fields/initialization.md
new file mode 100644
index 0000000..e637bed
--- /dev/null
+++ b/src/static_fields/initialization.md
@@ -0,0 +1,57 @@
+# Initialization
+
+By default, static fields will be given the same default initial value as other fields.
+
+So a static `int` field will be initialized to zero, a static `String` field
+will be initialized to `null`, etc.
+
+```java
+class Main {
+    static int count;
+    static String name;
+
+    void main() {
+        System.out.println(count); // 0
+        System.out.println(name); // null
+    }
+}
+```
+
+If you want to initialize them to a different value you do not do that in a constructor
+like you would a normal field. 
+
+You can give them a value directly with `=`.
+
+```java
+class Main {
+    static int count = 5;
+    static String name = "bob";
+
+    void main() {
+        System.out.println(count); // 0
+        System.out.println(name); // null
+    }
+}
+```
+
+Or you can initialize them in a "static block". This looks like the word `static`
+followed by some braces `{}` with code in the middle.[^confusing]
+
+```java
+class Main {
+    static int count;
+    static String name;
+
+    static {
+        count = 5;
+        name = "bob";
+    }
+
+    void main() {
+        System.out.println(count); // 0
+        System.out.println(name); // null
+    }
+}
+```
+
+[^confusing]: The rules for static blocks are actually crazy complicated. Try not to do anything "interesting" in them.
\ No newline at end of file
diff --git a/src/static_fields/meaning.md b/src/static_fields/meaning.md
new file mode 100644
index 0000000..471d788
--- /dev/null
+++ b/src/static_fields/meaning.md
@@ -0,0 +1 @@
+# Meaning
diff --git a/src/static_fields/naming.md b/src/static_fields/naming.md
new file mode 100644
index 0000000..7b27895
--- /dev/null
+++ b/src/static_fields/naming.md
@@ -0,0 +1,22 @@
+# Naming
+
+For static final fields people generally name them the same way you would an enum - `LIKE_THIS`.
+
+```java
+class Constants {
+    static final int DAYS_IN_A_WEEK = 7;
+    static final int WEEKS_IN_A_YEAR = 52;
+}
+```
+
+Because you will get yelled at for using a non-final static field no matter what you do, the rules there are less strict. You can name them in all caps or like a normal variable
+depending on personal preference.
+
+```java
+class Counter {
+    // The people who would be mad at you for the first
+    // will probably already be mad at you for the second.
+    static int value = 0;
+    static int VALUE = 0;
+}
+```
\ No newline at end of file
diff --git a/src/static_fields/usage.md b/src/static_fields/usage.md
new file mode 100644
index 0000000..5cf5cb6
--- /dev/null
+++ b/src/static_fields/usage.md
@@ -0,0 +1,27 @@
+# Usage
+
+To use a static field within the class it is declared you just need to write the name of the field.
+
+```java
+class Main {
+    static int count = 0;
+
+    void main() {
+        System.out.println(count);
+    }
+}
+```
+
+To use it from another class or to disambiguate it from a regular field with the same
+name, you should prefix it with the name of the class it is declared in plus a `.`.
+
+
+```java
+class Main {
+    static int count = 0;
+
+    void main() {
+        System.out.println(Main.count);
+    }
+}
+```
\ No newline at end of file
diff --git a/src/static_methods.md b/src/static_methods.md
new file mode 100644
index 0000000..7a1ee48
--- /dev/null
+++ b/src/static_methods.md
@@ -0,0 +1,25 @@
+# Static Methods
+
+If you want to be able to call a method from anywhere in your program you
+can use a `static` method.
+
+```java,no_run
+class MyMath {
+    static int add(int a, int b) {
+        return a + b;
+    }
+}
+```
+```java
+~class MyMath {
+~    static int add(int a, int b) {
+~        return a + b;
+~    }
+~}
+class Main {
+    void main() {
+        int result = MyMath.add(1, 2);
+        System.out.println(result);
+    }
+}
+```
\ No newline at end of file
diff --git a/src/static_methods/declaration.md b/src/static_methods/declaration.md
new file mode 100644
index 0000000..a73c34a
--- /dev/null
+++ b/src/static_methods/declaration.md
@@ -0,0 +1,12 @@
+# Declaration
+
+Same as `static` fields, to mark a method as `static` you write the word `static`
+before it.
+
+```java,no_run
+class MyMath {
+    static int add(int a, int b) {
+        return a + b;
+    }
+}
+```
\ No newline at end of file
diff --git a/src/static_methods/factories.md b/src/static_methods/factories.md
new file mode 100644
index 0000000..7ce98b6
--- /dev/null
+++ b/src/static_methods/factories.md
@@ -0,0 +1,119 @@
+# Factories
+
+Another interesting use of static methods is what we would call a "factory"
+method.
+
+Say you have a class like the following.
+
+```java
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+}
+~void main() {}
+```
+
+It would be reasonable want to add an overloaded constructor for when `y` is `0`.
+
+```java
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    Position(int x) {
+        this.x = x;
+        this.y = 0;
+    }
+}
+~void main() {}
+```
+
+But now it is impossible to add a constructor that works for when `x` is `0`.
+
+```java,does_not_compile
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    Position(int x) {
+        this.x = x;
+        this.y = 0;
+    }
+
+    Position(int y) {
+        this.x = 0;
+        this.y = y;
+    }
+}
+~void main() {}
+```
+
+Using a static method to create a `Position` - i.e. as a "factory" - is a way around the issue.[^note]
+
+```java,does_not_compile
+class Position {
+    int x;
+    int y;
+
+    Position(int x, int y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    static Position fromX(int x) {
+        return new Position(x, 0);
+    }
+
+    static Position fromY(int y) {
+        return new Position(0, y);
+    }
+}
+```
+```java
+~class Position {
+~    int x;
+~    int y;
+~
+~    Position(int x, int y) {
+~        this.x = x;
+~        this.y = y;
+~    }
+~
+~    static Position fromX(int x) {
+~        return new Position(x, 0);
+~    }
+~
+~    static Position fromY(int y) {
+~        return new Position(0, y);
+~    }
+~}
+~
+class Main {
+    void main() {
+        var p1 = new Position(1, 2);
+        var p2 = Position.fromX(4);
+        var p3 = Position.fromY(5);
+
+        System.out.println(p1.x + ", " + p1.y);
+        System.out.println(p2.x + ", " + p2.y);
+        System.out.println(p3.x + ", " + p3.y);
+    }
+}
+```
+
+[^note]: This won't work if you defined `Position` inside the anonymous main class. I'll tell you why later.
\ No newline at end of file
diff --git a/src/static_methods/math.md b/src/static_methods/math.md
new file mode 100644
index 0000000..4ada1db
--- /dev/null
+++ b/src/static_methods/math.md
@@ -0,0 +1,20 @@
+# Math
+
+One of the most "obvious" usages for static methods is when doing things
+that are math or math-like.
+
+```java,no_run
+class MyMath {
+    static int add(int a, int b) {
+        return a + b;
+    }
+}
+```
+
+These sorts of methods have a result computed solely from their inputs, so needing
+an instance of a class to call them would be silly.
+
+The `Math` class that comes with Java has methods that work in this way. `Math.max(a, b)`
+is `static` and therefore usable everywhere you want the maximum of two numbers.[^more]
+
+[^more]: There are way more on there. [Take a look](https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/lang/Math.html).
\ No newline at end of file
diff --git a/src/static_methods/naming.md b/src/static_methods/naming.md
new file mode 100644
index 0000000..9b39c19
--- /dev/null
+++ b/src/static_methods/naming.md
@@ -0,0 +1,12 @@
+# Naming
+
+Unlike static fields, which get new socially accepted naming rules,
+you name static methods the same as any other method.
+
+```java
+class Naming {
+    static void nameLikeNormal() {
+
+    }
+}
+```
\ No newline at end of file
diff --git a/src/static_methods/scope.md b/src/static_methods/scope.md
new file mode 100644
index 0000000..3852c42
--- /dev/null
+++ b/src/static_methods/scope.md
@@ -0,0 +1,36 @@
+# Scope
+
+In the definition of a static method you can use variables like normal
+and you can reference other static fields and methods.
+
+```java,no_run
+class ScopeExample {
+    static final int CAN_ACCESS = 3.14;
+
+    static void canCall() {
+    }
+
+    static void doStuff() {
+        canCall();
+        System.out.println(ScopeExample.CAN_ACCESS);
+    }
+}
+```
+
+But you cannot access any non-static methods or fields. They are not in scope.
+
+```java,no_run,does_not_compile
+class ScopeExample2 {
+    final int CANNOT_ACCESS = 3.14;
+
+    void cannotCall() {
+    }
+
+    static void doStuff() {
+        cannotCall();
+        System.out.println(
+            CANNOT_ACCESS
+        );
+    }
+}
+```
diff --git a/src/static_methods/usage.md b/src/static_methods/usage.md
new file mode 100644
index 0000000..65ee21b
--- /dev/null
+++ b/src/static_methods/usage.md
@@ -0,0 +1,24 @@
+# Usage
+
+You use a static method by writing the name of the class where it is
+defined followed by `.` and the method name.
+
+```java
+class StuffDoer {
+    static void doStuff() {
+        System.out.println("Doing stuff");
+    }
+}
+```
+
+```java
+~class StuffDoer {
+~    static void doStuff() {
+~        System.out.println("Doing stuff");
+~    }
+~}
+~
+void main() {
+    StuffDoer.doStuff();
+}
+```
\ No newline at end of file
diff --git a/src/string_builder.md b/src/string_builder.md
new file mode 100644
index 0000000..e47ec59
--- /dev/null
+++ b/src/string_builder.md
@@ -0,0 +1,19 @@
+# StringBuilder
+
+When you add `String`s together, the result is a new `String`.
+
+```java
+void main() {
+    String a = "a";
+    String b = "b";
+    String ab = a + b;
+
+    System.out.println(ab);
+}
+```
+
+This is perfectly fine and what you would expect, but if you are adding strings
+together in a loop it can become an issue.
+
+```java
+```
\ No newline at end of file
diff --git a/src/stringbuilder.md b/src/stringbuilder.md
new file mode 100644
index 0000000..0886a44
--- /dev/null
+++ b/src/stringbuilder.md
@@ -0,0 +1,47 @@
+# StringBuilder
+
+`String`s cannot be changed in place. This means that every operation
+on a `String` needs to produce a brand new `String` as a result.
+
+Normally this is fine, but when you do something like that in a loop
+it can become a performance problem.
+
+```java
+String removeAllNumbers(String input) {
+    String result = "";
+    for (int i = 0; i < input.length(); i++) {
+        char c = input.charAt(i);
+        if (c < '0' || c > '9') {
+            result = result + c;
+        }
+    }
+    return result;
+}
+
+void main() {
+    String screenplay = "5".repeat(1000000);
+    // There are 1301 characters in the above text, meaning this method
+    // does around that many copies of the string
+    System.out.println(removeAllNumbers(screenplay));
+}
+```
+
+```java
+String removeAllNumbers(String input) {
+    StringBuilder result = new StringBuilder();
+    for (int i = 0; i < input.length(); i++) {
+        char c = input.charAt(i);
+        if (c < '0' || c > '9') {
+            result.append(c);
+        }
+    }
+    return result.toString();
+}
+
+void main() {
+    String screenplay = "5".repeat(1000000);
+    // There are 1301 characters in the above text, meaning this method
+    // does around that many copies of the string
+    System.out.println(removeAllNumbers(screenplay));
+}
+```
\ No newline at end of file
diff --git a/src/strings/challenges.md b/src/strings/challenges.md
index 2a115a2..51d9fde 100644
--- a/src/strings/challenges.md
+++ b/src/strings/challenges.md
@@ -43,7 +43,7 @@ void main() {
     String second = "b";
     String third = "ab";
 
-    System.out.println((first + second).equals(second));
+    System.out.println((first + second).equals(third));
 }
 ```
 
diff --git a/src/strings/length.md b/src/strings/length.md
index 75d0955..768a6eb 100644
--- a/src/strings/length.md
+++ b/src/strings/length.md
@@ -9,7 +9,7 @@ int numberOfChars = fruit.length();
 
 // strawberry is 10 characters long
 System.out.println(
-    fruit + " is " numberOfChars + " characters long"
+    fruit + " is " + numberOfChars + " characters long"
 );
 ~}
 ```
diff --git a/src/strings_ii.md b/src/strings_ii.md
index 981c15d..2fb9ac7 100644
--- a/src/strings_ii.md
+++ b/src/strings_ii.md
@@ -1 +1,7 @@
 # Strings II
+
+If you haven't already, you will eventually realize that `String`s are
+one of the most common data types you will use.
+
+As such, its worth it to keep revisiting the things you can do with them.
+Expect more sections like this the deeper you get.
\ No newline at end of file
diff --git a/src/strings_ii/UPPERCASE.md b/src/strings_ii/UPPERCASE.md
new file mode 100644
index 0000000..8d44eb3
--- /dev/null
+++ b/src/strings_ii/UPPERCASE.md
@@ -0,0 +1,15 @@
+# UPPERCASE
+
+Similarly, if you have a `String` which potentially contains lower-cased letters, you can get a new `String` with everything
+transformed into lower-case using the `.toUpperCase()` method.
+
+```java
+void main() {
+    String message = "Happy Valentines Day";
+
+    String upperCased = message.toUpperCase();
+    System.out.println(upperCased);
+}
+```
+
+This does not change the original `String` in place. It just makes a new `String` with all upper-case letters.
\ No newline at end of file
diff --git a/src/strings_ii/check_if_blank.md b/src/strings_ii/check_if_blank.md
new file mode 100644
index 0000000..7feff4c
--- /dev/null
+++ b/src/strings_ii/check_if_blank.md
@@ -0,0 +1,23 @@
+# Check if blank
+
+You can check if a `String` is blank by using the `.isBlank` method.
+
+The difference is that an empty `String` has actually zero characters. A blank `String`
+is can have characters, so long as those characters are what we would consider whitespace.
+That is, things like spaces and newlines.
+
+```java
+void main() {
+    String brainSounds = """
+              
+             
+
+        """;
+
+    // false
+    System.out.println(brainSounds.isEmpty());
+
+    // true
+    System.out.println(brainSounds.isBlank());
+}
+```
\ No newline at end of file
diff --git a/src/strings_ii/check_if_empty.md b/src/strings_ii/check_if_empty.md
new file mode 100644
index 0000000..5060647
--- /dev/null
+++ b/src/strings_ii/check_if_empty.md
@@ -0,0 +1,30 @@
+# Check if empty
+
+You can check if a `String` is empty in a few ways.
+
+The one you should already have been able to figure out[^noshame] is that you can get the `.length` of a `String`
+and see if that is zero.
+
+```java
+void main() {
+    String textMessages = "";
+    System.out.println(
+        textMessages.length() == 0
+    );
+}
+```
+
+But another is to use the explicitly defined `.isEmpty()` method.
+
+```java
+void main() {
+    String textMessages = "";
+    System.out.println(
+        textMessages.isEmpty()
+    );
+}
+```
+
+This can be more convenient. Both to write, as it is fewer characters to type, and to read later on.
+
+[^noshame]: Again, no shame if not. I didn't exactly call attention to it.
\ No newline at end of file
diff --git a/src/strings_ii/equality_ignoring_case.md b/src/strings_ii/equality_ignoring_case.md
new file mode 100644
index 0000000..b5d3af2
--- /dev/null
+++ b/src/strings_ii/equality_ignoring_case.md
@@ -0,0 +1,19 @@
+# Equality ignoring case
+
+If you want to check if two `String`s contain the same contents
+but you do not care if those contents differ in the casing of letters, you can use the `.equalsIgnoreCase`
+method.
+
+```java
+void main() {
+    String historicalFigureOne = "St. Valentines";
+    String historicalFigureTwo = "st. valentines";
+
+    System.out.println(
+        historicalFigureOne.equalsIgnoreCase(historicalFigureTwo)
+    );
+}
+```
+
+This is different from the result the `.equals` method will give you. That method will return `false` if there
+are any differences in the two `String`s.
\ No newline at end of file
diff --git a/src/strings_ii/lowercase.md b/src/strings_ii/lowercase.md
new file mode 100644
index 0000000..cbc5585
--- /dev/null
+++ b/src/strings_ii/lowercase.md
@@ -0,0 +1,21 @@
+# lowercase
+
+In English[^otherlangs] letters can be either lower-cased (`a`, `b`, `c`) or upper-cased (`A`, `B`, `C`).
+
+If you have a `String` which potentially contains upper-cased letters, you can get a new `String` with everything
+transformed into lower-case using the `.toLowerCase()` method.
+
+```java
+void main() {
+    String message = "Happy Valentines Day";
+
+    String lowerCased = message.toLowerCase();
+    System.out.println(lowerCased);
+}
+```
+
+This does not change the original `String` in place. It just makes a new `String` with all lower-case letters.
+
+
+[^otherlangs]: Other languages also have a notion of case. I am not a polyglot though, so I'm not qualified
+to talk about them.
\ No newline at end of file
diff --git a/src/strings_ii/strip_extra_whitespace.md b/src/strings_ii/strip_extra_whitespace.md
new file mode 100644
index 0000000..424aa82
--- /dev/null
+++ b/src/strings_ii/strip_extra_whitespace.md
@@ -0,0 +1,39 @@
+# Strip extra whitespace
+
+If you have a `String` which might contains some extra "trailing" whitespace or extra "leading"
+whitespace, you can remove that by using the `.strip` method.
+
+This will give a new `String` with both the leading and trailing whitespace removed.
+
+```java
+void main() {
+    String message = "   Happy Valentines Day.   ";
+
+    System.out.print(message.strip());
+    System.out.println("|");
+}
+```
+
+If you want to just remove the leading whitespace, you can use `.stripLeading`.
+
+```java
+void main() {
+    String message = "   Happy Valentines Day.   ";
+
+    System.out.print(message.stripLeading());
+    System.out.println("|");
+}
+```
+
+And to remove only trailing whitespace, `.stripTrailing`.
+
+```java
+void main() {
+    String message = "   Happy Valentines Day.   ";
+
+    System.out.print(message.stripTrailing());
+    System.out.println("|");
+}
+```
+
+All of these methods are useful when you get input from human beings. Humans are generally pretty bad at seeing if they hit the spacebar one too many times.
\ No newline at end of file
diff --git a/src/switch_ii.md b/src/switch_ii.md
new file mode 100644
index 0000000..d80dac4
--- /dev/null
+++ b/src/switch_ii.md
@@ -0,0 +1,39 @@
+# Switch II
+
+A common thing to do is have a `switch` statement which assigns a value
+to a variable in each branch.
+
+```java
+enum StopLight {
+    RED,
+    YELLOW,
+    GREEN
+}
+
+enum Action {
+    STOP,
+    SLOW_DOWN,
+    GO
+}
+
+void main() {
+    StopLight light = StopLight.GREEN;
+
+    Action action = null; // Delayed assignment rules are funky here.
+    switch (light) {
+        case RED -> {
+            action = Action.STOP;
+        }
+        case YELLOW -> {
+            action = Action.SLOW_DOWN;
+        }
+        case GREEN -> {
+            action = Action.GO;
+        }
+    }
+
+    System.out.println(action);
+}
+```
+
+For this purpose, you can instead use a switch "as an expression."
\ No newline at end of file
diff --git a/src/switch_ii/exhaustive_switches_with_enums.md b/src/switch_ii/exhaustive_switches_with_enums.md
new file mode 100644
index 0000000..4796976
--- /dev/null
+++ b/src/switch_ii/exhaustive_switches_with_enums.md
@@ -0,0 +1 @@
+# Exhaustive Switches with Enums
diff --git a/src/switch_ii/exhaustive_switches_with_strings.md b/src/switch_ii/exhaustive_switches_with_strings.md
new file mode 100644
index 0000000..87fa738
--- /dev/null
+++ b/src/switch_ii/exhaustive_switches_with_strings.md
@@ -0,0 +1 @@
+# Exhaustive Switches with Strings
diff --git a/src/switch_ii/exhaustiveness.md b/src/switch_ii/exhaustiveness.md
new file mode 100644
index 0000000..98c7409
--- /dev/null
+++ b/src/switch_ii/exhaustiveness.md
@@ -0,0 +1,30 @@
+# Exhaustiveness
+
+When a switch is used as an expression it needs to be exhaustive.
+
+```java
+~void main() {
+String name = "bob";
+
+boolean cool = switch (name) {
+    case "bob" -> false;
+    default -> true;
+};
+
+System.out.println(cool);
+~}
+```
+
+If you attempt to make a non-exhaustive switch expression, Java will not let you.
+
+```java,does_not_compile
+~void main() {
+String name = "bob";
+
+boolean cool = switch (name) {
+    case "bob" -> false;
+};
+
+System.out.println(cool);
+~}
+```
diff --git a/src/switch_ii/omitted_yield.md b/src/switch_ii/omitted_yield.md
new file mode 100644
index 0000000..bec23b9
--- /dev/null
+++ b/src/switch_ii/omitted_yield.md
@@ -0,0 +1,61 @@
+# Omitted Yield
+
+If a branch of a switch just yields a value but does nothing else interesting you can
+omit the `yield` along with the surrounding `{` and `}`.
+
+```java
+~enum StopLight {
+~    RED,
+~    YELLOW,
+~    GREEN
+~}
+~
+~enum Action {
+~    STOP,
+~    SLOW_DOWN,
+~    GO
+~}
+~
+~void main() {
+StopLight light = StopLight.GREEN;
+
+Action action = switch (light) {
+    case RED -> Action.STOP;
+    case YELLOW -> Action.SLOW_DOWN;
+    case GREEN -> Action.GO;
+};
+
+System.out.println(action);
+~}
+```
+
+Which can be mixed with cases that have explicit `yield`s and might do other things.
+
+```java
+~enum StopLight {
+~    RED,
+~    YELLOW,
+~    GREEN
+~}
+~
+~enum Action {
+~    STOP,
+~    SLOW_DOWN,
+~    GO
+~}
+~
+void main() {
+    StopLight light = StopLight.GREEN;
+
+    Action action = switch (light) {
+        case RED -> Action.STOP;
+        case YELLOW -> {
+            System.out.println("Lemon Light!");
+            yield Action.SLOW_DOWN;
+        }
+        case GREEN -> Action.GO;
+    };
+
+    System.out.println(action);
+}
+```
\ No newline at end of file
diff --git a/src/switch_ii/return_a_switch.md b/src/switch_ii/return_a_switch.md
new file mode 100644
index 0000000..877bfaf
--- /dev/null
+++ b/src/switch_ii/return_a_switch.md
@@ -0,0 +1,19 @@
+# Return a Switch
+
+If you choose to, you do not need to assign the result of a switch expression into a variable. You can directly return the result from a method.
+
+```java,no_run
+enum Bird {
+    TURKEY,
+    EAGLE,
+    WOODPECKER
+}
+
+boolean isScary(Bird bird) {
+    return switch (bird) {
+        case TURKEY -> true;
+        case EAGLE -> true;
+        case WOODPECKER -> false;
+    };
+}
+```
\ No newline at end of file
diff --git a/src/switch_ii/yield.md b/src/switch_ii/yield.md
new file mode 100644
index 0000000..0d05ad6
--- /dev/null
+++ b/src/switch_ii/yield.md
@@ -0,0 +1,39 @@
+# Yield
+
+To use a "switch expression" you put the entire switch to the right hand side of an equals sign[^context] and, instead of assigning to a variable, you "`yield`" the value you want to assign.
+
+```java
+enum StopLight {
+    RED,
+    YELLOW,
+    GREEN
+}
+
+enum Action {
+    STOP,
+    SLOW_DOWN,
+    GO
+}
+
+void main() {
+    StopLight light = StopLight.GREEN;
+
+    Action action = switch (light) {
+        case RED -> {
+            yield Action.STOP;
+        }
+        case YELLOW -> {
+            yield Action.SLOW_DOWN;
+        }
+        case GREEN -> {
+            yield Action.GO;
+        }
+    };
+
+    System.out.println(action);
+}
+```
+
+`yield` is very similar to `return`. The difference is that `return` will exit the entire method. `yield` just decides what the switch evaluates to.
+
+[^context]: Technically we are talking about an "expression context." Meaning a place where you are allowed to put an expression. The right hand side of an equals sign is one, but there are many others.
\ No newline at end of file
diff --git a/src/the_terminal.md b/src/the_terminal.md
new file mode 100644
index 0000000..89321f3
--- /dev/null
+++ b/src/the_terminal.md
@@ -0,0 +1,7 @@
+# The Terminal
+
+Early computers didn't have graphical interfaces with windows or buttons you could "click."
+Instead, they offered a text based interface.
+
+We call this sort of interface a "terminal," though you might hear the terms "shell"
+and "terminal emulator" used interchangibly.
diff --git a/src/the_terminal/bash.md b/src/the_terminal/bash.md
new file mode 100644
index 0000000..f695d1f
--- /dev/null
+++ b/src/the_terminal/bash.md
@@ -0,0 +1,8 @@
+# Bash
+
+If you are programming on a computer running either Mac or Linux you should have easy access
+to a bash terminal. Just search your applications for something called "terminal" or that has the word "term" in it.
+
+This is the most common kind of terminal for working professionals to use.[^asterisk]
+
+[^asterisk]: Asterisks apply, of course. I didn't run or try to find a survey so this is mostly anecdotal.
\ No newline at end of file
diff --git a/src/the_terminal/changing_directories.md b/src/the_terminal/changing_directories.md
new file mode 100644
index 0000000..ae15af6
--- /dev/null
+++ b/src/the_terminal/changing_directories.md
@@ -0,0 +1,25 @@
+# Changing Directories
+
+You can change what your working directory is using the `cd` command.
+
+After the name of the command, you write the name of the directory you want to change in to.
+
+```bash
+$ pwd
+/Users/emccue
+$ cd Downloads
+$ pwd
+/Users/emccue/Downloads
+```
+
+If you want to go to a "parent" directory, you can write `..`. This means "one directory up".
+
+```bash
+$ pwd
+/Users/emccue
+$ cd ..
+$ pwd
+/Users
+```
+
+[^cd]: Short for "change directory"
\ No newline at end of file
diff --git a/src/the_terminal/chromebooks_and_school_computers.md b/src/the_terminal/chromebooks_and_school_computers.md
new file mode 100644
index 0000000..7a20a51
--- /dev/null
+++ b/src/the_terminal/chromebooks_and_school_computers.md
@@ -0,0 +1,12 @@
+# Chromebooks and School Computers
+
+A very common thing that school systems will do is prevent students from accessing a terminal.
+
+This is a good thing if your goal is to prevent high schoolers from committing shenanigans. Less so if your goal is to learn how to program.
+
+There are also computer types, like chromebooks, which aren't really built with programming in mind. While you could access a terminal, the sorts of programs you would generally install to
+work with Java will be out of reach. It's a similar case for things like iPads.
+
+If you are in one of these situations I would reccomend getting a "normal" computer if at all possible. You can make do for a time, but eventually it will be required to continue in this field.[^thems]
+
+[^thems]: Thems the ropes, kid. 🤷
\ No newline at end of file
diff --git a/src/the_terminal/commands.md b/src/the_terminal/commands.md
new file mode 100644
index 0000000..fc727a3
--- /dev/null
+++ b/src/the_terminal/commands.md
@@ -0,0 +1,13 @@
+# Commands
+
+The primary way you interact with a terminal is by running commands.
+
+You start with a blank prompt and write something like the following.
+
+```bash
+$ echo Hello
+Hello
+```
+
+The first word is the name of the program to run. In this case `echo`. Everything after
+that is an "argument" to the program.
\ No newline at end of file
diff --git a/src/the_terminal/creating_directories.md b/src/the_terminal/creating_directories.md
new file mode 100644
index 0000000..368f66d
--- /dev/null
+++ b/src/the_terminal/creating_directories.md
@@ -0,0 +1,11 @@
+# Creating Directories
+
+In order to create a directory you can use the `mkdir`[^mkdir] command.
+
+```bash
+$ mkdir project
+$ ls
+project
+```
+
+[^mkdir]: Make Directory. 
\ No newline at end of file
diff --git a/src/the_terminal/creating_files.md b/src/the_terminal/creating_files.md
new file mode 100644
index 0000000..54069e2
--- /dev/null
+++ b/src/the_terminal/creating_files.md
@@ -0,0 +1,19 @@
+# Creating Files
+
+To create a blank file you can use the `touch`[^no_clue] command.
+
+```bash
+$ touch hello.txt
+```
+
+This is situationally useful, but more often than not you will create files
+using a program called a "text editor."
+
+There are some text editors, like [`vim`](https://www.vim.org/), which run entirely
+inside the terminal.[^diehard]
+
+One of the more popular ones at time of writing is [Visual Studio Code](https://code.visualstudio.com/). If you weren't otherwise shown a different option, that is a decent default. Install it and then you can use it to create and edit files.
+
+[^no_clue]: I have no clue why this is called `touch`.
+[^diehard]: These have their die hard supporters. The lunatics.
+[^thisbook]: This book has been written inside Visual Studio Code.
diff --git a/src/the_terminal/directories.md b/src/the_terminal/directories.md
new file mode 100644
index 0000000..ea7c559
--- /dev/null
+++ b/src/the_terminal/directories.md
@@ -0,0 +1,15 @@
+# Directories
+
+Directories, also known as folders, are the places where files are in a computer.
+
+When you open a terminal, you are "inside" a particular directory.
+
+You can see the directory you are in by running the `pwd`[^pwd] command.
+
+```bash
+$ pwd
+/Users/emccue
+```
+
+
+[^pwd]: "Print Working Directory"
\ No newline at end of file
diff --git a/src/the_terminal/getting_used_to_it.md b/src/the_terminal/getting_used_to_it.md
new file mode 100644
index 0000000..d80f56d
--- /dev/null
+++ b/src/the_terminal/getting_used_to_it.md
@@ -0,0 +1,8 @@
+# Getting Used to it
+
+So far this is only a shallow dive. It will take a good amount of time for you to get
+comfortable using the terminal for things.
+
+Thats normal. You'll get there eventually. Just know that at least some familiarity with the terminal is going to be needed.
+
+We'll get back to it relatively soon, but feel free to seek out some bash/terminal specific resources online in the meantime.
\ No newline at end of file
diff --git a/src/the_terminal/java_programs.md b/src/the_terminal/java_programs.md
new file mode 100644
index 0000000..f4ad9fd
--- /dev/null
+++ b/src/the_terminal/java_programs.md
@@ -0,0 +1 @@
+# Run Java Programs
diff --git a/src/the_terminal/listing_files.md b/src/the_terminal/listing_files.md
new file mode 100644
index 0000000..c5b03b9
--- /dev/null
+++ b/src/the_terminal/listing_files.md
@@ -0,0 +1,18 @@
+# Listing Files
+
+You can list the files in your current working directory with the `ls`[^ls] command.
+
+```bash
+$ ls
+Applications
+Camera
+Desktop
+Development
+Documents
+Downloads
+```
+
+This is useful for getting your bearings, but also to find a file you forget the name of or similar.
+
+
+[^ls]: Short for "List"
diff --git a/src/the_terminal/run_java_programs.md b/src/the_terminal/run_java_programs.md
new file mode 100644
index 0000000..2259cf6
--- /dev/null
+++ b/src/the_terminal/run_java_programs.md
@@ -0,0 +1,32 @@
+# Run Java Programs
+
+If you've properly set up Java on your machine you should be able to use the `java` command
+to run any code on your machine.
+
+Just write `java` followed by the path to a file containing Java code.[^eventually]
+
+Say we had this code in a file named `Main.java`
+
+```java
+void main() {
+    System.out.println("Hello");
+}
+```
+
+To run this, say `java Main.java`.
+
+```bash
+$ java Main.java
+Hello
+```
+
+If the file is in a directory that is not your current working directory, you 
+should include the full path.
+
+```bash
+$ java src/Main.java
+Hello
+```
+
+[^eventually]: You can get away with just using your editor's run button for awhile, but this 
+will eventually become important to know.
\ No newline at end of file
diff --git a/src/the_terminal/windows_subsystem_for_linux.md b/src/the_terminal/windows_subsystem_for_linux.md
new file mode 100644
index 0000000..aafbf94
--- /dev/null
+++ b/src/the_terminal/windows_subsystem_for_linux.md
@@ -0,0 +1,10 @@
+# Windows Subsystem for Linux
+
+If you are using Windows there are two terminals that come preinstalled. One is `cmd.exe`, where
+you write in a language called batch, and the other is "PowerShell."
+
+Both of these differ in significant ways from bash so, if at all possible, you should get set up with the [Windows Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/about).
+
+This will let you follow along with the bash snippets you'll see later in this book.[^other_shells]
+
+[^other_shells]: It is certainly possible for me to also include instruction for PowerShell and batch but it doesn't feel practical. I spend most of my working hours using batch and can test commands on the machine I use to write this. It would be hard for me to do that with the Windows specific shells
\ No newline at end of file
diff --git a/src/variables.md b/src/variables.md
index ceb1822..5c9294e 100644
--- a/src/variables.md
+++ b/src/variables.md
@@ -12,7 +12,6 @@ void main() {
 
 A variable declaration has three components - the "type", the "name", and the "initial value".
 
-```java,no_run
 ```java,no_run
      String boss = "Jaqueline";
 //   type   name   initial value
diff --git a/src/variables/naming.md b/src/variables/naming.md
index 2c280ee..7c23ae4 100644
--- a/src/variables/naming.md
+++ b/src/variables/naming.md
@@ -11,10 +11,10 @@ String apple = "Red Delicious";
 If it is multiple words, the first word should be lowercase
 and the others should start with a capital letter.
 
-This convention is called `camelCase` because the capitals looks like the humps on a Camels back[^camel].
+This convention is called `camelCase` because the capitals looks like the humps on a Camels back.
 
 Just like proper formatting, sticking to this style will increase your chances of
 someone online being able to help you with your code.
 
 [^perry]: [Trapped! By societal convention!](https://youtu.be/CnOWLuN37D8?t=64)
-[^camel]: And because doing this will increase your body's ability to retain water by ~34%
+
diff --git a/src/visibility.md b/src/visibility.md
new file mode 100644
index 0000000..8ef10a4
--- /dev/null
+++ b/src/visibility.md
@@ -0,0 +1,20 @@
+# Visibility
+
+When code is all in one file, everything is "visible." This means that
+if there is a method you are always allowed to call it.
+
+```java
+class Main {
+    void canCallThis() {
+        System.out.println("of course!")
+    }
+
+    void main() {
+        canCallThis();
+    }
+}
+```
+
+And if there is a field you can read it, if there is a class you can make an instance of it, etc.
+
+Once we split into multiple files, you are allowed to make things less visible.
diff --git a/src/visibility/accessors.md b/src/visibility/accessors.md
new file mode 100644
index 0000000..3de25cb
--- /dev/null
+++ b/src/visibility/accessors.md
@@ -0,0 +1,61 @@
+# Accessors
+
+When a field is hidden that is usually because you want to control
+how it might be changed.
+
+To access the current value of a private field you need to go through a non-private method.
+If a method just provides access to a field we call that an "accessor."
+
+```java,no_run
+class Dog {
+    private String name;
+
+    Dog(String name) {
+        this.name = name;
+    }
+
+    // The name field is private, but
+    // you can access it by calling the name method.
+    String name() {
+        return this.name;
+    }
+}
+```
+```java
+class Main {
+    void main() {
+        var dog = new Dog("Daisy");
+
+        // dog.name won't work because the name field is private
+        // dog.name() will work because the name method is not
+        System.out.println(dog.name());
+    }
+}
+~class Dog {
+~   private String name;
+~
+~   Dog(String name) {
+~       this.name = name;
+~   }
+~
+~    String name() {
+~        return this.name;
+~    }
+~}
+```
+
+We would also consider things like the `length` method on `String`s to be "accessors."[^notthat]
+
+```java
+void main() {
+    String s = "abc";
+    System.out.println(
+        // We can't see what fields underly this,
+        // but we can access the length
+        s.length()
+    );
+}
+```
+
+[^notthat]: Not that the categorization matters much, but socially we expect "accessor"-looking methods to only give you a value and not "do stuff" like
+increment a number or mess with a file.
\ No newline at end of file
diff --git a/src/visibility/getter_and_setters.md b/src/visibility/getter_and_setters.md
new file mode 100644
index 0000000..c25639b
--- /dev/null
+++ b/src/visibility/getter_and_setters.md
@@ -0,0 +1,43 @@
+# Getters and Setters
+
+A very silly thing you are likely to see if you dig around on the internet
+is classes that look like this.
+
+```java
+class Person {
+    private String name;
+    private int age;
+    
+    String getName() {
+        return this.name;
+    }
+
+    void setName(String name) {
+        this.name = name;
+    }
+
+    String getAge() {
+        return this.age;
+    }
+
+    void setAge(String age) {
+        this.age = age;
+    }
+}
+```
+
+So people make classes with all private fields and then for each field `thing` they
+have two methods - `getThing` and `setThing`.
+
+To which you might immediately ask - what is the difference between this and just having non-private fields.
+
+```java
+class Person {
+    String name;
+    int age;
+}
+```
+
+The answer to that is...annoying. We'll get to it, but the short story is that its a bit of a holdover from a very weird period in the 1990s.
+
+I mention it specifically so that you know that there isn't any important information you are missing and you are not crazy.
\ No newline at end of file
diff --git a/src/visibility/invariants.md b/src/visibility/invariants.md
new file mode 100644
index 0000000..aa83d23
--- /dev/null
+++ b/src/visibility/invariants.md
@@ -0,0 +1,70 @@
+# Invariants
+
+Having private fields and methods is useful when you want
+to maintain some invariants.
+
+Say you wanted a class that holds an even number.
+
+```java
+class EvenNumberHolder {
+    int value;
+
+    EvenNumberHolder(int value) {
+        if (value % 2 == 1) {
+            throw new RuntimeException(value + " is not even");
+        }
+
+        this.value = value;
+    }
+}
+```
+
+You can always make the value `final` to prevent its value from being changed.
+
+```java
+class EvenNumberHolder {
+    final int value;
+
+    EvenNumberHolder(int value) {
+        if (value % 2 == 1) {
+            throw new RuntimeException(value + " is not even");
+        }
+        
+        this.value = value;
+    }
+}
+```
+
+But if you actually wanted to change its value that isn't enough.
+
+By making the field private you can know that other code has to call methods to access or
+change the value. That gives you a clean place to "enforce" your invariants.
+
+```java
+class EvenNumberHolder {
+    private int value;
+
+    EvenNumberHolder(int value) {
+        // The constructor explicitly rejects an odd value
+        if (value % 2 == 1) {
+            throw new RuntimeException(value + " is not even");
+        }
+        
+        this.value = value;
+    }
+
+    // There is no way to get an odd value now - you can only
+    // change it in steps of two.
+    int value() {
+        return this.value;
+    }
+
+    void addTwo() {
+        this.value += 2;
+    }
+
+    void subtractTwo() {
+        this.value -= 2;
+    }
+}
+```
\ No newline at end of file
diff --git a/src/visibility/private.md b/src/visibility/private.md
new file mode 100644
index 0000000..86620ac
--- /dev/null
+++ b/src/visibility/private.md
@@ -0,0 +1,2 @@
+# Private
+
diff --git a/src/visibility/private_constructor.md b/src/visibility/private_constructor.md
new file mode 100644
index 0000000..4736b26
--- /dev/null
+++ b/src/visibility/private_constructor.md
@@ -0,0 +1 @@
+# Private Fields
diff --git a/src/visibility/private_fields.md b/src/visibility/private_fields.md
new file mode 100644
index 0000000..146f8d6
--- /dev/null
+++ b/src/visibility/private_fields.md
@@ -0,0 +1,25 @@
+# Private Fields
+
+Similar to private methods, you can also mark a field as private.
+
+```java
+class Kaiju {
+    private int timesLostToGodzilla;
+
+    Kaiju() {
+        this.timesLostToGodzilla = 0;
+    }
+
+    void fightGodzilla() {
+        this.timesLostToGodzilla++;
+    }
+
+    boolean isLoser() {
+        return this.timesLostToGodzilla > 0;
+    }
+}
+```
+
+This makes it so that code in other files cannot see or change the field directly.
+
+
diff --git a/src/visibility/private_methods.md b/src/visibility/private_methods.md
new file mode 100644
index 0000000..2db9a45
--- /dev/null
+++ b/src/visibility/private_methods.md
@@ -0,0 +1,28 @@
+# Private Methods
+
+If a class has a method that it uses but that you do not want other code to see,
+you can mark it `private`.
+
+```java,no_run
+class RiceCooker {
+    int temperature;
+
+    private boolean shouldTurnOff() {
+        return temperature > 100;
+    }
+
+    void operate() {
+        if (shouldTurnOff()) {
+            turnOff();
+        }
+        else {
+            // ...
+        }
+    }
+}
+```
+
+This makes it so that code in `RiceCooker.java` can see and call the `shouldTurnOff` method but code in other files cannot.
+
+This is useful if you want to box up some logic but don't want to have to think about
+what happens if other code calls it.
\ No newline at end of file
diff --git a/src/visibility_ii.md b/src/visibility_ii.md
new file mode 100644
index 0000000..5649474
--- /dev/null
+++ b/src/visibility_ii.md
@@ -0,0 +1 @@
+# Visibility II
diff --git a/theme/book.js b/theme/book.js
index 0524af9..60cfba1 100644
--- a/theme/book.js
+++ b/theme/book.js
@@ -115,7 +115,7 @@ function playground_text(playground, hidden = true) {
     let text = playground_text(code_block);
 
     var params = {
-      release: '21',
+      release: '22',
       runtime: 'latest',
       action: 'run',
       preview: true,