CompSci 308 : Spring 2025

GITing Started

This exercise will not be explicitly graded, instead its goal is to ensure that you can participate in the course by verifying you

have correctly installed the course software
can use it to develop Java programs with OpenJFX
can submit your code to the course's Gitlab group

Download and Install Development Software

You will be using the most recent Long Term Support (LTS) version of Java in this course and we recommend using IntelliJ as your development environment since it has a wide variety of features to help you improve your program's design.

Download and install OpenJDK LTS version 21 (before starting the download, make sure to select the FULL JDK, DMG or MSI package, instead of the default Standard)
Download and install GIT (includes a Unix style command-line Shell for Windows or can also install a full version of Ubuntu Linux)
Download and install IntelliJ Ultimate version (free for students if you apply by providing your school email address)

Videos

Here is a video of the installation process since there are some specific notes I wanted to show in choosing what to download
Here is a video showing the steps below for working with a project with explanations along the way

Completing this step is vital so everyone starts with the same software versions to remove a possible variable when debugging large programs across multiple people and OSes.

Configure GIT

Note, we recommend using the command-line when interacting with GIT, at least for the first half of the course, to make sure you have a firm understanding of the foundational principles.

Accessing the command-line within IntelliJ you can use the Terminal tab within IntelliJ, View → Tool Windows → Terminal, (this first time it would require creating a "dummy" project)
OR, outside of IntelliJ, you can search for a Terminal app on
- Mac or Linux: you can use the built in Terminal program
- Windows: GIT comes with a program called Git Shell but there are some settings you should set to work well with other platforms
Within Terminal/Shell, configure GIT for your computer (note, these commands need to be done once for each computer you program on)
```
    git config --global user.name "YOUR NAME"
    git config --global user.email NETID@duke.edu
```

Completing this step is vital so the Teaching Team can identify the code you write during the semester to better give you personalized feedback.

Login to Gitlab

Within a Browser, go to the website: https://coursework.cs.duke.edu/
Press the Shibboleth button to log in using your Duke NetID
After you have successfully been logged in through Duke's standard log in page, you should see your Dashboard
If you have never used this Gitlab site in another CompSci course OR you have a new computer since you last used it, then you will need to generate a new SSH key
Otherwise, you should be able to skip the next section

Generate an RSA SSH Key

Within a Browser, go to the website: https://coursework.cs.duke.edu/help/user/ssh.md
If you have not already generated an SSH key for another class:
- Within Terminal/Shell, run the command below and accept the default options (details are in the RSA SSH Keys section within "Generating a new SSH key pair")
```
    ssh-keygen -t rsa -C NETID@duke.edu -b 4096
```
If you have not already connected your current computer to our Gitlab site (coursework):

Within Terminal/Shell, copy the public key using the command corresponding to your OS given in the section Adding an SSH key to your GitLab account
Within a Browser, paste the copied public key into the Gitlab text area (Preferences → SSH Keys → Key Text Area)
giving it the same title: id_rsa, and press Add key

Completing this step is vital to allow you to access the course Gitlab server (there is no password option).

Get your Own Copy of a Gitlab Project's Starter Code

Within a Browser, visit the project for this exercise, CompSci308_2025spring/lab_bounce
Press Fork (the button is in the right upper corner) to create a version of the project in your own account with the same name (e.g., NetID/lab_bounce)
Note, you will use fork only to create your own repository of lab_ or example_ repositories. A repository will be provided for you for project_ or portfolio_ repositories
On the new project page that appears, copy the SSH URL (e.g., git@coursework.cs.duke.edu:NetID/lab_bounce.git)
Note, it is will appear as an option when you press the blue Clone button on the right side of the page

Clone your Copy of the Project onto your Local Machine

Within Terminal, change to a folder you want to hold all your course coding project (WORKSPACE_FOLDER can be any directory you want on your computer as long as there are no spaces anywhere in the path)
```
    cd WORKSPACE_FOLDER
```
Download a local version of the project that is linked to your Gitlab repository
```
    git clone git@coursework.cs.duke.edu:NetID/lab_bounce.git
```
That command should create a folder named lab_bounce within your workspace folder that contains configuration information for GIT (e.g., a folder named .git — note that it starts with a period)
```
    ls -a lab_bounce
```

Create IntelliJ Project from your Local Copy

Within IntelliJ, open the newly cloned folder using File → Open (or the Open button if the File menu is not available)
Select the folder you just created, lab_bounce, and press Open
Once the project window appears, you will need to a few more steps to get it to run:
Note, depending on the speed of your machine, it may take a little while to recognize and setup the project, as well as download some files this first time.
1. Click on the Project label in the leftmost gutter to expand the contents of your project folder
2. Click to expand the folders src → java → main → bounce to find the Java class Main
3. Right click on this class to run it by selecting Run Main.main()
Run the program to verify that your Java installation is working
If there are compilation errors or it does not run, then you may not have installed the latest versions of Java or IntelliJ or the project is not correctly configured.

Completing these steps verifies your Java and IntelliJ installations are correct and working together.

Push Changes Made to your Project back up to Gitlab

Within Terminal, your lab_bounce folder should now have the configuration folders for both GIT (e.g., .git) and IntelliJ (e.g., .idea)
```
    ls -a lab_bounce
```
Within IntelliJ, the file README.md should already be open in Preview mode. Change it Edit and Preview mode by pressing the middle blue icon in the pane's upper right corner.
Add your name and save the file
When you do this, you should see the file's name in the Project View's list of files change color to indicate GIT knows it has been changed
Within Terminal, you can verify that GIT also knows that it has been changed by typing
```
    git status
```
Add your changed files to those staged for your next commit
```
    git add README.md
```
Then note that all the added files should be grouped together into a single commit to the repository, with a message describing the changes contained in this commit
```
    git commit -m "Included my name in the README"
```
Push all your commits to the remote repository, e.g., Gitlab, so that others (UTAs, teammates, etc.) can see your changes
```
    git push -u origin main
```
Within a browser, refresh the Gitlab page for your repository to see your changed README file

Completing this step verifies you can correctly access the course Gitlab group to submit your work for the semester.

Setup IntelliJ to Fix Code Indentation Issues

All projects will use Google's Java code format standards.

Set up IntelliJ to do this for you automatically:

Download intellij-java-google-style.xml from its GitHub repository
Go to the IntelliJ menu and select Preferences
In the dialog that appears, select Editor → Code Style
On the line that says Scheme, click on the gear icon after the Combo Box with the tooltip Show Scheme Actions
Click on Import Scheme → IntelliJ IDEA code style XML
Select the previously downloaded XML file and then Open
Finally unselect the option Enable EditorConfig support before clicking OK to close the dialog box

IntelliJ should now monitor your Code Formatting, but you can reformat code in any file to follow these conventions by selecting the menu Code → Reformat Code (especially before pushing it to the remote repository!).