DEV Community: Ankith Deegoju

Basics of Git - Part 2

Ankith Deegoju — Fri, 15 May 2026 06:56:11 +0000

In this blog we will explore the concept of -

Branches
Push, pull, merge
Pull Request and how can we contribute to any repo.

To understand above concepts we will follow a hands on approach of doing things -

Repo - Repository - Folder tracked by Git.

Methods to access an existing repo -

Directly download the repo from GitHub and open it in our terminal
We can fork the repo using fork button on github - This creates your own copy of the repo.
We can use git clone command to clone the repo locally. Command - git clone “Add repo-link here”

We will understand the concepts of cloning, remote conenction establishment, branching through the below steps.

Let’s create a new repo in GitHub. I have created a test_repo.

We get something like this -

Copy the link here.

Use the git clone command to clone the repo locally -

Let’s add a few files into it and we will also use some of the commands from our previous blog to add the files into staging, commit the changes, then push the code into GitHub.

I have created two files in the repo. [ You can refer prev blog / google it to create files in a repo ]

To push the code to GitHub we need to establish a remote connection with the GitHub repo. By default a remote connection with name origin is created if we use git clone command.

Why do we want to push code - Everyone with the repo link can view the updates in the code.

Command to establish remote connection - git remote add “remote-connection-name” “repo-link”

To view all existing remote connections in that repo .
Command - git remote -v

We can remove connection using command - git remote remove “remote-connection-name” .

Suppose we want to develop a project and we have a team of developers. We create a repo on GitHub. We then add a remote connection to that repo via our terminal, to make changes in our local system independently and then push those changes to the repo.

Why do we create a remote connection - To make changes locally in our system verify them once if they are properly working from our side and then pushing those to the github for the team to look into and review before deploying it.

I have also forked a public repo for example and did few things in the code.
Ex- git remote add origin https://github.com/NirDiamant/RAG_Techniques.git

To view all existing remote connections - git remote -v

Generally what happens is the repo’s MAIN / MASTER branch is generally connected to the hosting platform where our application in deployed [This is not always true]. Any changes to the MASTER branch will be reflecting in our production directly. To avoid any unnecessary issues , the MASTER branch of the repo is locked so that none of the developers can directly push the code to the production without proper check . So each developer creates a separate branch of the same repo, makes his/her changes then raises a pull request [PR], the manager / testing team after verification of the changes pushes the code into MASTER branch.

By default after cloning a repo, a MASTER branch is created in the local repo, which will be connected to the MASTER branch of the repo.

In my local experiments the default branch name is MASTER. Modern GitHub repositories use main by default not MASTER.

We need to use remote connection name and branch name to push changes into GitHub / MASTER branch.

What is a branch - Independent line of development

How do we create branches - Using command
git branch

To view all existing branches - git branch -a
Naming convention followed while creating branches- Developer Name/Feature Name

Fetch - Used to download the latest updates from GitHub repository and updates the remote tracking branch like remotes/origin/MASTER, without modifying our local working branch.

Use command - git fetch origin [ This fetches all branches from origin]

git fetch origin "branch-name" [ The changes are fetched from the specified branch name ]

We will manually add few changes in our repo from GitHub to understand fetch command in the GitHub repo. I have added changes in the two base files created via GitHub web app.

To compare changes from your local repo MASTER branch to the github repo’s MASTER branch we use - git diff MASTER origin/MASTER

So we have made changes directly in the MASTER branch of repo in the GitHub.

Using fetch command we can compare our repo code with latest github repo code and if needed the new changes can be copied into our local repo to maintain sync with the changes in the repo.

Branching - Switch command

We can update our repo with the newly made changes using git pull command. But we need to set upstream for a branch to enable push and pull changes. This upstream links a local branch to a remote branch.

Command - git branch —set-upstream-to=origin/MASTER

Now we can pull changes using pull command -

git pull origin [If upstream is already set- fetch and merge latest changes into the current local branch from the connected remote branch]

git pull origin "branch-name" [ The changes are pulled into the specifed branch name ]

To observe all the commit history of the branch - We can do it using command git log —oneline.

The branch Ankith/Feat1 is at commit 7864cda i.e. behind the MASTER branch of the local repo by two commits. So now we can merge these changes in Ankith/feat1 branch from the MASTER branch of local repo to keep all the branches in sync.

Explore checkout and restore commands in git.

Let’s understand merge -— squash . Suppose we make multiple commits in Ankith/feat1 branch .

Head pointer in the git always points the currently executed / checked-out commit.

Here we did few commits in the specific branch - Ankith/Feat1

When we use merge command all the three commits are merged into MASTER .

Instead we can also merge all the commits of Ankith/feat1 into MASTER branch using single commit by squashing all the commits into a single commit.

As we merge the changes from Ankith/feat1 branch to MASTER branch, the changes are placed into staging area. On commit operation these changes are made to MASTER branch with a single commit.

Generally we delete the branch once the changes are pushed to MASTER branch.

Pushing - To push changes made in the local MASTER branch into Github
Command - git push origin.

Rebase - Suppose we have two branches Ankith/Feat2, MASTER. Suppose my friend has added many features into the MASTER branch. In this case of many changes in a MASTER branch i.e. all the structure of your Ankith/Feat2 branch is different from initial setup then we can use rebase to place your branch commits on top of latest MASTER branch, creating cleaner linear history.

Here we can resolve merge conflicts either automatically or manually.

We can explore the above topics in a bit depth by using these commands and playing with them.

Explore about how Pull Request is created in an org and in open source contributions, if possible add pull request to my repo - https://github.com/ANKITHDEEGOJU/Test_Repo

If possible do create your open repo and configure it to allow PR”s from others by modifying the branch settings. [ Explore Protected Branches]

A small clarity - if you are the owner of the repo then you have the permission to directly push changes to MASTER branch, else you can push code directly to your custom branch and then raise a PR [if admin of the repo provides you access to create your own branch]. Generally people fork the repo , create their individual branch in the local repo , then push code to the MASTER branch of this local repo, check if everything is fine. Then send PR to admin/ maintainer to accept the updates. Then the maintainer verifies the code changes then accepts the pull request , merges changes into the main/MASTER branch of the repo.

Reference - Git Cheat Sheet

Basics of Git -

Ankith Deegoju — Fri, 20 Mar 2026 11:37:06 +0000

What is Git.

Git is a version control system. Version Control System is a software that manages changes of your code/files in a folder/directory.

What is the problem its solving -

Provides us tracking of changes in codebase.
Provides us simultaneous access to codebase enabling collaboration
[ via GitHub -> Simply say git in a server || Even I need to deep dive into it ]
Provides us a single source of truth i.e. provides us exact state of code base that is constantly being updated with changes done by members accessing the code base.

To understand it's importance and need of git.

Scenario - Imagine how you would collaborate with other developers and build together a project.

Suppose you have multiple people working with the same codebase but need simultaneous access and push changes independent of others in different parts of codebase.

Era before git - By sharing code via pendrive.
Think of use cases like - How can we provide simultaneous access and consistent updates of code across all developers of the code base.

I would like to explore other ideas which you can think of in the above context.

How was git built - [Just a short story]

Linus Torvald was working on Linux. As it was open source project many developers pushed code to improvise it, eventually the code base was too big to track and update changes. To solve this issue git was developed as his side project.

How do we use git -

[Start doing it in a system with me]

Create a folder - LearningGit
Create two files - ex - demo1.txt , demo2.txt
Open your terminal and let's work in it now on.

Few basic commands -

ls - to list files in a folder.

              Linux/WSL         Command Prompt (cmd)
List Files   ls               dir

Detailed List   ls -l             dir

Show Hidden ls -a            dir /a

All Details ls -la               dir /a

nano - Linux -> To create and edit files

edit - Windows -> Installation Command - winget install Microsoft.Edit

Usage:- > edit <filename>

Key Bindings { Shortcut Keys } ->

Ctrl+S to save.

Ctrl+F for find and replace.

Ctrl+Q to exit.

Add some info into your files .

cat - Linux -> To view file data

type - Windows

Usage - type file.txt

Concatenate/Merge files: type file1.txt file2.txt > combined.txt

Let's now start using our git commands .

git init - Initializes git inside your folder with by creating a .git file.

O/P => Initialized empty Git repository in C:/WebDev/LearningGit/.git/

git status- TO check the status

Red - Untracked
Green - Files that are being tracked / staged to be tracked.

Staging -

We need to stage files that we wish to track. A way to tell git to look into these files.

git add <filename> => For individual file to be tracked

git add . -> For all files within the directory to be tracked.

Committing -
Once we are okay with changes we can commit the changes so that that we can store them as checkpoints for reference of changes or revert back incase of any fallback.

Command-

git commit -m "Initial files"

Try to change the code a few times and try to commit.

Once committed -> changes are permanently stored in .git file.

How does it do it.
Under the hood we create a linked list of commits to file. Each new node stores a hash of prev node as a reference. As we have a head pointer in linked list we have a head here which points to the most updated node.

We can perform git add and commit both in a single command.
git commit -am "msg"

git log - gives us history of commits performed.

You get the list of commits with a unique hash value associated with each commit.

We can compare changes form one commit to another using commands-

git diff <hashval of commit> <hashval of commit to be compared with>
git revert hash_id=> Creates a complement of the given hash_id and attaches head to it.

The attached screenshot would be helpful.

We will explore .git folder,git branching, GitHub concepts in the upcoming blogs.

Git Cheat Sheet