Find us

611 North Brand, Boulevard, 11th floor
Glendale, CA 91203

Google Maps
Get in touch

Have a question for the mobileforming team?
T: 818-649-3299


Interested in joining our
amazing team? Email us on:

Current vacancies
New business

For new business enquiries please contact:
Jonathan Arnott
T: 951-229-5790

© 2018 mobileforming LLC. All rights reserved.

featured post

Kotlin Equality—Not All Equal Comparisons Are Created Equal

read post

Everyday Git

By Jeffrey Thomas

Posted on: 01 November 2019

A UI client spoiled me with my first introduction to Git. Everything was magic. All that was required was a click here and a click there; I never understood what was going on. Don't get me wrong, I do not have anything against such tools, but at what point does one click become too many? For me personally, not having to reach for the mouse or trackpad is always a win. Another advantage to learning the command line is that it is a natural path to understand the underpinnings of Git. On this journey of discovery, I realized there are a few commands that I would almost always use due to the nature of Git flow we practice. Putting these commands together may help other users get a quicker grasp of the basics. Let's get started.

Make sure you have installed the latest Git. If you are on a Mac, like I am, you may want to override the Git that comes with Mac in order to get the latest version.

My preference is to use Homebrew:

brew install git

Keep an eye out on the install report. If you see something like:

Error: The `brew link` step did not complete successfully

The formula built, but is not symlinked into /usr/local

Could not symlink bin/git

This is because a conflict of existing Git came with your Mac. Follow the next steps:

Optional: You can remove the Mac Git with:

rm '/usr/local/bin/git'

or just run:

brew link --overwrite git

You can confirm by checking:

git --version


Additional Tip:

Installing Git via Homebrew comes with a cool perk. This operation installs bash or zsh completion commands.

Alternatively, if it did not or you did not change your Git, you can install bash_completion via Homebrew like:

brew install bash-completion.


To get this working correctly, you want to edit your .bash_profie (or shell equivalent) to contain:

if [ -f $(brew --prefix)/etc/bash_completion ]; then

. $(brew --prefix)/etc/bash_completion


And now you can use this to get hints and completions:

git <Tab> <Tab>

Just <Tab> <Tab> on any partial Git command to get all options or completions.


I. Create a Repository 

The very first step in managing a repository would be to initialize and setup your source as a git repository.

Let’s assume you have a working project directory called my-awesome-project:


git init


If you're starting with nothing:

git init

This creates a new Git repository. Most other Git commands are not available outside of an initialized repository, so this is usually the first command you'll run in a new project.


Your very first step may be cloning an existing remote repository:

git clone ssh://

cd my-awesome-project


II. Create a Branch 

After cloning a repository, the most common next step would be to create or checkout a desired branch before making changes.

To Create a New Branch

Having cloned or created a new repository, you are most likely checked out on the master branch. To create a new local branch from the current branch:

git checkout -b

To Checkout a Desired Branch

Let's figure out which branch to create our new branch from.

List all available remote branches:

git branch -r

e.g. output


If the list is too long, I like to pipe the output like so:

git branch -r | less

If I know what branch name to look for, then:

git branch -r | grep 'phase-4'

Once the desired branch is identified, let’s check this out in our local repository:

git checkout name_of_remote_branch


git checkout origin/release-18.06.01

You can also do the following: 

git checkout release-18.06.01

This sets tracking to the origin branch automatically.

Now create/checkout the branch that you need from current branch:

git checkout -b branch_name


III. Saving changes 

After making changes to the working files or directory:

List the changes in the folder:

git status

Stage the file(s) to be committed to the staging index/directory:

git add path_to_filename


Add everything under the working directory:

git add .

Commit the changes (to  commit history):

git commit 

This opens up an editor to add comments and description


Commit the changes with a message added inline:

git commit -m 'comments for commit'


Stage all changes for tracked files and then commits with inline commit message:

git commit -am 'comments for commit'

I prefer the last, incase I may have forgotten to stage any recent changes by Git add.


Additional Tip:

Create your own power command to combine favorite but long Git commands. 

e.g. Create and combine git add . && git commit -m 'commit message' into an alias or function in .bash_profile


IV. Undo Changes 

If you are not happy, you can undo all the changes in the last commit.

If you simply want to change the message on the last commit:

git commit --amend

This opens up an editor to add comments and description. 


git commit --amend -m ‘my new message’

If, however, you want to modify files and message in the last commit. Make the file changes and then run:

git add .  

git commit --amend

To undo the last commit entirely and put everything into staging area:

git reset --soft

To undo the last commit entirely and unstage all contents from staging area:

git reset --mixed 


git reset

To undo and remove all changes in the last commit completely:

git reset --hard

Keep in mind that this action will destroy all changes you have made. 

To remove all untracked files:

git clean -nfd

This is a dry run mode. It safely shows you what is going to be removed without actually removing them.

git clean -fd

This removes all untracked files and directories.

To understand how Git manages state, look into the Three-Trees of Git.


V. Get Changes from Remote 

git fetch

This retrieves the branches or tags for all branches in the repository—along with objects necessary to complete their histories.

git pull

This is the same as git fetch, but it also does a git merge FETCH_HEAD in the end. Effectively merging with latest head of the current branch.


VI. Pushing Changes to Remote 

If our current branch was only created locally and is not tracked by a remote equivalent, we can push this up by:

git push -u origin branch_name


If you're already tracking a remote branch:

git push


VII. Visual Tool 

Sometimes command line will not cut it when it comes to visualizing differences and historical context.

Here gitk—the first graphical repository browser—comes to our rescue. 

To run simply type: 



VIII. Git Aliases 

Now that you are getting acquainted with the most common commands, you can save shortened forms of your most common commands:

$ git config --global checkout

Now to checkout just type:

git co

$ git config --global alias.unstage 'reset HEAD --'

git unstage myFile

See more examples here.


Additional Tip: 

If you follow Gitflow practice exactly, look into using the git-flow wrapper which will save you few steps. See gitflow-wrapper for more details.


So far, these have been the most basic commands I use for all normal needs. 

In the next part, we shall get a little deeper with some Git concepts and more advanced commands.