BROUGHT TO YOU IN PARTNERSHIP WITH

CONTENTS

ö ö Why Get Git?

ö ö Distributed Version Control

Getting Started With Git: ö ö Cloning Existing Projects

ö ö Treeish and Hashes

ö ö The Typical Local Workflow

The De Facto Standard for Version Control ö ö The Remote Workflow

ö ö CVS and Subversion

ö ö Advanced Commands

ORIGINAL BY MATTHEW MCCULLOUGH AND KURT COLLINS

UPDATED BY MATT RASBAND, SENIOR SOFTWARE ENGINEER AT INTERCHANGE

Why Get Git? repository (or "repo" in common parlance) leads to setting up repos
Git is a postmodern version control system that offers the familiar everywhere. It feels frictionless.
capabilities of CVS or Subversion, but doesn't stop at just matching
From there, you'll progress to the second epiphany of being able to
existing tools. Git stretches the very notion of version control systems
share a repository and a changeset directly with a colleague without
(VCS) by its ability to offer almost all its features for use offline and
any complicated setup, without a check-in to a central server, without
without a central server. It is the brainchild of Linus Torvalds, the
direct network connectivity, and without having to worry about
creator of Linux, with the first prototype written in a vitriolic two-
firewalls getting in the way. Git has done technologically for version
week response to the "BitKeeper debacle" of 2005.
control what BitTorrent did for file sharing. It permanently replaced
Today, Git is effectively the de facto standard for software version the spoke and hub structure with a peer-to-peer model, and there's
control and is an expected tool in every developer's toolbox. no turning back. It supports transmitting binary sets of changes
Users reference its blistering performance, usage flexibility, via USB stick, email, or in the traditional style (over a network), but
offline capabilities, and collaboration features as their motivation amazingly, via HTTP, FTP, SCP, Samba, SSH, or WebDAV.
for switching.

Let's get started with Git. You'll be using it like a master in no time at all.

DISTRIBUTED VERSION CONTROL

If you are familiar with one or more traditional or centralized
version control systems like Subversion, there will be several mental
adjustments to make in your migration to Git. The first is that there
is no central server. The second is that there is no central server. The
full history of the repository lives on every user's machine that has
cloned (checked out) a copy of the repository. This is the essence of a
distributed version control system (DVCS).

Once over those hurdles, it is quite liberating to be able to work

entirely independently, versioning any new project that you start,
even in the incubation phase. The ease of setting up a new Git

1
TAKE
CONTROL
of Your Open
Source Software

KNOW WHAT’S IN YOUR CODE WITH FLEXNET CODE INSIGHT

MANAGE COMPLY IDENTIFY INTEGRATE

Open Source Security with OSS Licenses Open Source Security Scanning into Your
and Compliance and Obligations Vulnerabilities DevOps Environment

Never miss evidence of open source in your applications using

FlexNet Code Insight—an end-to-end software composition analysis platform.

1.800.809.5659 | +44 870-871-1111 | FLEXERA.COM

Copyright © 2018 Flexera Software LLC. All other brand and product names mentioned herein
may be the trademarks and registered trademarks of their respective owners.
 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

Getting Started change the directories to either a blank folder or an existing project
that you want to put under version control. Then initialize the
INSTALLING GIT
Git has a very light footprint for its installation. For most platforms, directory as a Git repository by typing the following commands:

you can simply copy the binaries to a folder that is on the executable $ git init
search $PATH . Git is primarily written in C, which means there is a $ git add .
unique distribution for each supported platform. $ git commit -m 'The first commit'

The canonical reference for Git installers can be found on a subpage The first command in the sequence, init, builds a .git directory that
of the official Git site. There are a number of installers available contains all the metadata and repository history. Unlike many other
there for those who don't want to go through the hassle of doing the version control systems, Git uniquely stores everything in just a
installation manually. In addition, also available at the official Git single directory at the top of the project — meaning no pollution in
download site are links to older distributions of the Git binary. every directory.

You can confirm that Git is installed and available with: Next, the add command with the dot wildcard tells Git to start tracking
changes for the current directory, its files, and for all folders beneath.
$ git --version
git version 2.19.1 Lastly, the commit function takes all the "staged" previous additions
and makes them permanent in the repository's history in a
ESTABLISHING USER CREDENTIALS transactional action. Rather than letting Git prompt the user via the
Once you have selected a suitable distribution of Git for your platform, default text editor, the -m option preemptively supplies the commit
you'll need to identify yourself with a username and email address to Git. message to be saved alongside the committed files. Omitting this flag
will use your system's default $EDITOR, falling back to vi as the default.
In a separation of concerns most satisfying to the purist, Git does
not directly support repository authentication or authorization. It It is amazing and exciting to be able to truthfully say that you
delegates this in a very functional way to the protocol (commonly SSH) can use the basics of Git for locally versioning files with just these
or operating system (file system permissions) hosting or serving up the three commands.
repository. Thus, the user information provided during your first Git
setup on a given machine is purely for "credit" of your code contributions. CLONING EXISTING PROJECTS
An equally common use case for Git is starting from someone
With the binaries on your $PATH , issue the following three commands else's repository history. This is similar to the checkout concept
just once per new machine on which you'll be using Git. Replace the in Subversion or other centralized version control systems. The
username and email address with your preferred credentials. difference in a DVCS is that the entire history, not just the latest
version, is retrieved and saved to the local user's disk.
$ git config --global user.name "matthew.
mccullough" The syntax to pull down a local copy of an existing repo is:
$ git config --global user.email "matthew@
ambientideas.com" # ssh protocol (requires SSH credentials to be
established):
$ git config --global color.ui "auto"
$ git clone [email protected]:mrasband/gitrefcard.git

These commands store your preferences in a file named

# https protocol:
.gitconfig inside your home directory (~ on UNIX and Mac, and $ git clone https://github.com/mrasband/
%USERPROFILE% on Windows). gitrefcard.git

If you are intrigued by all the potential nuances of a Git setup, here
The protocol difference often signifies access to the origin repository.
are several in-depth tutorials on setting up Git:
Typically, HTTPS is used for read-only access (or when SSH is not
• Installing Git on Mac, Windows, and Linux configured) and SSH will be used for read-write access; however, this

• Setting Up Git is not a hard-and-fast rule.

• Getting Started and Installing Git The clone command performs several subtasks under the hood. It
sets up a remote (a Git repository address bookmark) named origin
CREATING A REPOSITORY that points to the location [email protected]:mrasband/gitrefcard. git.
Now that Git is installed and the user information is established, you Next, clone asks this location for the contents of its entire repository.
can begin establishing new repositories. From a command prompt, Git copies those objects in a zlib-compressed manner over

3 BROUGHT TO YOU IN PARTNERSHIP WITH

 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

the network to the requestor's local disk. Lastly, clone switches to a more prudent to just directly tell Git to relocate a file and track its
branch named master, which is equivalent to Subversion's trunk, as new destination.
the current working copy. The local copy of this repo is now ready to
$ git mv originalfile.txt subdir/newfilename.txt
have edits made, branches created, and commits issued — all while
online or offline.
If you wish to expunge a file from the current state of the branch,
TREEISH AND HASHES simply tell Git to remove it. It will be put in a pending deletion state
Rather than a sequential revision ID, Git marks each commit with a and can be confirmed and completed by the next commit.
SHA-1 hash that is unique to the person committing the changes, the
folders, and the files comprising the changeset. This allows commits $ git rm fileyouwishtodelete.txt
to be made independent of any central coordinating server.
VIEWING
A full SHA-1 hash is 40 hex characters:
Daily work calls for strong support of viewing current and historical
b0c2c709cf57f3fa6e92ab249427726b7a82d221.
facts about your repository, often from different, perhaps even
orthogonal points of view. Git satisfies those demands in spades.
To efficiently navigate the history of hashes, several symbolic
shorthand notations can be used as listed in the table below.
STATUS
Additionally, any unique sub-portion of the hash can be used. Git
To check the current status of a project's local directories and files
will let you know when the characters supplied are not enough to be
(modified, new, deleted, or untracked), invoke the status command:
unique. In most cases, four or five characters are sufficient.
$ git status
TREEISH DEFINITION
HEAD The current committed version DIFF
HEAD^1, HEAD~1 One commit ago A patch-style view of the difference between the currently edited and
HEAD^^, HEAD~2 Two commits ago committed files or any two points in the past can easily be summoned.
HEAD~N N Commits ago The .. operator signifies a range is being provided. An omitted
User definited tag was applied to the code when second element in the range implies a destination of the current
RELEASE-1/0
it was certified for release
committed state, also known as HEAD:

The complete set of revision specifications can be viewed by typing:

$ git diff
$ git diff 32d4
$ git help rev-parse
$ git diff --summary 32d4..
Treeish can be used in combination with all Git commands that accept
a specific commit or range of commits.
Depending on the Git distribution, a utility called diff-highlight
Examples include: will be included to make diffs easier to visualize by highlighting
word-level diffs instead of the default line level changes. Make sure
$ git log HEAD~3..HEAD
diff-highlight is available in your $PATH and enable it with:
$ git checkout HEAD^^
$ git merge RELEASE-1.0
$ git config --global core.pager "diff-highlight |
$ git diff HEAD^..
less -r"

The Typical Local Workflow Git allows for diffing between the local files, the stage files, and the
committed files with a great deal of precision.
EDITING
Once you've cloned or initialized a new Git project, just start changing
COMMAND DEFINITION
files as needed for your current assignment. There is no pessimistic
locking of files by teammates. In fact, there's no locking at all. Git Everything unstaged (not git added) diffed to the
git diff
last commit
operates in a very optimistic manner, confident that its merge
capabilities are a match for any conflicted changes that you and your git diff- Everything staged (git added) diffed to the last
colleagues can craft. cached commit

If you need to move a file, Git can often detect your manual relocation Everything unstaged and staged diffed to the last
git diff HEAD
commit
of the file and will show it as a pending "move." However, it is often

4 BROUGHT TO YOU IN PARTNERSHIP WITH

 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

LOG Specifying a folder name as the target of a git add recursively stages
The full list of changes since the beginning of time (or optionally, since files in any subdirectories.
a certain date) is right at your fingertips, even when disconnected
The -i option activates interactive add mode, in which Git prompts
from all networks:
for the files to be added or excluded from the next commit.
$ git log
$ git log --since=yesterday $ git add -i
$ git log --since=2weeks
The -p option is a shortcut for activation of the patch** sub-mode of
BLAME
the interactive prompt, allowing for precise pieces within a file to be
If trying to discover why and when a certain line was added, cut to the
selected for staging.
chase and have Git annotate each line of a source file with the name
and date it was last modified: $ git add -p

$ git blame <filename.ext>

It's a common use case to need to exclude some files in a project
from being tracked by Git. This is supported through a .gitignore file
STASHING
per project that is a list of file/directory patterns to be automatically
Git offers a useful feature for those times when your changes are in an
ignored. More information is available here.
incomplete state, you aren't ready to commit them, and you need to
temporarily return to the last committed (e.g. a fresh checkout). This
$ cat .gitignore
feature is named stash and pushes all your uncommitted changes
# If you find yourself ignoring temporary files
onto a stack.
generated by your text editor
# or operating system, you probably want to add a
$ git stash
global ignore instead:
$ git stash --include-untracked
# git config --global core.excludesfile '~/.
When you are ready to write the stashed changes back into the gitignore_global'
working copies of the files, simply pop them back on the stack. node_moles/
**/__pycache__/
$ git stash pop /log/*
/tmp/*
!/log/.keep
ABORTING
If you want to abort your current uncommitted changes and !/temp/.keep
.DS_Store
restore the working copy to the last committed state, there are two
commands that will help you accomplish this.
COMMITTING
$ git reset --hard
Once all the desired blobs are staged, a commit command
Resetting with the hard option recursively discards all your currently transactionally saves the pending additions to the local repository.
uncommitted (unstaged or staged) changes. The default text $EDITOR will be opened for entry of the commit
message; if unset, vi is the default.
To target just one blob, use the checkout command to restore the file
to its previous committed state. $ git commit

$ git checkout -- src/main/java/com.mrasband. Git requires that a message be present upon commit; leaving
platform/models/Person.java the message blank will abort the commit and leave the staged blobs
in place.

ADDING (STAGING)
The default editor can be changed with a Git configuration or by
When the developer is ready to put files into the next commit, they
setting the $EDITOR environment variable:
must be first staged with the add command. Users can navigate to
any directory, adding files item by item or by wildcard. $ git config --global core.editor <emacs|vim|subl
--wait|atom --wait>
$ git add <filename, directory name, or wildcard>
$ git add submodule1/Application.java To supply the commit message directly at the command prompt:
$ git add .
$ git add *.java $ git commit -m "<your commit message>"

5 BROUGHT TO YOU IN PARTNERSHIP WITH

 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

To view the statistics and facts about the last commit: MERGING
Like other popular VCSes, Git allows you to merge one or more
$ git show
branches into the current branch.
If a mistake was made in the last commit's message, edit the commit
$ git merge <branch one>
text while leaving the changed files as-is with: $ git merge <branch one> <branch two>

$ git commit --amend

If any conflicts are encountered, which is rare with Git, a notification
message is displayed and the files are internally marked with
BR ANCHING >>>>>>>>> and <<<<<<<< around the conflicting portion of the file
Branching superficially appears much the same as it does in other
contents. Once manually resolved, git add the resolved file then
version control systems, but the difference lies in the fact that Git
commit in the usual manner.
branches can be targeted to exist only locally or be shared with (pushed
to) the rest of the team. The concept of inexpensive local branches REBASE
increases the frequency in which developers use branching, opening Rebasing is the rewinding of existing commits on a branch with the
it up to use for quick private experiments that may be discarded if intent of moving the "branch start point" forward, then replaying the
unsuccessful, or merged onto a well-known branch if successful. rewound commits. This allows developers to test their branch changes
safely in isolation on their private branch just as if they were made on
$ git branch <new branch name> <from branch>
$ git branch <new branch name> top of the mainline code, including any recent mainline bug fixes.

$ git rebase <source branch name>

CHOOSING A BRANCH
$ git rebase <source branch name> <destination
Checking out (switching to) a branch is as simple as providing its name:
branch name>

$ git checkout <branch name>

TAGGING
Local and remote branches are checked out using the same In Git, tagging operates in a simple manner that approximates other
command, but in somewhat of a radical change of operation for users VCSes, but unlike Subversion, tags are immutable from a commit
coming from other systems like Subversion, remote branches are standpoint and must be unique. To mark a point in your code timeline
read-only until "tracked" and copied to a local branch. Local branches with a tag:
are where new work is performed and code is committed.
$ git tag <tag name>
$ git branch <new branch> <from branch> $ git tag <tag name> <treeish>
$ git checkout <new branch>

Or alternatively, in a combined command: AUTOMATION WITH HOOKS

Git runs a standard set of hooks during user actions. Users can define
$ git checkout -b <new branch> <from branch> custom scripts to be run that could be utilized to interrupt actions
for code quality, spell checking, testing, etc. There are samples pre-
Starting with Git 1.6.6, a shorthand notation can be used to track a
installed in .git/hooks. Details are available in the Git book.
remote branch with a local branch of exactly the same name when no
local branch of that name already exists and only one remote location
THE REMOTE WORKFLOW
is configured. Working with remote repositories is one of the primary features of

$ git checkout <remote and local branch name> Git. You can push or pull, depending on your desired workflow with
colleagues and based on the repository operating system file and
protocol permissions. Git repositories are most typically shared via
LISTING BRANCHES
SSH, though a lightweight daemon is also provided.
To list the complete set of current local and remote branches known
to Git:
Git repository sharing via the simple daemon is introduced here. Sharing

$ git branch -a over SSH and Gitosis is documented in the Git Community Book.

The local branches typically have simple names like "master" and REMOTES
"experiment". Local branches are shown in white by Git's default While full paths to other repositories can be specified as a source or
syntax highlighting while the currently tracked branch is green with destination with most Git commands, this quickly becomes unwieldy
an asterisk prefix. Remote branches are prefixed by remotes and are and a shorthand solution is called for. In Git-speak, these bookmarks
shown in red. of other repository locations are called remotes.

6 BROUGHT TO YOU IN PARTNERSHIP WITH

 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

A remote called origin is automatically created if you cloned a remote $ git bundle create catchupsusan.bundle HEAD~8..
repository. The full address of that remote can be viewed with: HEAD
$ git bundle create catchupsam.bundle
$ git remote -v --since=10days master

To add a new remote name: These diffs can be treated just like any other remote, even though
they are a local file on disk. The contents of the bundle can be
$ git remote add <remote name> <remote git
address> inspected with ls-remote and the contents pulled into the local
$ git remote add upstream [email protected]:mrasband/ repository with fetch. Many Git users add a file extension of .bundle as
gitrefcard.git a matter of convention.

$ git ls-remote catchupsusan.bundle

PUSH $ git fetch catchupsam.bundle
Pushing with Git is the sending of local changes to a colleague or
community repository with sufficiently open permissions as to allow
GUIS
you to write to it. If the colleague has the pushed-to branch currently Many graphical user interfaces have gained Git support in the last
checked out, they will have to re-checkout the branch to allow the two years. The most popular IDEs and editors have excellent Git
merge engine to potentially weave your pushed changes into their integration today.
pending changes.
GITK AND GIT-GUI
By default, Git will only push branches, however to share tags Standard Git distributions provide two user interfaces written in Tcl/
marking immutable releases requires an additional flag: Tk. Git-gui offers a panel by which to select files to add and commit,
as well as type a commit message. Gitk offers a diagram visualization
$ git push --tags
of the project's code history and branching. They both assume the
current working directory as the repository you wish to inspect.
FETCH
To retrieve remote changes without merging them into your local $ gitk
branches, simply fetch the blobs. This invisibly stores all retrieved
objects locally in your .git directory at the top of your project TOWER, SOURCETREE, AND OTHERS
structure, but waits for further explicit instructions for a source and There are a number of GUIs out there for Git that aren't officially

destination of the merge. released along with Git. Some of them include significant advanced
functionality and are available on multiple platforms. Some of the
$ git pull
more widely used ones include Tower, SourceTree, GitEye, and GitHub
$ git pull <remote name>
Desktop. Unfortunately, GitHub Desktop currently only works with
$ git pull <remote name> <branch name>
GitHub and GitHub Enterprise repositories. However, given the wide
use of GitHub as an online repository, it's likely that you'll run into the
PULL
GitHub Desktop client at some point.
Pulling is the combination of a fetch and a merge as per the previous
section all in one seamless action.
IDES
$ git pull Java IDEs including IntelliJ, Eclipse (eGit), and NetBeans (NBGit) all offer
$ git pull <remote name> native or simple plugin support for Git through their traditional source
$ git pull <remote name> <branch name> code control integration points. However, there are a number of other
applications that also offer direct Git integration, as well. This includes
In the cases in which a merge commit may not be desired and the
applications such as Sublime Text, Atom, VS Code, Vim, and Emacs.
rebasing behavior is preferred, pull supports a rebase flag.
Numerous other platform-native GUIs offer graphically rich history
$ git pull --rebase <remote name> <branch name>
browsing, branch visualization, merging, staging, and commit features.

BUNDLE CVS AND SUBVERSION

Bundle prepares binary diffs for transport on a USB stick or via email. On the interoperability front, the most amazing thing about Git is its
These binary diffs can be used to "catch up" a repository that is ability to read and write to a remote Subversion or CVS repository
behind otherwise too stringent of firewalls to successfully be reached while aiming to provide the majority of the benefits of Git on the local
directly over the network by push or pull . copy of a repository.

7 BROUGHT TO YOU IN PARTNERSHIP WITH

 GETTING STARTED WITH GIT: THE DE FACTO STANDARD FOR VERSION CONTROL

CLONING ADVANCED COMMANDS

To convert a Subversion repository that uses the traditional trunk, Git offers commands for both the new user and the expert alike. Some
tags, and branches structure into a Git repository, use a syntax very of the Git features requiring in-depth explanations can be discovered
similar to that used with a traditional Git repository. through the resources links below. These advanced features include
the embedded (manpage-like) help and ASCII art visualization of
$ git svn clone --stdlayout <svn repository url>
branch merge statuses with show-branch . Git is also able to undo
Please be patient, and note the progress messages. Clones of large the last commit with the revert command, binary search for bisect
Subversion repositories can take hours to complete. the commit over a range of history that caused the unit tests to begin
failing, check the integrity of the repository with fsck , prune any
PUSHING GIT COMMITS TO SUBVERSION orphaned blobs from the tree with gc , and search through history
Git commits can be pushed transactionally, one-for-one, to the cloned with grep . And that is literally just the beginning.
Subversion repository. When the Git commits are a good point for
sharing with the Subversion colleagues, type: This quick overview demonstrates what a rich and deep DVCS Git truly
is, while still being approachable for the newcomer to this bold new
$ git svn dcommit collaborative approach to source code and version control.

RETRIEVING SUBVERSION CHANGES

When changes are inevitably made in Subversion and it is desired to
freshen the Git repo with those changes, rebase to the latest state of
the Subversion repo.

$ git svn rebase

Written by Matt Rasband, Senior Software Engineer at Interchange

Matt Rasband is a software engineer with a favoritism toward backend and distributed systems. He has worked in the
financial services industry in a number of capacities, from Financial Advisor to Team Lead and Senior Software Engineer.
Over his career he led a multi-billion-dollar company from a monolithic application to a microservices architecture. When
he isn’t writing Java or Python, or learning something new, he can be found in the mountains of Colorado sipping coffee,
mountain biking, and spending time with his wife and their high-energy toddler.

Devada, Inc.
600 Park Offices Drive
Suite 150
Research Triangle Park, NC
DZone communities deliver over 6 million pages each
month to more than 3.3 million software developers, 888.678.0399 919.678.0300
architects, and decision makers. DZone offers something for
Copyright © 2019 DZone, Inc. All rights reserved. No part of this publication
everyone, including news, tutorials, cheat sheets, research
may be reproduced, stored in a retrieval system, or transmitted, in any form
guides, feature articles, source code, and more. "DZone is a or by means electronic, mechanical, photocopying, or otherwise, without
developer’s dream," says PC Magazine. prior written permission of the publisher.

8 BROUGHT TO YOU IN PARTNERSHIP WITH