What is Git and why is it used?

Git is a distributed version control system (VCS) used to track changes in source code during software development. It helps developers manage code versions, collaborate with teams, and maintain project history efficiently.

Git was created by:

Linus Torvalds

for Linux kernel development.

Why Git is Used

Git is widely used because it provides:

• version tracking
• collaboration support
• branching and merging
• backup and recovery
• distributed development

Key Features of Git

Version Control

Tracks every code change.

Collaboration

Multiple developers can work simultaneously.

Branching

Developers can create isolated environments for features or bug fixes.

Fast Performance

Operations are optimized locally.

Distributed Architecture

Every developer has a full repository copy.

Real-World Usage

Git is heavily used in:

• Java development
• microservices projects
• DevOps pipelines
• cloud-native applications
• open-source projects

Common Git Platforms

• GitHub
• GitLab
• Bitbucket

Git is considered an essential skill for modern software engineers because almost every enterprise project uses version control systems.

How does Git differ from other Version Control Systems (VCS)?

Git differs from traditional version control systems mainly because it is:

• distributed
• fast
• branch-friendly

Traditional VCS tools include:

• SVN
• CVS

Centralized VCS

In centralized systems:

• one central server stores code
• developers depend heavily on server access

Example:

SVN

Distributed VCS (Git)

In Git:

• every developer has a complete repository copy
• most operations work locally

Key Differences

Advantages of Git

Faster Operations

Most actions occur locally.

Better Branching Support

Feature development becomes easier.

Improved Collaboration

Teams can work independently.

Higher Reliability

Every local copy acts as backup.

Real-World Importance

Git became highly popular because modern agile development requires:

• parallel development
• fast releases
• CI/CD integration
• collaborative workflows

Git is now the industry standard for version control.

What is the difference between Git and GitHub?

Git and GitHub are related but completely different technologies.

Git

Git is a:

Version Control System

used locally to track code changes.

GitHub

GitHub is a:

Cloud-based hosting platform

that stores Git repositories online.

Simple Analogy

Git     → Tool
GitHub  → Platform using Git

Key Differences

What GitHub Provides

Remote Repository Hosting

Stores repositories online.

Collaboration Features

• pull requests
• code reviews
• issue tracking

CI/CD Integrations

Supports automation pipelines.

Team Management

Manages developer access and permissions.

Real-World Workflow

Developer workflow usually looks like:

Code → Git → GitHub

Git manages versioning locally, while GitHub enables team collaboration and cloud-based repository management.

What is a repository in Git?

A repository (repo) is a storage location where Git tracks:

• source code
• commit history
• branches
• configuration files

A repository contains everything required to manage a project using Git.

Types of Repositories

Local Repository

Stored on developer machine.

Remote Repository

Hosted on platforms such as:

• GitHub
• GitLab
• Bitbucket

Repository Structure

A Git repository contains:

.git

directory internally.

This stores:

• commits
• branches
• metadata
• history

Example

Initialize repository:

git init

Clone repository:

git clone repository-url

Why Repositories are Important

Repositories help developers:

• maintain project history
• collaborate safely
• manage versions
• recover old code

Real-World Usage

Every enterprise application:

• Spring Boot projects
• microservices
• frontend applications

typically has its own Git repository.

Explain the concept of a commit in Git

A commit in Git represents a snapshot of the project at a specific point in time. Every commit records:

• code changes
• author information
• timestamp
• commit message

Commits help developers track project evolution.

Commit Workflow

Step 1: Modify Files

Developer changes source code.

Step 2: Stage Changes

git add .

Step 3: Create Commit

git commit -m "Added login feature"

Each commit receives a unique hash ID.

Why Commits are Important

Version History

Tracks all project modifications.

Rollback Support

Developers can restore previous versions.

Collaboration

Team members understand changes clearly.

Audit Trail

Provides development history.

Best Practices for Commit Messages

Use meaningful messages:

Fixed JWT authentication issue
Added Kafka producer configuration

Avoid vague messages:

Updated code

Real-World Importance

Commits are critical in:

• agile development
• release management
• CI/CD pipelines
• production debugging

Every professional development workflow depends heavily on structured commit history.

What is the difference between a working directory, staging area, and repository in Git?

Git internally manages files in three major areas:

• working directory
• staging area
• repository

Understanding these areas is fundamental for Git workflows.

Working Directory

The working directory contains actual project files currently being edited.

Example:

• Java source files
• configuration files
• HTML templates

Changes here are not yet tracked by Git.

Staging Area

The staging area acts as an intermediate layer before commit.

Files are added using:

git add .

Purpose:

• select specific changes for commit

Repository

The repository stores permanently committed snapshots.

Changes enter repository after:

git commit

Workflow Diagram

Working Directory
        ↓
   Staging Area
        ↓
    Repository

Key Differences

Real-World Importance

This separation allows developers to:

• review changes carefully
• commit selectively
• maintain clean version history

It is one of Git’s most powerful workflow features.

Define branching in Git and its importance

Branching in Git allows developers to create separate lines of development without affecting the main codebase. Each branch acts as an independent workspace where developers can:

• add features
• fix bugs
• test code

without impacting production code.

Default Branch

Usually:

main

or

master

What Branching Enables

Feature Development

Develop new features independently.

Bug Fixes

Fix production issues safely.

Parallel Development

Multiple developers work simultaneously.

Safe Experimentation

Test ideas without affecting stable code.

Common Git Commands

Create branch:

git branch feature-login

Switch branch:

git checkout feature-login

Merge branch:

git merge feature-login

Real-World Workflow

Typical enterprise workflow:

main
 ├── feature-auth
 ├── feature-payment
 └── bugfix-api

Importance of Branching

Branching is critical for:

• agile development
• CI/CD pipelines
• team collaboration
• release management

Git branching is lightweight and extremely fast, making it one of Git’s biggest advantages.

What is a HEAD in Git?

HEAD in Git is a pointer that refers to the currently active commit or branch. It indicates:

• current working branch
• latest checked-out commit

In most cases:

HEAD → main

Meaning:

• developer is currently working on:

main

branch.

How HEAD Works

When switching branches:

git checkout feature-login

HEAD moves automatically:

HEAD → feature-login

Detached HEAD State

Sometimes HEAD points directly to a commit instead of a branch.

Example:

git checkout commit-id

This is called:

Detached HEAD

Why HEAD is Important

HEAD helps Git determine:

• current branch
• current code state
• next commit location

Real-World Importance

Understanding HEAD is essential for:

• debugging
• branching
• merging
• rollback operations

It plays a central role in Git’s internal navigation system.

What does the 'clone' operation in Git do?

The git clone command creates a complete copy of a remote repository on the local machine.

It downloads:

• source code
• commit history
• branches
• configuration

Example:

git clone https://github.com/project/repo.git

What Happens During Clone

Git creates:

• local repository
• working directory
• remote connection

By default:

origin

points to the remote repository.

Benefits of Cloning

Full Project Copy

Developer receives entire project history.

Offline Development

Most operations work locally.

Easy Collaboration

Developers contribute independently.

Backup Support

Each clone acts as repository backup.

Real-World Usage

Developers commonly:

• clone company repositories
• clone open-source projects
• contribute code changes

Clone is usually the first Git command developers use in a new project.

How does Git store information?

Git stores information using a content-addressable filesystem. Instead of tracking files traditionally, Git stores:

• blobs
• trees
• commits
• tags

inside:

.git

directory.

Core Git Objects

Blob

Stores file content.

Tree

Represents directory structure.

Commit

Stores snapshot metadata.

Tag

Marks important commits.

How Git Tracks Data

Git identifies objects using:

SHA-1 hash

Example:

a1b2c3d4...

Benefits of Git Storage Model

Data Integrity

Hashing detects corruption.

Efficient Versioning

Only changed content stored efficiently.

Fast Operations

Local repository enables high performance.

Compression

Git optimizes storage internally.

Real-World Importance

Git’s storage mechanism enables:

• fast branching
• efficient merging
• distributed development
• reliable history tracking

This architecture is one of the main reasons Git became the industry-standard version control system.