If you’re starting your journey as a developer, Git is one of the most important tools you’ll encounter. Whether you’re working alone or in a team, Git helps you track changes, collaborate efficiently, and manage your code safely.

In this article, we’ll cover:

• What Git is
• Why Git is used
• Git basics and core terminologies
• Common Git commands
• A simple developer workflow using Git
• '.gitignore' File overview
• Commit history flow

1. What is Git?

Git is a distributed version control system (DVCS) used to track changes in source code during software development.

In simple terms:
Git helps you save different versions of your code so you can track changes, go back in time if something breaks, and collaborate with others without overwriting each other’s work.

Unlike traditional version control systems, Git allows every developer to have a full copy of the project, including its history, on their local machine.

2. Why Git is Used

Git is widely used because it solves many real-world development problems.

Key Benefits of Git

• Version history to track every change made to your code
• Collaboration with multiple developers on the same project
• Backup and recovery by reverting to previous working versions
• Branching to work on features independently
• Fast and efficient since most operations run locally

Whether you’re a solo developer or part of a large team, Git keeps your workflow organized and reliable.

3. Git Basics and Core Terminologies

Before using Git commands, it’s important to understand some core concepts.

Repository (Repo)

A repository is a folder that contains:

• Your project files
• Git’s tracking history

Types of repositories:

• Local repository (on your computer)
• Remote repository (on platforms like GitHub or GitLab)

Commit

A commit is a snapshot of your project at a specific point in time.

You can think of a commit as saving your progress with a message explaining what changed.

Each commit includes:

• A unique commit ID (hash)
• Author information
• Date and time
• Commit message

Branch

A branch is a separate line of development.

• main or master is the default branch
• Branches allow you to work on new features or fixes without affecting the main codebase

HEAD

HEAD is a pointer that indicates the current commit you are working on.

By default, HEAD points to the latest commit of the current branch.

4. Git Working Areas

Below diagram shows how files move through Git when you work and commit changes. Git operates using three main areas.

Working Directory → Staging Area → Repository

Explanation

[ Working Directory ]
|
git add
↓
[ Staging Area ]
|
git commit
↓
[ Repository ]

• Working Directory: Where you create and edit files
• Staging Area: Where changes are prepared before committing
• Repository: Where Git permanently stores committed changes

5. Common Git Commands

Below are the most commonly used Git commands with beginner-friendly examples.

git init

Initializes a new Git repository.

git init

This command creates a hidden .git directory that Git uses to track changes.

git status

Displays the current state of the repository.

git status

It shows:

• Modified files
• Staged files
• Untracked files

git add

Adds files to the staging area.

Add a specific file:

git add index.html

Add all files:

git add .

git commit

Commits the staged changes to the repository.

git commit -m "Initial commit"

Commit messages should be clear and descriptive.

git log

Shows the commit history of the repository.

git log

Sample output:

commit a1b2c3d4
Author: John Doe
Date:   Mon Jan 10

Added homepage layout

6. Basic Developer Workflow Using Git

Below is a simple workflow demonstrating how a developer uses Git from scratch.

Step-by-Step Example

# Create a project directory
mkdir my-project
cd my-project

# Initialize Git
git init

# Create a file
touch README.md

# Check repository status
git status

# Stage the file
git add README.md

# Commit changes
git commit -m "Add README file"

This completes your first Git workflow.

7. Local Repository Structure Overview

This diagram explains what exists inside a local Git repository, especially the hidden .git directory.

my-project/
│
├── .git/                          ← Git internal repository
│   │
│   ├── HEAD                       ← Current branch pointer
│   ├── config                     ← Local repo configuration
│   ├── description                ← Repo description (mainly for bare repos)
│   ├── index                      ← Staging area data
│   │
│   ├── objects/                   ← All Git objects (database)
│   │   ├── 0a/
│   │   │   └── f23bd4...           ← Blob / tree / commit objects
│   │   ├── 1f/
│   │   │   └── a9c456...
│   │   └── pack/                  ← Compressed object packs
│   │
│   ├── refs/                      ← References (pointers)
│   │   ├── heads/                 ← Local branches
│   │   │   └── main
│   │   ├── remotes/               ← Remote branches
│   │   │   └── origin/
│   │   │       └── main
│   │   └── tags/                  ← Tags
│   │
│   ├── logs/                      ← History of reference updates
│   │   ├── HEAD
│   │   └── refs/
│   │       └── heads/
│   │           └── main
│   │
│   ├── hooks/                     ← Git hook scripts
│   │   ├── pre-commit.sample
│   │   ├── commit-msg.sample
│   │   └── post-commit.sample
│   │
│   ├── info/
│   │   └── exclude                ← Ignored files (local only)
│   │
│   └── FETCH_HEAD                 ← Last fetched branch info
│
├── .gitignore                     ← Ignore rules
├── README.md
├── index.js
├── package.json
└── node_modules/

8. Important .git Directories Explained

.git/
│
├── objects/     → Stores all data (commits, files, trees)
├── refs/        → Branch and tag pointers
├── logs/        → Tracks changes to refs and HEAD
├── index        → Staging area snapshot
├── hooks/       → Scripts triggered by Git events
├── info/        → Local-only ignore rules
└── HEAD         → Points to current branch

9. Important .gitignore File Overview

The .gitignore file tells Git which files or directories should NOT be tracked.

.gitignore

Typical use cases:

• Dependency folders

• Build output

• Environment variables

• OS-generated files

10. Important .gitignore Rule Diagram:

Rule Type        Example         Meaning
-------------------------------------------------
Directory        node_modules/   Ignore entire folder
File             .env            Ignore specific file
Wildcard         *.log           Ignore all .log files
Negation         !keep.txt       Do not ignore keep.txt

11. Commit History Flow

A simple representation of commit history:

Commit A → Commit B → Commit C (HEAD)

Each commit builds on the previous one, creating a timeline of your project’s development.

Commit History Flow with Internal Git View:

Commit C (HEAD, main)
│
├── Tree
│   ├── index.js
│   └── README.md
│
└── Parent → Commit B
              │
              └── Parent → Commit A

Conclusion

Git is an essential tool for modern software development. Once you understand repositories, commits, branches, and the staging workflow, Git becomes easy to use and extremely powerful.

For beginners, the best way to learn Git is consistent practice on small projects.

Thank you reading this article.