Assignments > Lab 2: Configuring git and GitHub

If you haven’t already, please register for a GitHub account, and then add your full name and your GitHub username to this spreadsheet. I will invite you to be a contributor to the relevant repos.

• Note that you will have to confirm this invitation via email.
• I recommend that you use your UNCA email account because you can get some student perks later from GitHub.

When accessing a remote server (including a GitHub server), a common authentication strategy involves using public and private keys. Below, you will go through the process of generating a public / private key. Your private key is for you and you alone. It is your secret, and should not be shared with anyone. Your public key, on the other hand, is typically copied to a server to which you have access.

In the workflow outlined below, all commands should be run from the command line on your local computer (not arden). If you’re a Windows user, activate WSL.

2.1. Generate a public / private key pair

To generate a public / private key pair (use WSL if you’re a Windows user):

• Type the following command (from any directory on your terminal): ssh-keygen
• This will generate your private key inside the .ssh folder inside your home directory (accept the default name or rename – up to you). Typically, the private key is called id_rsa and the public key is called id_rsa.pub.
• Verify that this worked by typing ls -la ~/.ssh. You should see both files (with today’s timestamp).

2.2. Copy your public key to GitHub

• Follow the GitHub instructions
• More on public / private keys here: https://kb.iu.edu/d/aews

In this class, we’re going to be working with various shared repositories on GitHub. For most of our labs and in-class exercises, we will be using the class-exercises-fall2026 repository. You will “fork” your own personal copy of this repository on Github that you will periodically sync with the class repo. This will be for doing individual work and activities.

Before we get into the details of various GitHub workflows, you will create a copy of the course repo – one that you own – on GitHub. To do this:

1. Navigate to the course repository: https://github.com/csci338/class-exercises-fall2026
2. Click the “Fork” button (towards the top of the page on the right hand side)
3. Confirm where you would like the repo to be forked (choose your GitHub account).

Now, on your laptop, make a copy of your repo locally (using the SSH protocol):

1. Navigate to your csci338 directory on the command line.
   
   

2. On GitHub, click the green “Code” button of the course repo that you just forked. Make sure that you copy the SSH version of the address:

   

3. Within your csci338 directory, clone the class-exercises-fall2026 repo using the ssh method using the following command:

   git clone ADDRESS_YOU_JUST_COPIED

   The address should look something like this: git@github.com:walter/class-exercises-fall2026.git

4. Navigate into the class-exercises-fall2026 folder (that was just created)

5. Look at commit history (git log)

1. Create a new branch called lab02-b
   • See the git cheatsheat
2. Switch to the branch you just made (if you haven’t already)
3. Verify that you are now on the lab02-b branch (see cheatsheet)

1. Open the entire class-exercises-fall2026 folder in VS Code.
2. Create a folder named lab02
3. Inside of your lab02 folder, create a text file called ContainsPair.java
4. Within the ContainsPair.java file, implement both a nested-loop solution and a set-based solution to determine whether a list contains a repeated value. Here’s a stub to help you:

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class ContainsPair {

    public static void main(String[] args) {
        checkCase(Arrays.asList(), false, "empty");
        checkCase(Arrays.asList(3), false, "singleton");
        checkCase(Arrays.asList(1, 2, 3, 2), true, "duplicate");
        checkCase(Arrays.asList(5, 2, -10, 44, 90), false, "no duplicate");
        checkCase(Arrays.asList(-2, 4, -2), true, "negative duplicate");
        checkCase(Arrays.asList(7, 7, 7), true, "repeated more than twice");
    }

    public static boolean checkNestedLoops(List<Integer> values) {
        // TODO: compare values using nested loops
        return false;
    }

    public static boolean checkWithSet(List<Integer> values) {
        // TODO: use a Set to remember values already seen
        return false;
    }

    private static void checkCase(List<Integer> values, boolean expected, String label) {
        boolean nestedResult = checkNestedLoops(values);
        boolean setResult = checkWithSet(values);
        if (nestedResult == expected && setResult == expected) {
            System.out.println("PASS: " + label);
        } else {
            System.out.println(
                "FAIL: " + label + " expected " + expected
                + " but got nested=" + nestedResult + ", set=" + setResult
            );
        }
    }
}

1. Compile it on the command line using the javac command (e.g., javac ContainsPair.java). See the Lecture 3 slides for potential solutions. Make sure you’re in the right directory. This should generate the compiled ContainsPair.class file.
   • If you’re on WSL and javac is not installed, you can install it using the apt package manager as follows:
     sudo apt install default-jdk
2. Run your program on the command line by typing java ContainsPair

When working with version control, you don’t want to commit compiled code, system files, passwords, or third-party libraries. Luckily, the .gitignore file makes this easy.

From the command line

1. Type git status -u. What happened?
   • This command should tell you all of the untracked changes you’ve made.
2. Edit the .gitignore file by adding this line: *.class
3. Type git status -u again. What happened?

If you did it correctly, git is now ignoring your *.class file.

First, check if python is installed:

Windows

If you’re using WSL, python is probably installed. Open a WSL terminal and type:
python --version or py --version or python3 --version.
If any of those commands returns a 3.x python version, then you’re good to go. Otherwise, you will need to install a new version: https://www.python.org/downloads/

Mac

If you’re on a Mac, check if a 3.x version of python is installed. Open a terminal and type:
python --version or python3 --version.
If these commands aren’t recognized, or if they show an older version of python, you will need to install a new version: https://www.python.org/downloads/

Write some code

1. Inside of your lab02 folder, create another text file called contains_pair.py

2. Within the contains_pair.py file, implement one of the “contains pair” solutions we discussed in class (ideally the fastest one). Here’s a stub to help you:

   def check(l: list):
       # your code goes here
       return False
   
   
   print(check([1, 2, 3, 2]))          # should print True
   print(check([5, 2, -10, 44, 90]))   # should print False

Run / test your program on the command line by typing python3 contains_pair.py.

On some systems, the python executable is invoked with a different alias (see below). So figure out which one you’ll need to use and make a note of it:

• py contains_pair.py
• python contains_pair.py
• py3 contains_pair.py

New to Python? Begin from your working Java solution and compare the two languages. For this Practice section, you may ask ChatGPT to explain Python syntax or help translate your own Java code, but disclose that use in a comment. You remain responsible for tracing and explaining the Python result. This translation does not count as readiness Verification.

1. Stage your changes using git add . (the dot indicates that you want to stage all of the files that have been added / deleted / edited).
2. Commit your changes using git commit -m "Some descriptive commit message" (e.g. “Lab 2 is completed”).

1. Push your branch to GitHub using the git push command
   • This command should display an error with a suggested push command (e.g., git push --set-upstream origin <your-branch-name>). This is telling you that there is no branch called lab02-b in the GitHub repository.
2. Try again by typing git push --set-upstream origin lab02-b

A note on your origin path

Within git, your remote origin variable holds both the address and the protocol you will be using to interact with a remote server (like GitHub). Some of you are accessing the remote server using the https protocol while others are using the ssh protocol. For the sake of simplicity, let’s all use ssh. To check your origin, type: git remote show origin.

If it prints git@github.com:<your-user-name>/class-exercises-fall2026, you don’t have to do anything. Otherwise, let’s switch up your origin protocol to ssh as follows:

git remote rm origin  # removes current references
git remote add origin git@github.com:<your-user-name>/class-exercises-fall2026.git  # adds new reference
git remote show origin  # prints the new origin (which should be the correct one).

If you get a “Please tell me who you are.” error message, please set the following environment variables on your machine (you will only have to do this once):

git config --global user.name "My Name"
git config --global user.email "my_email@gmail.com"

Please use the email you used to register with GitHub

Now that your code is on GitHub, you’re going to make a “Pull Request” so that I can review your code. Do this on your fork of class-exercises-fall2026 (not the instructor’s csci338 repo).

1. Open your fork on GitHub: https://github.com/<your-username>/class-exercises-fall2026

2. Click Contribute → Open pull request (or the Compare & pull request banner if GitHub shows one).

3. Set the branch comparison like this:

   base (left)                    compare (right)
   ┌─────────────────────┐        ┌───────────────────────┐
   │ your-username/main  │   ←    │ your-username/lab02-b │
   │   (your fork)       │        │   (your branch)       │
   └─────────────────────┘        └───────────────────────┘

   Both sides should show your GitHub username as the repository owner. If the left side says csci338, switch it to your fork before creating the PR.

4. Copy the URL of the pull request and keep the link handy for Canvas.