Challenges up through static methods

Author: bowbahdoe

src/projects/data_visualization.md

@@ -11,7 +11,7 @@ organic matter.
 
 If you've ever seen a drawing of [a plague doctor](https://en.wikipedia.org/wiki/Plague_doctor)
 this is part of why they had that long nosed mask. They would fill it with nice smelling herbs
-in order to counter the miasma they though was causing disease.
+in order to counter the miasma they thought was causing disease.
 
 This was basically entirely wrong in terms of the mechanics of disease spread. But it wasn't all bad. Staying
 away from dead bodies and wearing a mask around the sick aren't the worst ideas in the world.
@@ -34,7 +34,7 @@ plotted it, and saw a straight line then that is useful information.
 
 Computers are uniquely suited to making visualizations. Modern data sets
 are often quite large and already stored on a computer. It is easier for a computer
-to turn that visualization into a chart or diagram of some kind than it is
+to turn that data into a chart or diagram of some kind than it is
 for a human to sit down and labor with a sheet of paper and a ruler. 
 
 ## Your Goal
@@ -76,7 +76,7 @@ So if you write text like this into a file and give it a `.ppm` extension your c
 able to show it to you as an image.
 
 You will still need to figure out how you are going to represent image data in your program,
-how to write to produce a file like this, and how to arrange the pixels. That should all be within your
+how to produce a file like this, and how to arrange the pixels. That should all be within your
 ability at this point though.[^believe]
 
 ## Future Goals

src/recur

@@ -1 +1,90 @@
 # 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
+
+Add a static field to this `Ogre` class that keeps track of
+how many Ogres have been made thus far in the program.[^threads]
+
+```java,editable
+class Ogre {
+    // CODE HERE
+
+    Ogre() {
+        // CODE HERE
+    }
+}
+
+class Main {
+    void main() {
+        // 0
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+
+        // 1
+        Ogre o1 = new Ogre();
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+
+        // 2
+        Ogre o2 = new Ogre();
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+        
+        // 3
+        Ogre o3 = new Ogre();
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+        
+        // 4
+        Ogre o4 = new Ogre();
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+
+        // 5
+        Ogre o5 = new Ogre();
+        IO.println(Ogre.NUMBER_OF_OGRES_MADE);
+    }
+}
+```
+
+## Challenge 2
+
+Initialize the `PI` and `TAU` static final fields inside of a static initializer block.
+`TAU` should have twice the value of `PI`.
+
+```java
+class Maths {
+    static final double PI;
+    static final double TAU;
+
+    static {
+        // CODE HERE
+    }
+}
+
+class Main {
+    void main() {
+        IO.println(Maths.PI);
+        IO.println(Maths.TAU);
+    }
+}
+```
+
+## Challenge 3
+
+Rename the constants in the `Doug` class in the way that would
+be expected of you by others.
+
+```java
+class Doug {
+    static final String pattyMayonnaise = "Patty Mayonnaise";
+    static final String sKeEtEr = "Mosquito 'Skeeter' Valentine";
+    static final String mosquito_valentine = sKeEtEr;
+    static final String rodgerMKlotz = "Rodger M. Klotz";
+    static final String DOUG = "Douglas Yancy Funnie";
+}
+```
+
+
+[^threads]: Part of why mutable static fields are such a nightmare is that code like this would 
+not work when you have to write "multi-threaded" Java code. There are things you can do with normal fields to sort of "make unsafe stuff safe in a way," but static fields are a lot harder to wrangle.

src/static_fields/challenges.md

@@ -1 +1,131 @@
 # 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
+
+Change this position class such that it doesn't only have an `x` and a `y`. It should
+also have a `z`.
+
+Then add the following static methods. `fromZ`, `fromXY`, `fromXZ`, and `fromYZ`.
+
+```java,editable
+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 = Position.fromXY(1, 2);
+        IO.println("(" + p1.x + ", " + p1.y + ", " + p1.z + ")");
+
+        var p2 = Position.fromYZ(1, 2);
+        IO.println("(" + p2.x + ", " + p2.y + ", " + p2.z + ")");
+
+        var p3 = Position.fromXZ(1, 2);
+        IO.println("(" + p3.x + ", " + p3.y + ", " + p3.z + ")");
+
+        var p4 = Position.fromZ(4);
+        IO.println("(" + p4.x + ", " + p4.y + ", " + p4.z + ")");
+    }
+}
+```
+
+## Challenge 2
+
+Make a static method in the `Maths` class called `quadraticFormula`.
+It should take in an `a`, `b`, and `c` and run the [quadradic formula](https://en.wikipedia.org/wiki/Quadratic_formula) on those values.
+
+This formula will give you either one "real" solution, two real solutions,
+or two imaginary solutions.
+
+For now just throw an exception if the solutions are imaginary
+and treat having one solution as having two solutions with the same value.
+
+```java,editable
+class Maths {
+    // CODE HERE
+}
+
+class Main {
+    void main() {
+        var result = Maths.quadraticFormula(6, -17, 12);
+        IO.println(result.solutionOne);
+        IO.println(result.solutionTwo);
+    }
+}
+```
+
+## Challenge 3
+
+Update your code above to also communicate if a solution is imaginary.
+Use a boolean or an enum field on whatever class you wrote to hold both solutions
+for this.[^other]
+
+[^other]: You will learn other ways later.
+
+## Challenge 4
+
+Make the following code compile. Do so first by changing one of the fields to `static`
+then by instead passing an extra argument to the `static` method.
+
+```java,no_run
+class Keychain {
+    final String[] keys;
+
+    Keychain(String[] keys) {
+        this.keys = keys;
+    }
+
+    boolean hasKey(String key) {
+        for (int i = 0; i < keys.length; i++) {
+            if (keys[i].equals(key)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+
+
+class Main {
+    Keychain keychain = new Keychain(new String[] {
+        "house",
+        "car",
+        "shed"
+    });
+
+    static void unlock(String thing) {
+        if (keychain.hasKey(thing)) {
+            IO.println("You have unlocked my " + thing);
+        }
+        else {
+            IO.println("You don't have a key for my " + thing);
+        }
+    }
+    
+    void main() {
+        unlock("house");
+        unlock("car");
+        unlock("shed");
+        unlock("heart");
+    }
+}
+```

src/static_methods/challenges.md

@@ -1 +1,92 @@
 # 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
+
+The following `Ratio` class should have an invariant where `denominator`
+cannot be `0`.
+
+```java,no_run
+class Ratio {
+    int numerator;
+    int denominator;
+
+    Ratio(int numerator, int denominator) {
+        if (denominator == 0) {
+            throw new RuntimeException("Denominator cannot be zero");
+        }
+    }
+
+    double value() {
+        return ((double) numerator) / denominator;
+    }
+}
+```
+
+Unfortunately other classes can directly access the `denominator` field.
+
+Make the denominator field private and add an accessor method for other classes to use.
+You can name this accessor `.denominator()` or `.getDenominator()`.
+
+## Challenge 2
+
+Alter the code from the last challenge such that numerator is also private and only
+usable via an accessor method.
+
+## Challenge 3
+
+Alter the code from the last challenge such that you can not only access but also
+mutate the `numerator` and `denominator` fields via exposed methods.
+The method for mutating the `denominator` should throw an exception
+if someone tries to set it to zero.
+
+## Challenge 4
+
+Given this `Pineapple` class make every method except `digest` private.
+
+```java,no_run
+class Pineapple {
+    void digestProtein(String name) {
+        IO.println("Pineapple juice is digesting the proteins in " + name);
+    }
+    
+    void eatPork() {
+        digestProtein("pork");
+    }
+
+    void eatChicken() {
+        digestProtein("chicken");
+    }
+
+    void eatBeef() {
+        digestProtein("beef");
+    }
+
+    void eatYou() {
+        IO.println("Pineapple juice is eating you from the inside.");
+    }
+
+    void digest(String thing) {
+        switch (thing) {
+            case "pork" -> eatPork();
+            case "chicken" -> eatChicken();
+            case "beef" -> eatBeef();
+            default -> eatYou();
+        }
+    }
+}
+```
+
+## Challenge 5
+
+Rewrite the code from the previous challenge such that the `digest`
+method on `Pineapple` does the same thing but no other private methods
+exist.
+
+Note when doing this that you wouldn't need to consider other code.
+The behavior of the only exposed method does not change so those private
+methods would only be "implementation details."

src/visibility/challenges.md

@@ -38,6 +38,6 @@ class Person {
 }
 ```
 
-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 early 2000s.
+The answer to that is interesting. We'll get to it, but the short story is that its a bit of a holdover from a very weird period in the early 2000s.
 
 I mention it specifically so that you know that there isn't any important information you are missing and you are not crazy.