GIT-IFICATION

AGENDA
What is GIT?
Cloning a remote repository
Creating a repository
Git config
Adding remote repository
GIT trees
Committing to local repo and pushing commits to remote repo
Pulling code from remote repo
Switching working directory to a past commit
Undoing changes(erasing local commits)
Merging and Conflict Resolution
GIT DiffTool and MergeTool
Git Panoramic View
Stashing
Reverting remote repo to previous commit
GIT-o-LOGY
Ten Command(ments)
PUSH/PULL WORKFLOW
Common Use-Cases
Git related software

WHAT IS GIT?
It is a Distributed Version Control System.
Developed by Linux Torvalds (Founder of Linux).
Each developer machine has his/her own local repository to which code can

be committed.

Code can be committed without an internet connection as repository is

local.

Code commits in local repository can be pushed to remote repository which

could be shared with other developers.

We could sync our repository with multiple repositories.

Merging and Branching is seamless.

CLONING A REPOSITORY
It copies the contents from a remote repository to a local repository.
Navigate to any folder on your file system using GIT CMD.
Run the following command.

> git clone http://USTR-ERL-5966.na.uis.unisys.com/USFN/git-playground.git

It essentially copies two folder hierarchies
.git folder
project content

All the git commands work on the .git folder. A folder turns into a repository

if it contains .git folder.

All the GIT commands can run only in the folder containing .git folder.

CREATING A REPOSITORY
To create a repository on your local system.
All you have to do is run the following command in the folder where you

want your repository to be created.

> git init

When you run git init and .git folder is created which indicates that a

repository has been created.

git init is all you need to put a folders content in version control. We are

good to commit code to our local repository now.

GIT CONFIG
Global Settings
> git config --global user.name Gitty Kumar
> git config --global user.name gitkum@gmail.com

Project settings
> git config user.name Gitty
> git config user.email Gitty@gmail.com

Storing credentials so that we dont have to type often. Note that password is

stored as plain text in .gitcredentials file.

> git config global credential.helper store

The .gitconfig file is located in .git folder in each local repository and also in the

users home directory.

ADDING REMOTE REPOSITORY

Generally, when we clone from a particular repository the origin alias is

set automatically

> git remote add origin http://IP/path/to/repository

Also, if we want to change the origin URL, we could do so by the following

command

> git remote set-url origin origin http://IP/path/to/repository

GIT TREES
Working Directory: It holds the actual files which we would be working on. It

is the area where we would be making modifications to the files.

Staging/Index: It is the staging area which snapshot is prepared. Note that

it is a single file.

Repository: Maintains a series of committed snapshots.

COMMITTING TO LOCAL REPO AND PUSHING

COMMITS TO REMOTE REPO
GIT follows a two stage commit process.
First we need to execute git add which adds the changes to the staging/index.

> git add . (Add all the files in the current directory to the staging/index area)
Next we need to execute git commit which adds the staged changes to the repository

> git commit m Implemented a new feature (Commits the changes in staging area
to the repository)
Next we need to push our commits to remote repository by issuing the following

command. Note that origin is an alias for the URL which is stored in .gitconfig and
master is the name of the branch to which we want to push our changes.
> git push origin master

Note: Typically pushing code into repository might not be straight forward and we might
have to follow the push/pull workflow flowchart mentioned in the later slides.

PULLING CODE FROM REMOTE REPO

We have to first fetch the code from the remote repository by issuing the following command.

It gets the code from remote repository but does not affect with our working directory. It is like
a preview of changes which have taken place in remote repository.
> git fetch origin master

Then run the following command

> git status

If it says that the branch and origin/master have diverged, it means that we have different

commits in local and remote repository. We need to run the following command to re-apply
our commits on top of the remote commits.

> git rebase origin/master

If at all, we have no committed changes, then we could use the following command. It is a

called a fast forward merge and no additional commit will be created.

> git merge origin master

Note: Please dont use git pull origin master

SWITCHING WORKING DIRECTORY TO A PAST

COMMIT
Revert a working directory to a past commit.

> git checkout 1asd9rrtretero

It affects the working directory. It is useful when we want to see build the application from the code
on a past commit. Whenever the above command is run it will put HEAD in a detached state.
When head is in detached state, we should not do any commits. After we check that the code on a
particular commit we can again take the head to a stable state by the following command.
>git checkout master
Used to navigate between branches.

> git checkout feature-2

Assuming if there is another branch by name feature-2. It affects the working directory. When we
checkout a branch three things happen.
The HEAD points to the branchs latest commit.
Populates the staging/index with the snapshot of the commit.
Checks out the contents of the file in the staging/index area to the working directory

HEAD is said to be in detached state if it is not pointing to any of the

branches(Ex:master)

UNDOING CHANGES(ERASING LOCAL COMMITS)

Erases history of commits from the local repository and resets repository to the

commit mentioned in the command. Resets the staging area to the repository. It
affects only the staging area and repository.
> git reset 123asfasdf32434

Same as the above command but it changes the files in the working directory. After

this command the working directory, staging and repository are in sync
> git reset --hard12sresfasdfs343

Resetting your working directory to the remote repositorys latest commit. The below

is useful when you have done some wrong changes and want to go back to the
remote repositorys state.

> git reset --hard origin/master

Be cautious when you use reset hard as your local changes will be overridden.
Never try to run reset hard on public commits(commits which are pushed to
remote repository) as it might affect other developers and cause confusion.

MERGING AND CONFLICT RESOLUTION

What is a merge conflict and when does it happen?
Whenever there is a difference of commits between our local repo branch and the

remote repository branch there is said to be a merge conflict when we pull code
from remote repository(a.k.a. Upstream.).
For instance
Remote repo might have the following commits (a<-b<-c<-d) c being the
latest commit
Our local repo might have the following commits (a<-b<-e<-f) with f being the
latest. When
At this point when we issue git pull there is a merge conflict so git will try to
resolve conflicts automatically but sometimes manually intervention is required in
case if the same file was modified in c and e commit.
The below command gets the latest changesets from the remote repository and
merges them with code in the working directory. If merging is successful this
command executes successfully else we have to manually merge.
> git pull origin master

GIT DIFFTOOL AND MERGETOOL

The following are needed to configure the diff tool and mergetool. We

would be using Meld.

> git config --global diff.tool meld

> git config --global merge.tool meld
Ensure that the following lines are added to the .gitconfig of your

respective user directory.

[mergetool "meld"]
cmd = \"C:\\Program Files (x86)\\Meld\\Meld.exe\" $LOCAL $MERGED
$REMOTE
[difftool "meld"]
cmd = \"C:\\Program Files (x86)\\Meld\\Meld.exe\" $REMOTE $LOCAL

GIT PANAROMIC VIEW

STASHING
In fact, most of the times, we might have some uncommitted changes and when we try to

issue a git pull it fails to do so because of the following error.

Your local changes to the following files would be overwritten by merge: Please commit or stash them

At this stage, we might not be interested to commit as we might have not completed the
feature. Instead, we could stash which means temporarily saving your work in a separate
place.
Just execute the following command
> git stash
After this you could run
> git pull
Which will execute successfully. Now you must be wondering how to get back those
uncommitted changes. Just issue the below command which will get the uncommitted
changes back to the working directory.
> git stash pop

REVERTING REMOTE REPO TO PREVIOUS COMMIT

The word revert has a different meaning in GIT. Let us say we have a

series of commits with E being the latest

A<-B<-C<-D<-E<-F

Revert means undoing the changes made by a specific commit. So, if we

issue
> git revert D
Whatever changes made by D will be undone. Please note that it does not
mean that the code will be reverted to the D commit.

GIT-O-LOGY
HEAD: Generally, HEAD should point to a branch. It can also point to a commit

but then it is called a detached HEAD.

Branch: It is a pointer to the latest commit. Every GIT repository has a default

branch called master.

Each of the branches are also called as head but uppercase HEAD refers to

the current branch.

Commit: It is a snapshot of the entire repository at the point of commit.

GIT Trees: There are three trees namely Working Directory, Staging/Index

Area and the Local repository.

TEN COMMAND(MENTS)
git clone : Used to clone a remote repository
git add: Used to add files to the staging area.
git commit: Commits the changes present in the staging area to the local repository.
git checkout: Used to switch between branches,
git reset: Erase commits.
git push: Pushes code commits from local repository to remote repository.
git pull:

Pulls code commits from remote repository to local repository and then
merges code. So the changes are reflected in the working directory. So
PULL=FETCH+MERGE

git fetch: Pulls code commits from remote to local repository.

git merge: Merges code from local repository to working directory.
git revert: Undoes a commit by adding a new commit.
git stash: Temporarily storing your uncommitted changes

git add .

Start

git fetch origin master

(Adds the modified files to the

staging/index area)

(Fetching commits from remote repository to local repository)

git commit mMessage

(Commits the changes to the local repository)

git rebase origin/master

(It replays your commits on top of remote commits, thereby
maintaining a linear history.)

PUSH/PULL
WORKFLOW

git push origin master

(Pushes the commit from local repository to the
remote repositorys(origin) master branch )

No (Nothing to rebase)

Yes

Is rebase
successful??
No(because of
conflicts)

Is Push
successful??

No (Because remote repository

contains changes which we dont
have)

Yes

git merge
origin/master
(Merges the changes)

No (Working directory contains

uncommitted changes)

git stash

( Stores your uncommitted changes safely so

that they are not disturbed by rebase/merging)

No

Is merge
successful?
?

Yes

Resolve conflicts manually

No

Did you
execute git
stash before

Breathe a sigh of relief

We are done

Yes

git stash pop

( Get the uncommitted changes back to working
directory)

No (Because of merge
conflicts)

COMMON USE-CASES
Ensuring that local working directory exactly resembles the remote

repository. Note that your local commits/uncommitted changes will be lost.

> git fetch origin master

> git reset hard origin/master

Reverting changes to a particular commit in remote repository. Let us say

we have the following sequence of commits

A<-B<-C<-D<-E with D being the latest commit

Now if we want to take the code to a version B that means we need to
undo C,D,E
> git revert C D E
> git push origin master

GIT RELATED SOFTWARE

GIT supports both CLI (Command Line Interface) namely
GIT CMD

and GUI (Graphical User Interface) open source clients namely

GIT GUI
Atlassian Source Control

GIT downloads (contains default CLI and GUI):

https://git-scm.com/download/win

Eclipse has a plugin name E-git for issuing git commands within eclipse
http://www.vogella.com/tutorials/EclipseGit/article.html

Diff and Merge Tool

https://download.gnome.org/binaries/win32/meld/3.14/Meld-3.14.0-win32.msi (for

windows)