🔍Git for Beginners: Basics and Essential Commands
✍️Introduction:
When I started learning programming, I used to save my project files like this:
project_final.zip
project_final_v2.zip
project_final_really_final.zip
Very soon, I realized this was messy and confusing.
That’s when I learned why developers use Git.
In this blog, I’ll explain what Git is, why it is used, and how beginners can start using Git step by step.
✍️What is Git?
In simple language git means version control system, track changes and helps developer to work safely.
But more technical way: Git is a distributed version control system to track changes in source code during development.
Now you think what is version control system?? It’s nothing but in simple way: It keeps a history of your work and allows you to go back to any previous version whenever needed.
Every developer use Git as a complete copy of the entire project on their own system.
✍️Why Git is used?
Git is used because it solves many real-world problems:
1. Losing Code by Mistake ❌
Problem:
You delete or overwrite a working file and can’t recover it.
How Git Helps:
Git keeps a complete history of every change.
You can easily go back to a previous working version.
2. Multiple People Editing the Same File 🧑🤝🧑
Problem:
Two developers change the same file and one person’s work gets lost.
How Git Helps:
Git merges changes safely and shows conflicts if any.
👉 Real life: Google Docs but for code
3. Confusing File Versions 📁
Problem:
Files like:
final.cpp
final_v2.cpp
final_latest.cpp
final_latest_fixed.cpp
How Git Helps:
Git stores versions internally using commits with messages.
👉 Real life*:* Clean history instead of messy file names
4. Experimenting Without Fear 🧪
Problem:
You’re scared to try a new feature because it may break the code.
How Git Helps:
You can create a branch, test freely, and discard it if it fails.
👉 Real life: Like testing ideas in a separate notebook
5. Tracking Who Changed What 🕵️
Problem:
A bug appears and no one knows who caused it.
How Git Helps:
Git shows:
Who changed the code
When it was changed
Why (commit message)
👉 Real life: CCTV for code changes
6. Fixing Bugs Faster 🐞
Problem:
You don’t know which change introduced a bug.
How Git Helps:
You can:
Compare versions
Go back to a stable commit
Identify the faulty change
👉 Real life: Time-travel to find mistakes
7. Working Offline 🌐
Problem:
No internet but you still want to code and save progress.
How Git Helps:
Git works offline and syncs later when online.
👉 Real life: Notes app that syncs when internet is back
💡Because of these reasons, Git is used in almost every software company today.
✍️Git basics and Core Terminologies:
Before learning Git commands or terms, it’s important to understand how Git works behind the scenes.
Git works in three main stages:
Working Directory
Staging Area
Repository
📌 Diagram: Git Basic Workflow
Working Directory → Staging Area → Repository
🔹Repository (Repo)
A repository is a folder where Git tracks all changes of your project.
It contains:
Your project files
Complete history of changes
Information about commits and branches
You create a repository using:
git init
📘 Real-life example:
A repository is like a Google Drive folder that remembers every edit you’ve ever made.
Working Directory
The working directory is where you actually write and modify your code.
Whenever you:
Create a file
Edit code in VS Code
Delete or update a file
You are working inside the working directory.
📝 These changes are not saved by Git automatically until you tell Git to save them.
Staging Area
The staging area is a temporary place where you select which changes should be saved.
You use the staging area to tell Git:
“These are the changes I want to include in my next save.”
Command used:
git add filename
or to add everything:
git add .
📘 Real-life example:
Like selecting photos before uploading them to Instagram.
🔹Commit
A commit is a permanent snapshot of your project at a specific point in time.
Each commit includes:
A unique ID
A message describing the change
Date and time
Command:
git commit -m "Added login feature"
📘 Important:
Once a commit is created, you can always go back to it.
🔹Branch
A branch allows you to work on new features or experiments without affecting the main code.
By default, Git creates a branch called main.
📌 Diagram: Branching in Git
main
|
|── feature-login
|
|── bug-fix
Another view:
A ── B ── C (main)
\
D ── E (feature branch)
📘 Real-life example:
Like writing rough work on a separate notebook page while keeping the main notes clean.
🔹HEAD
HEAD is a pointer that shows:
Where you are currently working in Git
If you switch branches, HEAD moves with you.
📘 Simply put:
HEAD = your current position in the project.
😀Now come to all common Git commands:
🟢 git init — Initialize a Repository
Initializes a new Git repository in the current project directory.
git init
Purpose:
Starts Git tracking for a project
Creates a
.gitdirectory
Use this command once when starting a new project.
🟢 git status — Check Repository Status
Displays the current state of the working directory and staging area.
git status
Shows:
Modified files
Staged files
Untracked files
This command is useful to understand what changes are pending.
🟢 git add — Stage Changes
Moves changes from the working directory to the staging area.
Add a specific file:
git add filename
Add all changes:
git add .
Purpose:
- Prepares changes for commit
🟢 git commit — Save Changes
Records staged changes permanently in the repository.
git commit -m "Commit message"
Purpose:
Creates a snapshot of the project
Stores changes with a descriptive message
Commit messages should clearly describe the change.
🟢 git log — View Commit History
Displays the commit history of the repository.
git log
Shows:
Commit hash
Author
Date and time
Commit message
Useful for tracking changes over time.
🟢 git diff — View File Differences
Shows differences between modified files and the last committed version.
git diff
Purpose:
- Review changes before staging or committing
🟢 git branch — Manage Branches
Lists, creates, or deletes branches.
List branches:
git branch
Create a new branch:
git branch branch-name
Purpose:
- Enables parallel development
🟢 git checkout — Switch Branches
Switches between branches or commits.
git checkout branch-name
Purpose:
- Move the HEAD pointer to another branch
🟢 git merge — Merge Branches
Combines changes from one branch into the current branch.
git merge branch-name
Purpose:
- Integrates completed work into another branch
🟢 git clone — Copy a Repository
Creates a local copy of a remote repository.
git clone repository-url
Purpose:
- Download an existing project to your system
🟢 git pull — Fetch and Merge Changes
Fetches updates from a remote repository and merges them into the current branch.
git pull
Purpose:
- Keep the local repository up to date
🟢 git push — Upload Local Changes
Uploads local commits to a remote repository.
git push
Purpose:
- Share changes with others
🟢 git remote — Manage Remote Repositories
Displays or manages remote repository connections.
git remote -v
Purpose:
View linked remote URLs
😀😀Final Thoughts:
Git may look complicated at first, but it becomes much simpler once you understand the purpose of each command. Focus on learning the basics well instead of trying to remember everything at once.
Mistakes are part of the learning process, and Git is designed to help you recover from them. With consistent practice, these commands will soon feel natural.
Up next, we will explore a complete Git workflow that beginners can follow in real projects.