Merge branch 'code-differently:main' into Work07

Author: DavisD251

.github/workflows/check_lesson_09_pr.yaml

@@ -0,0 +1,27 @@
+name: Check Lesson 09 Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_09/types/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up JDK
+      uses: actions/setup-java@v4
+      with:
+        java-version: '21'
+        distribution: 'temurin'
+
+    - name: Build Lesson 09 with Gradle
+      working-directory: ./lesson_09/types
+      run: ./gradlew check

.github/workflows/check_lesson_10_pr.yaml

@@ -0,0 +1,28 @@
+name: Check Lesson 10 Pull Request
+
+on:
+  pull_request:
+    branches: [ "main" ]
+    paths:
+      - "lesson_10/libraries/**"
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Use Node.js
+      uses: actions/setup-node@v4
+      with:
+        node-version: '20.x'
+
+    - name: Build Lesson 10 with Node.js
+      working-directory: ./lesson_10/libraries
+      run: |
+        npm ci
+        npm run check

.github/workflows/check_push.yml

@@ -93,3 +93,13 @@ jobs:
       run: |
         npm ci
         npm run compile
+
+    - name: Build Lesson 09 with Gradle
+      working-directory: ./lesson_09/types
+      run: ./gradlew check
+
+    - name: Build Lesson 10 with Node.js
+      working-directory: ./lesson_10/libraries
+      run: |
+        npm ci
+        npm run compile

lesson_04/dylanlafferty/ReadME.md

@@ -0,0 +1,81 @@
+## Java Implementation
+
+```class PrimeChecker {
+    public static boolean isPrime(int number) {
+        if (number <= 1) {
+            return false;
+        }
+
+        // Check if number is divisible by any number from 2 to sqrt(number)
+        for (int i = 2; i <= Math.sqrt(number); i++) {
+            if (number % i == 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int num1 = 11; //This number may be changed to change the input 
+        int num2 = 15; //This one too
+        System.out.println(num1 + " is prime: " + isPrime(num1));
+        System.out.println(num2 + " is prime: " + isPrime(num2));
+    }
+}
+```
+
+## JavaScript implementation
+
+```
+// let number = prompt("Enter a number to check if it is a Prime number");
+
+function checkPrime(number) {
+    if (number === null || number === undefined) {
+        console.log("You have not entered a number");
+        return;
+    }
+
+    if (number <= 1) {
+        console.log("This is not a prime number");
+        return false; // Numbers less than or equal to 1 are not prime
+    }
+
+    for (let i = 2; i < Math.sqrt(number); i++) {
+        if (number % i === 0) {
+            console.log("This is not a prime number");
+            return false; // If divisible by any number other than 1 and itself
+        }
+    }
+
+    console.log("This is a prime number");
+    return true; // If no divisors were found, the number is prime
+}
+
+console.log(checkPrime(45)); // 
+console.log(checkPrime(23)); // 
+console.log(checkPrime(13)); // 
+```
+
+## Explaination
+
+The Java
+The Java implementation uses a class named `PrimeChecker`. `PrimeChecker` will get an integer named `number` and run it through 2 tests. The first test will be to see if `number` is less than or greater than 1 which then will return `false`.  It will then see if the number is able to be divided by anything other than itself and if not then it will return `True`.
+
+The JavaScript implementation uses a function named `checkPrime`. `CheckPrime` first checks if a `number` has been entered. If a `number` has been entered and if it is less than or equal to 1 it will return `True`. If this passes the for loop will run and see if that `number` can be divided into itself and if it can then return `False`.  
+
+## Similarites
+1. **Syntax**
+    - Both languages write If statements in the same way using `if(instance) { code } `.
+    - The For Loop are both written using `for` and adding the statements inside of `(statement1)`.
+    - Math works the same in both languages using the `%` for division.
+2. **Input Fields**
+    - Both Languages can have a predefined input inside of the code.
+    - Both Languages can return either `true` or `false` to the console.
+
+## Differences
+1. **Syntax**
+    - In `Java` there are two Static functions but one it required to be defined as main. However in `JavaScript` you do not need to define a main function.
+    - In `Java` in order to print something you have to write a `system.out.print` compared to `JavaScript` It uses the `console.log`.
+2. ## Declarations
+    - With `Java` You have to let the computer know what type of input you are giving it. So if you would want to give a variable a number you need to declare that as an integer or `int`. While you can just write a number out in `javaScript`.
+    

lesson_04/ezra4/README.md

@@ -1,29 +1,47 @@
 ## Python Implementation
 
 ```python
-def prime_num(num):
+def is_prime(num):
     if num <= 1:
         return False
-    for i in range(2, num): 
+    for i in range(2, num):
         if num % i == 0:
             return False
     return True
+
+def main():
+    num = int(input("Enter a number: "))
+    print(f"{num} is prime." if is_prime(num) else f"{num} is not prime.")
+
+if __name__ == "__main__":
+    main()
 ```
 
 ## Java Implementation
 
 
 ```java
-public static void main(String[] args) { 
-    Scanner scanner = new Scanner(System.in);
-    System.out.print("Enter a number:");
-    int num = scanner.nextInt();
-
-    if (isPrime(num)) {
-        System.out.println(num + " is prime.");
+import java.util.Scanner;
+
+public class PrimeChecker {
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter a number: ");
+        int num = scanner.nextInt();
+        System.out.println(num + (isPrime(num) ? " is prime." : " is not prime."));
+        scanner.close();
     }
-    else {
-        System.out.println(num + " is not prime.");
+
+    public static boolean isPrime(int num) {
+        if (num <= 1) {
+            return false;
+        }
+        for (int i = 2; i < num; i++) {
+            if (num % i == 0) {
+                return false;
+            }
+        }
+        return true;
     }
 }
 ```
@@ -46,5 +64,6 @@ In java we have a different approach. Unlike python we define our class using `(
 
 2. Java uses `System.out.print()` to print out the statement and python uses `print()` to print statement.
 
-
-3. I notice i have to import `java.util.Scanner` to prompt user to input a number while python you only need to use, `input()`
+3. I notice i have to import `java.util.Scanner` to prompt user to input a number while python you only need to use, `input()`
+4. Java uses `{}` for blocks and `;` to end statement while python doesn't need semicolons.
+   

lesson_05/dylanlafferty/README.md

@@ -0,0 +1,12 @@
+
+
+## Three user Stories
+    ```
+    1. As a `Line Cook`, `I want ` an application that allows me to see an easy-to-read ticket that only displays items that belong to my station on that ticket. `So that` I can quickly make entrees faster and be able to focus on what is on my stations end other than the other stations.
+
+    2. As a `Software engineer`, `I want` a program that will allow me to drag and drop different css elements, `So that` I can efficently create a custom webpage without having to spend hours making the perfect CSS.
+
+    3. As a `Inventory Stock`, `I want` a program that will keep track of items in my storage and when that item hits a certain number it will automatically send order. `So that` I can automate my storage process and spend time reordering on other tasks in the store.
+    ```
+
+    

lesson_09/README.md

@@ -10,4 +10,28 @@ Please review the following resources before lecture:
 
 ## Homework
 
-- TODO(anthonydmays): Add homework details
+- [ ] Complete [data types exercise](#choosing-the-right-data-types).
+
+### Choosing the Right Data Types
+
+For this exercise, you will use your knowledge of data types to identify the appropriate type to store and process data. You will run a program to generate a unique file with sample data, then write code to provide the correct data type of each column.
+
+1. Execute the app providing a unique provider name.
+
+```bash
+cd lesson_09/types
+./gradlew bootRun --args="yourprovidername" # Substitute with your own value
+```
+2. Examine the file that was created for you in the [resources/data][resources-folder] folder. The file will be formatted using the [JSON][json-link] data format.
+3. Next, you will create a `DataProvider` implementation that will provide information about the data types for the columns in the file (e.g. `column1`, `column2`, etc.). You can view the example [AnthonyMaysProvider.java][example-file] file.
+4. Customize the data types map by choosing the closest appropriate data type of each column. Each data type should only be used **once**.
+5. Make sure to apply the formatter and run the tests to confirm that you've implemented everything correctly.
+```bash
+./gradlew spotlessApply
+./gradlew check
+```
+6. You are to submit a PR with your `DataProvider` implementation and the generated `.json` file that was produced for you. All build checks must pass in order to receive full credit.
+
+[json-link]: https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/JSON
+[resources-folder]: ./types/types_app/src/main/resources/data/
+[example-file]: ./types/types_app/src/main/java/com/codedifferently/lesson9/dataprovider/AnthonyMaysProvider.java

lesson_09/types/.gitattributes

@@ -0,0 +1,9 @@
+#
+# https://help.github.com/articles/dealing-with-line-endings/
+#
+# Linux start script should use lf
+/gradlew        text eol=lf
+
+# These are Windows script files and should use crlf
+*.bat           text eol=crlf
+

lesson_09/types/.gitignore

@@ -0,0 +1,5 @@
+# Ignore Gradle project-specific cache directory
+.gradle
+
+# Ignore Gradle build output directory
+build