In the world of software development, Git is an indispensable tool. It's not just for professional developers; anyone working on projects that involve multiple iterations or collaboration can benefit immensely from understanding its fundamentals.

What is Git?

Git is a Version Control System, it helps you track changes in your code over time.

Imagine: When you write code today and modify it tomorrow, there’s always a chance that something might break. In such situations, you may want to return to the last working version of your code. Git makes this process easy, safe, and well-organized by keeping a complete history of changes.

Why “Distributed”?
Git is called a distributed version control system because every developer has a full copy of the entire project. This means there is no single point of failure, and developers can continue working on their code even without an internet connection.

Why Git is Used?

Git is used to manage and control changes in source code efficiently. It helps developers work in an organized manner, whether they are working alone or in a team.

Git is mainly used to:

• Track code changes over time so you always know what was modified and when

• Collaborate with multiple developers without overwriting each other’s work

• Maintain complete project history with clear and meaningful commits

• Experiment safely using branches without affecting the main codebase

• Roll back mistakes easily and return to a stable version whenever needed

Without Git

Without Git, managing code becomes messy and confusing. Developers often end up creating multiple copies of the same project, such as:

• final_project.zip

• final_project_v2.zip

• final_project_final.zio

This leads to confusion, lost changes, and wasted time.

With Git

With Git, everything is structured and easy to manage:

• Clean and readable project history

• Clear tracking of every change

• Smooth and efficient collaboration

In short, Git brings clarity, control, and confidence to the development process.

Git Basics and Core Terminologies

Before using Git effectively, it is important to understand some core concepts. These basic terminologies form the foundation of how Git works.

A) Repository (Repo) : A repository is a folder that Git tracks and manages. It contains our entire project along with all its version history. A Git repository includes:

• Your project files

• A hidden “.git” folder, which stores Git’s data, history, and configuration (think its like a Git’s brain)

• repository structure like

  • 

    The .git directory is hidden inside the LEARNGIT folder.

B) Working Directory : The working directory is the place where you actively work on your code. Any changes you make here are not tracked by Git until you tell Git to track this/that file.

Examples of working directory actions include:

• Editing hello.txt

• Creating new file feature.txt

• Deleting or modifying existing files

C) Staging Area : The staging area is an intermediate step between the working directory and the repository. It allows you to select which changes should be included in the next commit.

You can think of it as telling Git: “I want Git to remember these specific changes (Means we tell to git “hey git take a screenshot of these changes what I made now)”.

For example, as shown in the figure below, the staging area works like a bridge between the working directory and the repository, helping Git decide what changes should be committed.

D) Commit : A commit is saves screenshot of our project at a specific point in time. Once committed, the changes are safely stored in the repository’s history (Means here we say to git “Hey git save the screenshot of changes“ ).

Each commit contains:

• A unique commit ID

• Author information

• Date and time of the commit

• A descriptive commit message example for commit message “Added login feature”

E) Branch : A branch is an independent line of development that allows you to work on features or fixes without affecting the main codebase.

Common examples:

• main → stable and production-ready code

• feature → experimental or feature-specific work

Branches help you develop new features safely and in parallel.

F) HEAD : A HEAD is a pointer that indicates your current position in the Git history. It tells Git which commit you are currently working on.

You can think of HEAD as: “Where am I right now in Git history?”

Common Git Commands

Here are some of the most frequently used Git commands.

1. git init : This command initializes a new Git repository in our current working project directory. It creates a hidden .git folder where Git stores all its tracking information.

2. git add <filename> : his command adds specific/single file from our working directory to the staging area.

3. git add . : This command adds all modified and new files in our current directory to the staging area. Use with caution, ensuring you only add what you intend to commit.

4. git commit -m "commit message" : This command takes everything from the staging area and permanently saves it as a new commit in our local repository. The “-m” flag allows you to add a concise and descriptive message about the changes what we made. Ex: git commit -m "Initial commit: create user register form"

5. git diff : It shows the differences between files — it tells you what changes you have made compared to the last saved version of commit.

6. git log : This command displays the commit history of your current branch. You'll see each commit's unique ID, author, date, and commit message.

7. git revert <commit-hash> : it is used to undo or remove a specific changes/commit safely by creating a new commit that reverses the changes made in that commit.

8. git reset —hard <commit-hash>: moves the HEAD back to an earlier commit and completely removes all commits and changes after it and You cannot recover those changes unlike git revert

9. git status : git status command that shows the current state of our repository. It helps you understand what is happening in our project at any given moment. The command tells us which files have been modified, which files are staged, which are untracked, and whether changes have been committed or not. In short, “git status” gives a complete overview of the current condition of the project.

Git may feel confusing at first, but once you understand:

• Repository

• Staging

• Commit

• Branch

it becomes one of the most powerful tools in your developer journey.