Fixed typos "it's" to "its" and "access access" to "access"

adt-and-links/adt-and-links.md

@@ -1,6 +1,6 @@
 # ADTs and Lists Tutorial
 
-![Approved for: Spring 2022](https://img.shields.io/badge/Approved%20for-Spring%202022-purple)
+![Approved for: Fall 2023](https://img.shields.io/badge/Approved%20for-Fall%202023-green)
 
 ## Introduction
 

cla/cla.md

@@ -1,6 +1,6 @@
 # Command-Line Arguments
 
-![Approved for: Spring 2022](https://img.shields.io/badge/Approved%20for-Spring%202022-purple)
+![Approved for: Fall 2023](https://img.shields.io/badge/Approved%20for-Fall%202023-green)
 
 When working in a Unix-like environment, programs are launched when the user
 enters the program's name into the shell (i.e., they type it in, then press
@@ -9,34 +9,35 @@ pieces of information, called **command-line arguments**, after the program's
 name in order to adjust the program's settings and supply values that the
 program needs to execute. For example, consider using `ls` to list all of the
 entries in `~/public_html` using the long listing format (`-l`), including
-files that being with a dor (`-a`):
+hidden files that begin with a dot `.` (`-a`):
 
 ```
 $ ls -l -a ~/public_html
 ```
 
+In the example above, the base command (program) is `ls` and the command-line 
+arguments used are `-l`, `-a`, and `~/public_html`. Each of the command-line 
+arguments provides information to the program about how it should run.
+
 When the program is launched, the command-line arguments are passed into
-to the program through its `main` method. Like many Unix programs, `ls` is
+to the program through its `main` method. The program reads these values as
+input and determines how to respond. Like many Unix programs, `ls` is
 written in C, but support for command-line arguments extends to other
 languges as well, including Java. Let's try it!
 
 1. Create a directory for this tutorial called `cs1302-cla`, then change into it.
 
 1. Create a `src` and `bin` directory, then create the `.java` file for a class
-   called `ArgTester` in a package called `cs1302.cla` such that the `src` directory
-   is the _default package for source code_.
+   called `ArgTester` and place `ArgTester.java` in the `src` directory.
 
    ```
    cs1302-cla
    ├── bin
    └── src
-       └── cs1302
-           └── cla
-               └── ArgTester.java
+       └── ArgTester.java
    ```
 
-1. In `ArgTester.java`, add the appropriate package statement, then
-   add the declaration for the `ArgTester` class.
+1. In `ArgTester.java`, add the declaration for the `ArgTester` class.
 
 1. In your `ArgTester` class, add the following `main` method:
 
@@ -52,16 +53,20 @@ languges as well, including Java. Let's try it!
 
 1. Take a few minutes to carefully read through the code above. Try and understand what it's doing.
    Note: Up until this point, you've always typed `String[] args` as a parameter to `main` but you've
-   never used it. That parameter is a reference to an array of command-line arguments.
+   probably never used it. That parameter is a reference to an array containing the command-line arguments.
 
 1. Compile the `ArgTester` class, specifying `bin` as the destination directory.
 
-1. Run `cs1302.cla.ArgTester` as usual using the `java` command. Here is what the command looks
+   ```
+   javac -d bin ArgTester.java
+   ```
+
+1. Run `ArgTester` as usual using the `java` command. Here is what the command looks
    like with the expected program output, assuming you are running it from the `cs1302-cla`
    directory:
 
    ```
-   $ java -cp bin cs1302.cla.ArgTester
+   $ java -cp bin ArgTester
    arguments:
    ```
 
@@ -71,10 +76,10 @@ languges as well, including Java. Let's try it!
 1. Now try the following command:
 
    ```
-   $ java -cp bin cs1302.cla.ArgTester one two three
+   $ java -cp bin ArgTester one two three
    ```
 
-   What happened? It looks like the for-loop iterated. The array referred to by `args` is not
+   What happened when you ran it? It looks like the for-loop iterated. The array referred to by `args` is not
    empty. That's right, we've actually used the `args` array for something! Here's the
    expected output:
 
@@ -92,15 +97,15 @@ languges as well, including Java. Let's try it!
    different command-line arguments are parsed. Try the following commands:
 
    ```
-   $ java -cp bin cs1302.cla.ArgTester "one two" three
+   $ java -cp bin ArgTester "one two" three
    ```
 
    ```
-   $ java -cp bin cs1302.cla.ArgTester --help "some topic"
+   $ java -cp bin ArgTester --help "some topic"
    ```
 
    ```
-   $ java -cp bin cs1302.cla.ArgTester --string "my \"awesome\" day"
+   $ java -cp bin ArgTester --string "my \"awesome\" day"
    ```
 
 2. That's it! The rest is purely in the realm of code. We've shown you how command-line

components/components.md

@@ -1,6 +1,6 @@
 # JavaFX Custom Component Tutorial
 
-![Approved for: Spring 2022](https://img.shields.io/badge/Approved%20for-Spring%202022-purple) 
+![Approved for: Spring 2023](https://img.shields.io/badge/Approved%20for-Spring%202023-magenta)
 
 JavaFX is a library for creating and delivering applications with graphical user interfaces (GUIs)
 in Java. In this tutorial, we will use JavaFX 17. The API documentation for
@@ -26,8 +26,8 @@ using inheritance and polymorphism to emphasize code reuse.
 
    If you encounter problems in this step, then please ensure that you have followed the
    instructions provided at the beginning of the semester for
-   [MacOS users](https://github.com/cs1302uga/cs1302-exercises/blob/master/misc/MacOS.md) or
-   [Windows 10 users](https://github.com/cs1302uga/cs1302-exercises/blob/master/misc/Windows10.md).
+   [MacOS users](https://github.com/cs1302uga/cs1302-tutorials/blob/alsi/setup/MacOS.md) or
+   [Windows 10 users](https://github.com/cs1302uga/cs1302-tutorials/blob/alsi/setup/Windows.md).
 
    Also, the `-X` and `-Y` options can be used individually with or without each other. 
    See the manual page for `ssh` for more information about the differences between
@@ -50,14 +50,14 @@ using inheritance and polymorphism to emphasize code reuse.
    ```
 
 1. Compile and run the provided code without any errors or warnings. If you need a reminder of the compile commands, review
-   the relevant parts of the [JavaFX Tutorial](https://github.com/cs1302uga/cs1302-tutorials/blob/master/javafx/javafx.md). 
+   the relevant parts of the [JavaFX Tutorial](https://github.com/cs1302uga/cs1302-tutorials/blob/alsi/javafx/javafx.md). 
    We recommend creating a compile script so you don't have to retype these commands. If you completed the previous steps 
    correctly, your app should look similar to the screenshot below. You may also find it helpful to review
    the scene graph for this app (also seen below).
 
    <table>
    <tr>
-      <td><img src="https://github.com/cs1302uga/cs1302-tutorials/raw/master/components/ScreenShot.png?raw=true" width=300>
+      <td><img src="https://github.com/cs1302uga/cs1302-tutorials/raw/alsi/components/ScreenShot.png?raw=true" width=300>
       <td><pre><code>                                     --|
                          Stage            |
                            |              |
@@ -77,8 +77,6 @@ using inheritance and polymorphism to emphasize code reuse.
 1. The default size for the image in the ImageView container is 500x500 (Even though the image says 300x300). 
    Do a quick google search for "500x500 images" and load one or two of the images to make sure the app is 
    functioning properly. **Note:** the `Image` class only supports the BMP, GIF, JPEG, and PNG filetypes.
-
-1. Congratulations on compiling and running a good looking app!
 
 ## Creating a Custom Component
 
@@ -88,7 +86,7 @@ using inheritance and polymorphism to emphasize code reuse.
    reusable component based on the set of existing components contained 
    in the application.
 
-   Consider the following containment hieararchy:
+   Consider the following containment hierarchy:
 
    ```
                                                              --|
@@ -163,14 +161,14 @@ using inheritance and polymorphism to emphasize code reuse.
    1. The class should contain the `static` constants from
       the `ImageApp` class. They can be cut and paste directly
       from that class, perhaps changing them to `protected`
-      visibility if you wish to do so.
-
-   1. Your class should have instance variables for the other
-      nodes in the sub-graph (make sure to import all required classes). 
-      For example, you will need
-      an instance variable called `urlLayer` of type `HBox`
-      as well as instance variables for the remaining nodes.
-      For the most part, these can be cut and paste from the
+      visibility if you wish to do so. That way they can be accessed
+      by the other classes in the package.
+
+   1. Your `ImageLoader` class should contain instance variables for the
+      nodes in the sub-graph above (`HBox`, `TextField`, `Button`, and `ImageView`).
+      You do not need an instance variable for `VBox` because the `ImageLoader` itself
+      is a `VBox`!
+      For the most part, the required instance variables can be cut and paste from the
       `ImageApp` class. Any instance variables that you move
       into the `ImageLoader` class can be removed from `ImageApp`. You can
       also remove any imports that are no longer needed in `ImageApp`.
@@ -184,7 +182,9 @@ using inheritance and polymorphism to emphasize code reuse.
       Use this knowledge to add your newly created nodes to the
       sub-graph rooted at `this` similar to how they are 
       added to the `VBox` node in the `ImageApp` class. 
-      Your code will likely look something like this:
+      Your code will likely look something like the code below with 
+      additional statements to instantiate the components and connect
+      them:
 
       ```java
       public ImageLoader() {
@@ -195,23 +195,30 @@ using inheritance and polymorphism to emphasize code reuse.
       } // ImageLoader
 	  ```
 
-   1. If you haven't done so already, remove the code to create the subgraph
-      (`HBox`, `ImageView`, `TextField`, and `Button`) from the `start` method 
-      of `ImageApp`. All of that code will be run when we create a new `ImageLoader`
-      object.
+   1. Remove the code to create the subgraph
+      (`HBox`, `ImageView`, `TextField`, and `Button`) from the constructor and `init` methods
+      of `ImageApp`. All of that code will now be run when we create a new `ImageLoader`
+      object. This includes the code to initialize the `ImageView` and set up the button handler.
+
+   1. Take a moment to think about what you are doing. You have created your own, custom class that extends
+      the JavaFX `VBox` class. This class is essentially a `VBox` with some of the components
+      built into it. Once we complete this class, we will be able to add objects of this class to a
+      scene graph and all the messy details of creating that object will be hidden inside of `ImageLoader`!
 
-   1. Move the `loadImage` method from `ImageApp` to `ImageLoader`.
-      Don't forget to set the handler on your `ImageLoader`'s button.
+   1. Now, move the `loadImage` method from `ImageApp` to `ImageLoader`. This is the method that is
+      called when the button is clicked. Don't forget to set the handler on your `ImageLoader`'s button.
 
    1. You've probably noticed that `ImageApp` has significantly decreased
       in size.  We moved a lot of that code over into our custom component!
-      Now, instantiate two objects of type `ImageLoader` within the `start`
-      method of `ImageApp`.
+      Now, instantiate two objects of type `ImageLoader` within the constructor
+      of `ImageApp`.
 
-   1. Instantiate an `HBox` object within the `start` method of `ImageApp`. This
+   1. Create an `HBox` instance variable in the `ImageApp` class and instantiate 
+      it within the constructor. This
       will serve as the container for our `ImageLoader` objects. Set
       the `spacing` property of the `HBox` to 10 by passing 10 into the `HBox`
-      constructor. Now, Add the two `ImgLoader` objects to the `HBox` object of `ImageApp`.
+      constructor. Now, in the `init` method, add the two `ImgLoader` objects to 
+      the `HBox` object of `ImageApp`.
 
    1. Make sure you pass the reference to your newly created `HBox` object into the
       `Scene` constructor within the `start` method of `ImageApp`. Previously, the 
@@ -221,7 +228,7 @@ using inheritance and polymorphism to emphasize code reuse.
    1. Compile and run your new app and load up a few 500x500 images.  You 
       should see something like the image below:
 
-      <img src="https://github.com/cs1302uga/cs1302-tutorials/raw/master/components/TwoPaneScreenShot.png?raw=true" width=300>
+      <img src="https://github.com/cs1302uga/cs1302-tutorials/raw/alsi/components/TwoPaneScreenShot.png?raw=true" width=300>
 
    1. Imagine all the ways you could use your new, custom component! Also, think
       of other custom components you could build by extending existing JavaFX

components/setup.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
-
+1;95;0c
 TUTNAME="components"
 DIR="cs1302-$TUTNAME"
 if [ ! -d $DIR ]; then
@@ -20,4 +20,4 @@ if [ ! -d $DIR ]; then
   echo "subdirectory $DIR successfully created"
 else
   >&2 echo "subdirectory $DIR already exists"
-fi  
+fi