Bad project

Author: bowbahdoe

src/SUMMARY.md

@@ -83,6 +83,9 @@ Adjacency Matrix
 
 BFS
 
+Have a project that is just klarna but the your goal is "never write this program."
+
+
 -->
 
 # Modern Java
@@ -456,9 +459,9 @@ BFS
   - [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)
+  - [Rethrowing Exceptions](./exceptions_ii/rethrowing_exceptions.md)
   - [main](./exceptions_ii/main.md)
   - [Challenges](./exceptions_ii/challenges.md)
 - [Switch II](./switch_ii.md)
@@ -582,6 +585,8 @@ BFS
 
 # Projects
 
+- [Buy Now, Pay Later](./projects/buy_now_pay_later.md)
+- [Data Visualization](./projects/data_visualization.md)
 <!-- read and write some journal entries -->
 - [Journal Entries]()
 
@@ -1066,6 +1071,8 @@ jshell
         - [Maven]
             - Dependencies
 
+SDL, Vulkan, IMGUI - the C world
+
 ```xml
 <?xml version="1.0" encoding="UTF-8"?>
 <project xmlns="http://maven.apache.org/POM/4.0.0"

src/exceptions_ii/challenges.md

@@ -1 +1,76 @@
 # 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
+
+Make a method named `parseIntChecked` that works the same as `Integer.parseInt`
+but throws a checked exception instead of an unchecked one.
+
+```java,editable
+// CODE HERE
+
+void main() throws Exception {
+    int x = parseIntChecked("45");
+    IO.println(x);
+
+    parseIntChecked("abc");
+}
+```
+
+## Challenge 2
+
+The following program will not compile. Make it compile by propagating the checked exception
+thrown by the `doesSomethingDangerous` method.
+
+```java,no_run
+int doesSomethingDangerous(int value) {
+    if (value == 1) {
+        throw new Exception("1 does not work");
+    }
+    return 3 * value + 2;
+}
+
+int compute(int start) {
+    return square(doesSomethingDangerous(start));
+}
+
+int square(int x) {
+    return x * x;
+}
+
+void main() {
+    int x = Integer.parseInt(IO.readln("Give a starting number: "));
+    IO.println(compute(x));
+}
+```
+
+## Challenge 3
+
+The following program is the same as the last one. Instead of propagating the exception, make it so that 
+`compute` catches and rethrows the checked exception as an unchecked one.
+
+```java,no_run
+int doesSomethingDangerous(int value) throws Exception {
+    if (value == 1) {
+        throw new Exception("1 does not work");
+    }
+    return 3 * value + 2;
+}
+
+int compute(int start) {
+    return square(doesSomethingDangerous(start));
+}
+
+int square(int x) {
+    return x * x;
+}
+
+void main() {
+    int x = Integer.parseInt(IO.readln("Give a starting number: "));
+    IO.println(compute(x));
+}
+```

src/exceptions_ii/runtime_exception.md

@@ -1 +1,17 @@
 # RuntimeException
+
+`RuntimeException` is an unchecked exception.[^naming]
+
+If you want a unchecked exception and do not know of a better one, `RuntimeException` will do.
+
+```java,panics
+void main() {
+    throw new RuntimeException("Crash!");
+}
+```
+
+[^naming]: You may be wondering why the names "`Exception`" and "`RuntimeException`" instead of the
+probably easier to understand "`CheckedException`" and "`UncheckedException`." Java was made by humans
+and initially - as I understand it - "normal" exceptions were expected to be checked. It was only
+exceptions that came from "The Java Runtime" that would be unchecked. So that is where the name "`RuntimeException`" comes from. It just very quickly became a choice that was too late to change
+without breaking all the Java code in the world.

src/global_fields/challenges.md

@@ -31,7 +31,7 @@ void main() {
 
 ## Challenge 2
 
-Make a class named `DJKhaled`. If you ask DJ Khaleed to `produceMusic`
+Make a class named `DJKhaled`. If you ask DJ Khaled to `produceMusic`
 some lyrics should be printed out but also `anothaOne` should be called at least 7 times.[^drake]
 
 

src/projects/buy_now_pay_later.md

@@ -0,0 +1,91 @@
+# Buy Now, Pay Later
+
+## Problem Statement
+
+People exchange money for goods and/or services.
+
+Some of these purchases are non-essential. This means that they are,
+strictly speaking, optional. Ordering extra guacamole at a restraunt,
+buying a brand new pair of shoes, and buying a diamond ring are all
+examples of non-essential spending.
+
+Other purchases are essential. If you are having a heart attack (within
+the United States) medical care is a mandatory expense. You either make that
+purchase or you die. If one does not have some minimum level of food, water, and shelter
+those are also essential expenses.
+
+It comes down to needs and wants. If you need to have something that is an essential purchase.
+If you want to have something that is a non-essential purchase.
+
+Many people do not have enough money for their essential expenses.
+This can be due to any number of reasons, but in the United States minimum wage has
+not kept up with overall inflation since 1968. Add to that rising costs of housing,
+transportation, education, etc. and people's financial
+
+Some people have much more money than they could ever need. These people,
+sometimes pooling funds via corporations, often choose to loan this money
+to those that do not have enough for their expenses.
+
+The reason they do this is because they can charge fees. If someone can't afford
+a particular expense of ~$100 they can get the money for that expense right away in exchange for agreeing
+to say a 2% interest rate. This would mean that the amount they owe goes up by 2% every month or so that they
+do not pay the loan issuer back.
+
+Banks work this way. You deposit money in the bank and, while the bank and the government
+guarentee you that you can go at any time and get your money out, they are also turning around
+and lending that money to any number of businesses and individuals.
+
+So long as you assume most people will be able to eventually pay off their debts being a loan issuer
+is a very profitable business to be in. It is also something of a public good.[^christmas] But if a large number of people are unable to pay off their debts
+you can get financial collapses. This can be at the level of an indidual loan issuer or entire countries.
+
+Because it is bad when this happens governments generally have laws that restrict the "level of risk"
+loan issuers are allowed to take on. If they "take on too much risk" - meaning loan enough money
+to people who aren't able to pay it back - there will eventually be a collapse.
+
+The level of scrutiny that applies to normal debts does not seem to, at least in the United States,
+apply when you do it via payment plans and call it "Buy Now, Pay Later." This allows for businesses
+to make loans they otherwise wouldn't be allowed to to people that might not otherwise qualify.
+
+This certainly helps people who are struggling to get enough to affort their essential expenses.
+It can also help people make non-essential expenses which they deem essential. Human's are imperfect
+creatures. Many will take on a payment plan with an interest rate for a burrito.
+
+In all cases the ability to take on debt can either help someone stabilize their financial situation
+or it can ultimately make things worse. The higher the interest rate the more likely the second situation
+comes to pass.
+
+In the modern world computers are required to track both the issuance of these debts as
+well as compute interest and facilitate the collection process. This is in part because payments
+are often made electronically but also in part because the overhead of paying a person
+to manually keep track of all this info would eat in to the profits from interest and flat fees.
+
+"Buy Now, Pay Later" programs also want to be embedded into online storefronts. People are much more likely
+to accept higher interest rates or take on the debt at all the closer the offer is made to "the point of sale." This requires not only business deals but a non-trivial amount of code.
+
+## Your Goal
+
+Never make a program for this.
+
+"Buy Now, Pay Later" is another word for debt. If you make a program that
+enables desperate people go deeper and deeper into debt to enrich yourself
+you are a scumbag.
+
+I put this "project" here to tell you that building software is not
+a neutral act. You need to critically consider how what you decide to spend
+your time on will affect the world around you.
+
+Facebook is one of the largest websites in the world. It makes a lot of
+people a lot of money. The world would be a better place
+if it did not exist.
+
+There are real companies - at the time of writing the biggest one is called [Klarna](https://klarna.com/) -
+which are more than happy to offer loans to the desperate and short-sighted. Their existence makes the
+world a worse place and they could not exist without the efforts of people who write software.
+
+## Future Goals
+
+None.
+
+[^christmas]: Watch "It's A Wonderful Life" sometimes. Banking is not intrinsically evil. Loaning people
+money so they can buy a home to live in can be a great thing.

src/switch_ii/challenges.md

@@ -1 +1,52 @@
 # 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
+
+Complete the switch expression such that it yields 
+the appropriate value for each case.
+
+In the surfer case, make sure to print out "Radical!" before yielding
+the value.
+
+```java,editable
+enum Profession {
+    FIREFIGHTER,
+    PLUMBER,
+    SURFER
+}
+
+enum NaturalEnemy {
+    FIRE,
+    LEAKY_PIPES,
+    BODACIOUS_WAVES
+}
+
+NaturalEnemy enemy(Profession p) {
+    switch (p) {
+        case FIREFIGHTER -> {
+            // CODE HERE
+        };
+        case PLUMBER -> {
+            // CODE HERE
+        } 
+        case SURFER -> {
+            // CODE HERE
+        }
+    }
+}
+
+void main() {
+    IO.println(enemy(Profession.FIREFIGHTER));
+    IO.println(enemy(Profession.PLUMBER));
+    IO.println(enemy(Profession.SURFER));
+}
+```
+
+## Challenge 2
+
+Update your program above to omit `yield` in the two cases where it is not needed.

src/switch_ii/exhaustive_switches_with_enums.md

@@ -28,3 +28,34 @@ boolean cool = switch (name) {
 IO.println(cool);
 ~}
 ```
+
+Unlike in a switch statement, covering all the enum values in a switch expression
+is enough for that switch to be considered exhaustive. You do not need an
+extra `default` or `case null`[^reason].
+
+```java,no_run
+enum Species {
+    ALIEN,
+    PREDATOR,
+    HUMAN
+}
+
+void main() {
+    Species species = Species.valueOf(
+        IO.readln("What do you see? ").toUpperCase()
+    );
+    String message = switch (species) {
+        case ALIEN -> "Run";
+        case PREDATOR -> "Fight Back";
+        case HUMAN -> "RUN"
+    };
+
+    IO.println(message);
+}
+```
+
+[^reason]: The nitty gritty of why this is comes down to what Java will do if the code is
+run with an unexpected enum variant. With a switch statement the code will just move on and
+run none of the switch cases. With a switch expression Java will crash on an unexpected value.
+This difference is partially due to the fact that switch statements came first in the language
+and switch expressions came later. What a world, huh? 

src/switch_ii/exhaustive_switches_with_strings.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 1990s.
+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.
 
 I mention it specifically so that you know that there isn't any important information you are missing and you are not crazy.