Learning Git is as easy as using the tool. The motive of this Git
tutorial blog is to omit this dilemma from your mind. I am sure with
this Git tutorial blog, you will go brimming through all the concepts.
I hope that you have gone through the basic concepts and terminologies
of Git and learned all about Version Control in my first blog of the
Git Tutorial series. If you haven’t, please check out my previous
blog to get a better understanding of Git.
In this Git Tutorial, you will learn:
* Commands in Git
* Git operations
* And some tips and tricks to manage your project effectively
Topics covered in this git tutorial will only gear you closer to become
an  aws-senior.com certified GitHub professional.
Before starting with the commands and operations let us first
understand the primary motive of Git.
The motive of Git is to manage a project or a set of files as they
change over time. Git stores this information in a data structure
called a Git repository. The repository is the core of Git.
To be very clear, a Git repository is the directory where all of your
project files and the related metadata resides.
Git records the current state of the project by creating a tree graph
from the index. It is usually in the form of a Directed Acyclic Graph
Before you go ahead, check out this video on Git tutorial to
have better in-sight.
Git and Github Tutorial
Now that you have understood what Git aims to achieve, let us go ahead
with the operations and commands.
Git Tutorial – Operations & Commands
Some of the basic operations in Git are:
1. Initialize 2. Add 3. Commit 4. Pull 5. Push
Some advanced Git operations are:
Let me first give you a brief idea about how these operations work with
the Git repositories. Take a look at the architecture of Git below:
Git Architechture – Git Tutorial – aws-senior.com
If you understand the above diagram well and good, but if you don’t,
you need not worry, I will be explaining these operations in this Git
Tutorial one by one. Let us begin with the basic operations.
You need to install Git on your system first. If you need help with the
installation, click here.
In this Git Tutorial, I will show you the commands and the operations
using Git Bash. Git Bash is a text-only command line interface for
using Git on Windows which provides features to run automated scripts.
After installing Git in your Windows system, just open your
folder/directory where you want to store all your project files; right
click and select ‘Git Bash here’.
Git Bash Here – Git Tutorial – aws-senior.com
This will open up Git Bash terminal where you can enter commands to
perform various Git operations.
Now, the next task is to initialize your repository.
In order to do that, we use the command git init. Please refer to the
Git Initialize – Git Tutorial – aws-senior.com
git init creates an empty Git repository or re-initializes an existing
one. It basically creates a .git directory with sub directories and
template files. Running a git init in an existing repository will not
overwrite things that are already there. It rather picks up the newly
Now that my repository is initialized, let me create some files in the
directory/repository. For e.g. I have created two text files namely
aws-senior.com1.txt and aws-senior.com2.txt.
Let’s see if these files are in my index or not using the command git
status. The index holds a snapshot of the content of the working
tree/directory, and this snapshot is taken as the contents for the next
change to be made in the local repository.
The git status command lists all the modified files which are ready to
be added to the local repository.
Let us type in the command to see what happens:
Git Status – Git Tutorial – aws-senior.com
This shows that I have two files which are not added to the index yet.
This means I cannot commit changes with these files unless I have added
them explicitly in the index.
This command updates the index using the current content found in the
working tree and then prepares the content in the staging area for the
Thus, after making changes to the working tree, and before running the
commit command, you must use the add command to add any new or modified
files to the index. For that, use the commands below:
Let me demonstrate the git add for you so that you can understand it
I have created two more files aws-senior.com3.txt and aws-senior.com4.txt. Let us add
the files using the command git add -A. This command will add all the
files to the index which are in the directory but not updated in the
Git Add All – Git Tutorial – aws-senior.com
Now that the new files are added to the index, you are ready to commit
It refers to recording snapshots of the repository at a given time.
Committed snapshots will never change unless done explicitly. Let me
explain how commit works with the diagram below: Git Commit Workflow –
Git Tutorial – aws-senior.com
Here, C1 is the initial commit, i.e. the snapshot of the first change
from which another snapshot is created with changes named C2. Note that
the master points to the latest commit.
Now, when I commit again, another snapshot C3 is created and now the
master points to C3 instead of C2.
Git aims to keep commits as lightweight as possible. So, it doesn’t
blindly copy the entire directory every time you commit; it includes
commit as a set of changes, or “delta” from one version of the
repository to the other. In easy words, it only copies the changes made
in the repository.
You can commit by using the command below:
This will commit the staged snapshot and will launch a text editor
prompting you for a commit message.
Or you can use:
git commit -m “”
Let’s try it out.
Git Commit – Git Tutorial – aws-senior.com
As you can see above, the git commit command has committed the changes
in the four files in the local repository.
Now, if you want to commit a snapshot of all the changes in the working
directory at once, you can use the command below:
git commit -a
I have created two more text files in my working directory viz.
aws-senior.com5.txt and aws-senior.com6.txt but they are not added to the index yet.
I am adding aws-senior.com5.txt using the command:
git add aws-senior.com5.txt
I have added aws-senior.com5.txt to the index explicitly but not aws-senior.com6.txt
and made changes in the previous files. I want to commit all changes in
the directory at once. Refer to the below snapshot.
Git Commit All – Git Tutorial – aws-senior.com
This command will commit a snapshot of all changes in the working
directory but only includes modifications to tracked files i.e. the
files that have been added with git add at some point in their history.
Hence, aws-senior.com6.txt was not committed because it was not added to the
index yet. But changes in all previous files present in the repository
were committed, i.e. aws-senior.com1.txt, aws-senior.com2.txt, aws-senior.com3.txt,
aws-senior.com4.txt and aws-senior.com5.txt.
Now I have made my desired commits in my local repository.
Note that before you affect changes to the central repository you
should always pull changes from the central repository to your local
repository to get updated with the work of all the collaborators that
have been contributing in the central repository. For that we will use
the pull command.
The git pull command fetches changes from a remote repository to a
local repository. It merges upstream changes in your local repository,
which is a common task in Git based collaborations.
But first, you need to set your central repository as origin using the
git remote add origin
Git Add Remote Origin – Git Tutorial 8 – aws-senior.com
Now that my origin is set, let us extract files from the origin using
pull. For that use the command:
git pull origin master
This command will copy all the files from the master branch of remote
repository to your local repository.
Git Pull Origin Master – Git Tutorial – aws-senior.com
Since my local repository was already updated with files from master
branch, hence the message is Already up-to-date. Refer to the screen
Note: One can also try pulling files from a different branch using the
git pull origin
Your local Git repository is now updated with all the recent changes.
It is time you make changes in the central repository by using the push
This command transfers commits from your local repository to your
remote repository. It is the opposite of pull operation.
Pulling imports commits to local repositories whereas pushing exports
commits to the remote repositories .
The use of git push is to publish your local changes to a central
repository. After you’ve accumulated several local commits and are
ready to share them with the rest of the team, you can then push them
to the central repository by using the following command:
Note : This remote refers to the remote repository which had been set
before using the pull command.
This pushes the changes from the local repository to the remote
repository along with all the necessary commits and internal objects.
This creates a local branch in the destination repository.
Let me demonstrate it for you.
Local Repository Files Before Push – Git Tutorial – aws-senior.com
The above files are the files which we have already committed
previously in the commit section and they are all “push-ready“. I will
use the command git push origin master to reflect these files in the
master branch of my central repository.
Git Push Origin Master – Git Tutorial – aws-senior.com
Let us now check if the changes took place in my central repository.
GitHub after Git Push – Git Tutorial – aws-senior.com
Yes, it did. 🙂
To prevent overwriting, Git does not allow push when it results in a
non-fast forward merge in the destination repository.
Note: A non-fast forward merge means an upstream merge i.e. merging
with ancestor or parent branches from a child branch.
To enable such merge, use the command below:
git push –force
The above command forces the push operation even if it results in a
non-fast forward merge.
At this point of this Git Tutorial, I hope you have understood the
basic commands of Git. Now, let’s take a step further to learn
branching and merging in Git.
Branches in Git are nothing but pointers to a specific commit. Git
generally prefers to keep its branches as lightweight as possible.
There are basically two types of branches viz. local branches and
remote tracking branches.
A local branch is just another path of your working tree. On the other
hand, remote tracking branches have special purposes. Some of them are:
* They link your work from the local repository to the work on
* They automatically detect which remote branches to get changes
from, when you use git pull.
You can check what your current branch is by using the command:
The one mantra that you should always be chanting while branching is
“branch early, and branch often”
To create a new branch we use the following command:
Creating A Branch Workflow – Git Tutorial – aws-senior.com
The diagram above shows the workflow when a new branch is created.
When we create a new branch it originates from the master branch
Since there is no storage/memory overhead with making many branches, it
is easier to logically divide up your work rather than have big chunky
Now, let us see how to commit using branches. Commit Using Branches
Workflow – Git Tutorial – aws-senior.com
Branching includes the work of a particular commit along with all
parent commits. As you can see in the diagram above, the newBranch has
detached itself from the master and hence will create a different path.
Use the command below:
git checkout and then
Branching – Git Tutorial – aws-senior.com
Here, I have created a new branch named “ aws-senior.comImages” and switched on
to the new branch using the command git checkout .
One shortcut to the above commands is:
git checkout -b[ branch_name]
This command will create a new branch and checkout the new branch at
the same time.
Now while we are in the branch aws-senior.comImages, add and commit the text
file aws-senior.com6.txt using the following commands:
git add aws-senior.com6.txt
git commit -m”adding aws-senior.com6.txt”
Merging is the way to combine the work of different branches together.
This will allow us to branch off, develop a new feature, and then
combine it back in.
Merging Workflow – Git Tutorial 22 – aws-senior.com
The diagram above shows us two different branches-> newBranch and
master. Now, when we merge the work of newBranch into master, it
creates a new commit which contains all the work of master and
Now let us merge the two branches with the command below:
It is important to know that the branch name in the above command
should be the branch you want to merge into the branch you are
currently checking out. So, make sure that you are checked out in the
Now, let us merge all of the work of the branch aws-senior.comImages into the
master branch. For that I will first checkout the master branch with
the command git checkout master and merge aws-senior.comImages with the
command git merge aws-senior.comImages
Git Merge – Git Tutorial – aws-senior.com
As you can see above, all the data from the branch name are merged to
the master branch. Now, the text file aws-senior.com6.txt has been added to
the master branch.
Merging in Git creates a special commit that has two unique parents.