Introduction to Git

Overview

Git is a powerful source code control system that allows developers to store their source code, collaborate, and manage changes. For this tutorial, Git uses some terminology that we need to remember:

• Working Tree: this is just a fancy name for your code, stored in directories however you like.
• Repository: the Git database of your project's entire history. Everyone has a copy of the repository stored in a .git directory at the root of your working tree. You do not need to edit anything in there directly, only through a git command on the command line.
• Add: take the changes to your working tree and get ready to store them in the repository.
• Commit: store the changes from the add command into your local repository. When you commit, you need to write a descriptive message of the changes, and Git also records the timestamp.
• Push: take the commits stored in your local repository and place them in a remote repository, thereby integrating your work with others' work.

In this exercise, we will be focusing on how to use Git on the command line, including creating a repository, adding files, committing files, and pushing your changes to a remote repository.

Git is also how we will be submitting assignments in this class. You will be creating one personal repository for this entire course. As you work, you will be asked to make many commits at logical times. When you are ready to submit an assignment, then you will push your changes to /pushbox

Setup

1. Find PuTTY in the Programs menu and use it to login to hamilton.se.rit.edu using your SE account and password. A few notes:
• In PuTTY, if you use your mouse to select text on the PuTTY screen, it is automatically copied to the Windows clipboard. So if you want to copy text from your PuTTY console, just select, then switch to a Windows editor and paste
• To paste from the Windows clipboard into your PuTTY console, use Shift + Insert.
• hamilton uses Ubuntu Linux; if you don't know much about Linux/Unix, at some point you should peruse the material in the course schedule related to Linux commands.
2. We require that you create a subfolder for this course called swen250 . The command is: mkdir swen250
3. Now change the permissions for this folder: chmod 700 swen250
4. Now verify that your permissions are correct: ls -ld swen250
   The first part of the line should look like this: drwx------
5. Change directory into swen250 using the cd command. If you are in your home directory you type cd swen250. You can verify your location by typing pwd to print the working directory. A few notes regarding directories:
• Your current directory is ./
• The directory above your current directory is ../. So to go up one directory use cd ../
• The ~ (tilde) represents your home directory. Thus, your swen250 directory can be called ~/swen250
6. We also suggest using the Bourne-Again Shell on the command line because it gives you more features. When you first reach the command line, type bash
• Use the up and down keys to scroll through previous command you ran
• In most situations, hitting Tab will auto-complete to known commands and directories
• You can create a .profile file in your home directory to automatically use the bash shell. This file should contain exec /bin/bash

Initial Setup and Activity

Source control systems are great for breaking up your work into logical tasks. Carefully follow the instructions below:

1. First, let's set up our username in git. Use the git config command for changing user.name and user.email, like this:

2. A neat feature in git command line is to use the coloring scheme to more easily spot the status of things:

   $ git config --global color.ui true  

3. Now let's create a repository. From within ~/swen250, type git init .            ONLY RUN THIS COMMAND ONCE!!!
   You should get the output like:

4. Let's add something to our working tree. Edit a text file called name.txt.
• If you have never used a command line text editor before, the simplest text editor is nano. Type nano name.txt to create and edit the file, use hotkeys shown at the bottom - (e.g. ^X means Ctrl+X)
• While nano is a pretty good quick-and-dirty text editor, we strongly suggest learning a more feature-rich editor like vim as the course moves forward. Check out our resources page for more information on learning different editors.


5. In name.txt, write your name (so the instructor knows who you are).


6. Ok, now that we've written some "code", we've completed our first task. So it's a logical time to add, commit, and push our changes. First, let's see where we stand. Type git status. You should get output like this:

# On branch master

#

# Initial commit
#

# Untracked files:

#   (use "git add ..." to include in what will be committed)

#

#       name.txt
nothing added to commit but untracked files present (use "git add" to track)

7. Before we continue, let�s create a new file which will give save us some time in the future and prevent saving into the repository �stuff� we don�t usually want. For now we will exclude the basics. Let�s create this special file. As before use nano .gitignore create and edit the file and add the following contents. Be careful that your copy/paste does not ruin the formatting:

Copy starting from line below:

# This file will prevent Git from adding files that match the following

# patterns to the repository. If you need to add a file anyway, you can use

# `git add -f [file]`

# Text editor swap files

*.swp

*.swo

*~

# Compiled binary files

*.o

<Copy up to line above>

Note that git will not ignore a file that was already tracked before a rule was added to this file to ignore it. In such a case the file must be un-tracked, usually with git rm --cached filename

8. As we expect, we've got our new file to add. Add your changes to git by typing git add .. Running git status now gives us the following output:

# On branch master

#

# Initial commit

#

# Changes to be committed:

#   (use "git rm --cached ..." to unstage)

#

#       new file:   name.txt

#                     

9. Now it's time to commit. Committing your changes to source control generally means that you are in a relatively stable state. It does not mean that you are done with the assignment - that's not committing enough for this class. Commit when when your program is compiling, and a piece of your work is done. The more often you commit, the easier it is to roll back to a stable state, and the more atomic and understandable your changes are. To commit, type git commit


10. By default, git will open up the vim text editor for you to enter your commit message. (If you would rather use nano to edit your commit messages, then run git config --global core.editor "nano"). Git commit messages have this convention:
• The first line is the subject line, which is a concise description with a maximum of 50 characters
• The second line is always blank
• Anything on the third line and after is a more thorough description of the changes.

For this class, the most important element is a well-written subject line. "A few changes" is the worst possible commit message - be descriptive without being verbose (50 characters is short - this parenthetical is 49).
Write a descriptive message for adding the name file, such as "Recording my name for grading".

11. Exiting out of the text editor will automatically finish your commit. When that is done, your output will look something like this:

[master (root-commit) 5d859e9] Recording my name for grading

 1 file changed, 1 insertion(+)

 create mode 100644 name.txt             

12. Now we have one more action: push. We need to push our commits to a remote repository so the instructor can view it and grade it. The instructors have set up a special directory on hamilton, called /pushbox, that allows you to securely push your changes. We have also provided a script that sets up your remote repository properly and hooks up your personal repository with the remote. Here's an example run of the script:

If everything in the script worked, then you should get the output that looks If everything in the script worked, then you should get the output that looks something like this:

Initialized empty Git repository in /pushbox/swen250-01-spring2165-cxn9999-54cd8f737bcb5e8b33916193f56d6e94/

Success!

13. Ok let's push now. The command is git push pushbox master. The output looks like this:

Counting objects: 3, done.

Writing objects: 100% (3/3), 236 bytes, done.

Total 3 (delta 0), reused 0 (delta 0)

Unpacking objects: 100% (3/3), done.

To /pushbox/swen250-01-fall2151-cxn9999-54cd8f737bcb5e8b33916193f56d6e94

 * [new branch]      master -> master

         

14. You're all set up! We've synchronized our repository with our pushbox so that the instructor can see our changes. From here on, we can continue to modify, commit, and push our code right up to the deadline. Now try out the workflow below and review our tips.

Typical Workflow Exercise

Here's the typical workflow we want you to use.

1. Start working by running git status. Commit or remove any changes you might have forgot to deal with before (i.e. start with a clean working tree).
2. Think about how you will break up this work into smaller tasks
3. Edit, compile, test (your typical programming workflow)
4. At the end of one of your mental tasks, add and commit.
5. Continue to complete your other tasks until the assignment is completed.
6. When you are ready to submit your assignment, push your changes.
7. Double-check that all of your changes are pushed with git status.

For this exercise, let's use our FizzBuzz  code into our working tree.

1. Make a subdirectory for Fizzbuzz  - called FizzBuzz.
2. Copy your FizzBuzz  code into your FizzBuzz  directory
3. Commit that code as-is.
4. Now add some comments to your FizzBuzz  source code, and make any other code cleanup that you wish to make.
5. Commit those changes, giving a descriptive message.
6. Push to your pushbox.

Git Tips for swen250

• All of your assignment and projects will be in your personal repository for this course. To speed up grading, please name files and directories exactly as specified in the assignment or project description.
• To check that you have submitted, run these two commands
• git status - to make sure everything has been committed (should say "# On branch master nothing to commit (working directory clean)")
• git push pushbox master - if it says "Everything up-to-date", you have everything pushed and submitted
• Deleted a file? Use either git rm or git add -A . to record that deletion.
• Want to add, commit, push all in one command? Use:

Also, in bash, you can use the up arrow to bring that command back up quickly. If you realize you don't want to commit partway through, then exit your text editor with an empty commit message and everything aborts safely.

• Interested in more Git features? Ask your instructor! It's a very feature-rich tool.
• Git is not a misspelling of "get", it's a self-deprecating joke about Linus Torvalds

Submission: A correctly set up /pushbox

• For this assignment, the instructor will find for your pushbox and make sure it's set up properly.