Intro to Git and Github


Girl Develop It is here to provide affordable and accessible programs to learn software through mentorship and hands-on instruction.

Some "rules"

  • We are here for you!
  • Every question is important
  • Help each other
  • Have fun

About the Instuctor

  • Shelby Heinecke
  • Math/CS PhD Candidate at UIC
  • Several years of teaching math/cs courses
  • How I use git/github:
    • website
    • research code
    • portfolio


Tell us about yourself.

  • Who are you?
  • What do you hope to get out of the class?
  • Who was your favorite character as a child?

What we will cover today

  • What is version control and why should we care?
  • Basics of git -- the essential commands
  • "Gitting" social with GitHub

What is version control?

Version control allows you (and your team) to do two powerful things


Create anything with other people, from academic papers to entire websites and applications.

Track and revert changes

Mistakes happen. Wouldn't it be nice if you could see the changes that have been made and go "back in time" to fix something that went wrong?

Working without Version Control

Trying to make a grocery list with 5 people and no version control

The Horror!

Working with Version Control

Successfully making a grocery list with 5 people and version control

Rainbows and bunny rabbits!

Brief history of Version Control

1990s -- CVS (Concurrent Version Systems)

2000s -- SVN (Apache Subversion)

2005 -- Git (well, Git)

Version Control Types

Centralized Version Control

Examples: CVS, SVN

One central server, each client (person) checks out and merges changes to main server

Distributed Version Control

Examples: Git, Mercurial

Each client (person) has a local repository, which they can then reconcile with the main server.

Version Control Distribution

Version control share between Bazaar, CVS, Git, Mercurial and Subversion

Version Control Change

Version control popularity change between 2010 and 2013 between Bazaar, CVS, Git, Mercurial and Subversion

Intro to Git

Goals of Git Design

  • Fast -- add to your team and code base quickly
  • Distributed (see slide above)
  • Each commit has a corresponding hash (track changes from everyone)
  • Everyone has a local copy of the history

Installation and Setup

Install git

Download latest version of Git

Installation and Setup

Setup ssh keys

             $ cd ~/.ssh
# If you don't already have this folder, don't worry; keep going.

$ ssh-keygen -t rsa -C ""
# Use your github email address here.
# Generating public/private rsa key pair.
# Enter file in which to save the key (/Users/you/.ssh/id_rsa): [Press enter]

Enter passphrase (empty for no passphrase): [Type a passphrase]
# Enter same passphrase again: [Type passphrase again]
# Each time your local repo talks to github, it will prompt you for
#this passphrase.

Installation and Setup

Get SSH Key

Your identification has been saved in /Users/you/.ssh/id_rsa.
# Your public key has been saved in /Users/you/.ssh/
# The key fingerprint is:
# 01:0f:f4:3b:ca:85:d6:17:a1:7d:f0:68:9d:f0:a2:db

$ pbcopy < ~/.ssh/
# Copies the file to your clipboard

Installation and Setup

Add SSH Key to Github

Steps to add SSH key to github account

Installation and Setup

Setup name and email in gitconfig

$ git config --global "Your Name Here"
# Sets the default name for git to use when you commit

$ git config --global ""
# Sets the default email for git to use when you commit

$ git config --list

Your first Local Repository

Go to home directory

  cd ~/
  cd Users\username

Create a "working directory"

  mkdir my-first-repo
  cd my-first-repo

Initialize repository with Git

  git init
  git status

Add files

Create a new hello_world.txt file in your new folder

Check repo status

  git status

Tell Git to track our new file

  git add hello_world.txt
  git status

File is now tracked by Git

Changes and commits

Open hello_world.txt and add some more text

  git status

Stage and commit the change

  git add hello_world.txt
  git commit -m "First commit. Added hello world to repository."

What did we just do??

How is this all different than just saving a file?

  • When we add a new file, we tell Git to add the file to the repository to be tracked
  • When we stage an existing file (also with the keyword 'add'), we are telling Git to track the current state of our file
  • A commit saves changes made to a file, not the file as a whole. The commit will have a 'hash' so we can track which changes were committed when and by whom.

Look at our progress

  git log

  commit [HASH HERE]
  Author: Your name 
  Date:   [DATE HERE]

      First commit. Added hello world to repository.


  1. Commit 5 new lines to your hellow_world.txt file. Then remove one of the lines as a 6th commit.
  2. Open your git log
  3. Use git diff (see below) to compare a pair of your commits using their hash numbers
  4. Exit diff mode by typing "q"

  git diff [HASH1 HERE] [HASH2 HERE]

Look at our progress, visually

Image of commits for this curriculum repo

Nobody's Perfect

Undoing local changes

If you haven't committed yet

Open hello_world.txt and add some new text

  change hello_world.txt
  git checkout hello_world.txt

Look at hello_world.txt. Your changes are gone.

Nobody's Perfect

Undoing staged changes

Open hello_world.txt and add some new text

git add hello_world.txt
git reset HEAD hello_world.txt
git checkout hello_world.txt

Look at hello_world.txt. Your changes are gone.

Nobody's Perfect

Undoing committed changes

Open hello_world.txt and add some new text

git add hello_world.txt
git commit -am "Changing and committing some lines"
git log --pretty=oneline
git revert [HASH]

Look at hello_world.txt. Your changes are gone.

Nobody's Perfect

Remove a file from staging

Create new file my_new_file.txt

git add my_new_file.txt
git reset my_new_file.txt

Nobody's Perfect

Delete a file

Create new file my_other_file.txt

git add my_other_file.txt

Manually delete your file

git rm my_other_file.txt


  • Develop different code on the same base
  • Conduct exploratory work without affecting the work on master branch
  • Incorporate changes to your master branch only when you are ready


Create a new branch called version2

git checkout -b version2

Add new lines to hello_world.txt

git add hello_world.txt
git commit -m "Adding changes to version 2"


Switching branches

See all branches. Branch with * is active

git branch

Switch to master and look at hello_world.txt

git checkout master

Switch to version2 and look at hello_world.txt

git checkout version2



Branching from a previous commit:
  1. In master branch, use git log to find a previous commit to start from.
  2. Use git checkout [HASH] to load that version to the HEAD
  3. Start a new branch
  4. Open hello_world - what does it look like?
  5. Commit a change. Look at the git log.
  6. Switch to master branch. Look at the git log. Do you see the newly commited change?


Merge to get changes from one branch into another*

Switch to master and merge changes

git checkout master
git merge version2

*rebase is another option, but will not be covered in this workshop



For which scenarios would a merge conflict occur?

  1. I only change line 30 and my colleague changes only line 10.
  2. I delete line 10 and my colleague changes line 10.
  3. I change line 10 and my colleague deletes line 10.
  4. We both change the contents of line 30.


Merge conflicts

Change first line in hello_world.txt in master branch

git add hello_world.txt
git commit -m "Changing first line in master"

Change first line in hello_world.txt in version2 branch

git checkout version2
# open hello_world.txt and change first line
git add hello_world.txt
git commit -m "Changing first line in version2"


Merge conflicts, cont.

Merge from master into version2

git merge master

You will be notified of a conflict. Go to the file and fix the problem. Then commit your edits.


  • Launched in 2008
  • Leader in Social Coding
  • GitHub is a commercial site that allows users to host Git repositories publicly and privately
  • Open source projects host or mirror their repositories on GitHub
  • Post your own code for others to use or contribute to
  • Use and learn from the code in other people's repositories


Create your first repository

How to create a new repository. Image from


Create your first repository

How to create a new repository. Image from



While a README isn't a required part of a GitHub repository, it is a very good idea to have one. READMEs are a great place to describe your project or add some documentation such as how to install or use your project. You might want to include contact information - if your project becomes popular people will want to help you out.


Get Local Repository of GitHub Repo

cd ../ # Back in root directory
mkdir hello-github
cd hello-github
git init
git remote add origin
git pull origin master


Push to GitHub Repo

Edit the ReadMe file

git add README
git commit -m "Updating readme file"
git push origin master

Go look at your github repo online


Pulling from remote repository

If you are working with a team, you want to make sure that you have everyone's changes before pushing your changes to the GitHub repo

# Commit local changes
git commit -m "My latest commit"
# Pull changes other people have made
git pull origin master
# Fix any conflicts (see merge conflicts above) and commit
git commit -m "Fixing merging conflicts"
# push local changes to GitHub
git push origin master


  1. Go to your github repo and create a new text file called Test2.
  2. Add a line to the Readme.
  3. Pull these changes to your local repository.


  • There are MILLIONS of public repositories on GitHub
  • If you want to use or contribute to a repository, you can fork it.


How to fork a repository. Image from


Fork octocat's "Spoon-Knife" repo



Clone to get a local repository of your fork

cd ../

git clone


git remote add upstream
# Assigns the original repository to a remote called "upstream"

git fetch upstream
# Pulls in changes not present in your local repository, without modifying your files


Clone your fork of the Spoon-Knife repo

Pull Requests

  • After you fork and clone a repository all pushed changes will go to your fork
  • These changes will not affect the original repository
  • If you would like to get your changes to be incorporated into the original repo, you can submit a pull request


Make some changes to one of more of the files. Add, commit, and push the changes to your fork.

Starting a pull request

How to initiate a pull request. Image from


Send octocat a pull request.

Previewing and sending pull request

How to preview and send a pull request. Image from

Managing pull requests

How to manage pull requests is out of the scope of this short workshop, but you can learn more from the Github Collaborating Tutorials


Local Repo

  • add, stage
  • commit
  • diff
  • delete, revert
  • branch, merge

Remote Repo

  • push, pull
  • fork, clone
  • pull request

Bonus Content

  • Open Source Projects
  • GitHub Desktop
  • GitHub Pages