Forem: Abhimanyu Kumar

How DNS Resolution Works

Abhimanyu Kumar — Wed, 21 Jan 2026 05:03:38 +0000

Introduction: DNS as the Internet’s Phonebook

Imagine you want to call a friend.
You don’t remember their phone number, but you remember their name.
So you open your phonebook, search the name, and get the number.
DNS (Domain Name System) works the same way.

Humans remember: google.com
Computers understand: 142.250.195.46 (IP address)

DNS translates human-friendly domain names into machine-friendly IP addresses.
This process is called DNS Resolution.

Why Does Name Resolution Exist?

If DNS didn’t exist:

You would have to type IP addresses instead of website names
Websites changing servers would break bookmarks
The internet would be unusable for humans So DNS exists to make the internet scalable, flexible, and human-friendly.

What is the `dig` Command?

dig stands for Domain Information Groper.
It is a DNS diagnostic tool used to:

Inspect DNS records
Understand how a domain is resolved
Debug DNS issues

Think of dig as an X-ray machine for DNS lookups.
dig google.com

This shows:

Which servers were contacted
What records were returned
How long it took

DNS Resolution Happens in Layers

DNS resolution does not happen in one step.
It happens in a hierarchy:

Root Name Servers
TLD Name Servers (.com, .org, .in)
Authoritative Name Servers

Let’s understand each layer using dig.

Understanding dig . NS → Root Name Servers

dig . NS
What does this mean?

. (dot) represents the DNS root
This command asks: “Who manages the entire DNS system?”

Real-life example
Imagine a country:

The central government doesn’t know every house address
But it knows which state offices exist

Root servers don’t know IPs of websites
They only know where to find TLD servers

Understanding dig com NS → TLD Name Servers

dig com NS

What does this mean?

Asking: “Who manages all .com websites?”

Real-life example

Continuing the address analogy:

Country → State → City → House
.com is like a state
TLD servers know which authoritative servers manage domains

They don’t know google.com IP,
but they know who to ask next.

Understanding dig google.com NS → Authoritative Servers

dig google.com NS

What does this show?

The authoritative name servers for google.com
These servers hold the actual DNS records

Real-life example
This is like reaching the local house registry office:

They know the exact address
Final and trusted source of information

Authoritative servers give the real IP address

Understanding dig google.com → Full DNS Resolution Flow

dig google.com

This triggers the complete DNS resolution process.

Step-by-step flow (Real-life analogy)

Browser asks the Recursive Resolver

“Where is google.com?”
Resolver asks Root Server

“Who handles .com?”
Root replies

“Ask the .com TLD servers”
Resolver asks TLD Server

“Who handles google.com?”
TLD replies

“Ask Google’s authoritative servers”
Resolver asks Authoritative Server

“What is the IP of google.com?”
Authoritative server replies

“Here is the IP: 142.xxx.xxx.xxx”
Resolver returns the IP to the browser
Browser connects to Google’s server

What Are NS Records and Why They Matter?

NS (Name Server) records tell:

Which servers are responsible for a domain

Why important?

Load balancing
Fault tolerance
Faster resolution
High availability

Without NS records:

DNS delegation would fail
Websites would become unreachable

Role of Recursive Resolver (Behind the Scenes)

The recursive resolver (ISP / Google DNS / Cloudflare DNS):

Performs all DNS steps on your behalf
Caches responses for faster future access
Protects browsers from DNS complexity

Browsers do not talk to root servers directly.

Connecting DNS to Real Browser Requests

When you type:

https://google.com

Behind the scenes:

DNS resolves the domain
Browser gets the IP
TCP connection is created
HTTPS handshake happens
Webpage loads

DNS is the first and mandatory step in web communication.

Less time to coverup summary

DNS is the foundation of the internet
dig helps visualize DNS resolution
Resolution happens in layers
Recursive resolvers hide complexity
Every browser request starts with DNS

Understanding Network Devices

Abhimanyu Kumar — Tue, 20 Jan 2026 06:27:50 +0000

Imagine this,
You open your laptop, type chaicode.com, and press Enter.
Within a second a page appears. Have you wondered how that page reached you?
It didn't just magically appear.
Behind the scenes, some networking devices worked together like a team.

Let's understand With a story

Internet starts from Outside your home

Think of the internet as a very big city full of information:

Website
Videos
Apps
Servers

Your home and office is just a small house in that city.
To bring network into your house, we need some helpers.

Modem -- The Internet Door of Your home

First understand, What is Modem?
A modem is the first device that connects your home to the internet.

Without a modem:

No Internet
No Website
No YouTube

Let's understand with a example
Modem is like a main gate of your house
It allows the internet to enter your home.

Internet comes from your ISP(Internet service provider) -> Jio, Airtel etc..
The modem understand their signals and convert them into data your device can use.

No modem == No internet

Router - Who gets the internet?

Now the internet is inside your house.
But you have:

Mobile
Laptop
Smart TV

Who decides which gets what data?
That's the router job

What is Router?
A router sends internet data to correct device.
Example: Router is like a traffic police
it sees:

This data is for phone
This is your laptop

And sends it correctly

One internet connection
Many devices
Router manage everything

Hub vs Switch - Talking Inside the network

Inside an office or lab, many computer are connected together.
For this, we use hub and switch.

Let's we will take an example of the classroom.

Hub -Old Style (Not Smart)

A hub sends data to everyone.

Teacher shouts a message in the class
Even students who don't need to hear it.

Problem:

slow
wastes data
Not secure

Switch -Smart Choice

A switch sends data only the correct computer.

Example:

Teacher gives a letter to one student, Only that student reads it.

Benefits:

Fast
Secure
Used everywhere today

Modern network use switches, Not hubs

Firewall - The Security Guard

The internet is useful, but it is also dangerous.
Hackers, viruses, unwanted traffic all exists.
That's why we need a firewall.

First understand, What is Firewall?
A firewall checks every request coming in or going out.

See, Firewall is like a security guard at a gate

Allowed person -> come in
Unknown person -> Stop

Firewall protects:

Computer
Servers
Database

Load Balancer -> Handling Too many users

Let's take a example of Flipkart: Flipkart announced 80% discount of every product, Now what will happen Thousand of the people visits their website to purchasing products at a same time.
One server will get tired
So what do we do?

Here the concepts of load balancer comes?

What is load balancer?
A Load Balancer shares traffic between many servers.

We see at Toll plaza on highway

One gate -> traffic jam
Multiple gats -> Smooth traffic

Load Balancer:

Makes website fast
Prevents server crash
Used in big apps like Flipkart, Netflix

Short and precise meaning of all is:

Internet comes from ISP
Modem brings it inside
Router sends it to right device
Firewall checks security
Load balancer manages heavy traffic
Switch connects internal systems
Data reaches server
Response comes back to you

Inside Git: How It Works and the Role of the .git Folder

Abhimanyu Kumar — Mon, 05 Jan 2026 05:40:58 +0000

when i run Git commands like git add or git commit, everything feels simple.
But behind the scenes, Git is doing a lot of serious work.

The real magic of Git lives inside the hidden folder called .git.

If you truly want to understand Git, Not just use it you must understand what happens inside this folder.

Let's open Git from the inside.

The Moment Git Comes Alive

Imagine you have a normal project folder.

myProject

Now run this command

git init

suddenly , a hidden folder appears That is:

.git/

This single folder turns your project into Git repository.

If the .git folder is deleted, Git forgets everything.
But your file remain, but Git memory is gone.

This tells one thing:

Git is not the files -- Git is the history stored in .git.

Now, What is the .git Folder Really?

Here we will think like as a Git brain.

It stores:

Every commit you have ever made.
Every file version.
Every branch.
Every message.
Every pointer.
The complete timeline of your project.

Let's Enter the .git folder

Inside .git, you'll see something like this:

Each part has a clear responsibility

HEAD - Where You Are Right Now

Head is a pointer.

it tells Git:

"This is the current commit you are working on."

usually, it points to branch like main.
When you switch branches like main.

When you switch branches or checkout a commit, HEAD moves.
That's how Git always knows your current position in history

objects/ - The heart of Git ❤️

This is the most important directory.

Everything in Git becomes an object and is stored here:

File contents
Folder Structure
Commits
Messages

Git uses hashes (SHA-1) to store objects.

That means:

Same object -> same hash
No duplication
Data integrity guaranteed

Git doesn't care about filenames here -- only content.

index -> The Stagging Area

When you run:

git add .

Changes are written to the index file.

This file represents:

"What will got into the next commit"

It’s a buffer between working files and permanent history.

That’s why Git allows:
Partial commits
Clean control
Intentional snapshots

refs/ -> Branches & Tags

This folder stores references to commits.

refs/heads/master

This file contains a commit hash.
So a branch is not a copy of code
it’s just a pointer to a commit.
That’s why branches are:

Lightweight
Fast
Cheap to create

logs/ -> Git's Memory Timeline

Every movement of HEAD is logged here.
This is how Git can:

Recover lost commits
Undo mistakes
Support git reflog Even if you “lose” a commit, Git still remembers it — temporarily.

config – Repository Settings

This file stores:

Repo-specific configuration
Remote URLs
User preferences

It’s local to the repository and overrides global settings.

What Happens When You Run Git Commands?

Let’s connect commands to internal behavior.

git add

Updates the index
Does not create history

git commit

creates a new commit object
Stores snapshot in objects/
Moves branch pointer
Updates HEAD

git checkout

Moves HEAD
Updates working directory

git log

Reads commit objects
Follows parent links

Why Git Is So Fast

Because:

Files are hashed
Objects are immutable
No duplication
Everything is local

Git doesn’t ask a server:

“What changed?”

Git already knows.

Why Deleting .git Is Dangerous

If you delete .git:

All commits are gone
All branches disappear
History is erased

Your files survive — but Git becomes blind.

That’s why .git is sacred.

Git is not magic things
it is:

Smart data structures
Clear pointers
Immutable snapshots
Careful tracking

Once you understand .git, Git commands stop feeling scary.

You stop memorizing commands
and start reasoning about behavior.

Git for Beginners: Basics and Essential Commands

Abhimanyu Kumar — Sun, 04 Jan 2026 03:13:31 +0000

Introduction

If you are learning web development, later or sooner you will be listen this sentences
"Push your code to GitHub"

But before GitHub there is Git

Git is not just another tool, it is the foundation of software development.
Almost every company, open-source project, and developer uses Git daily.

In this, here we will see all about the Git and their command, which comes to use in the day to day life.

What is Git?

Git is the distributed version control system. It gives your code a memory.

Track changes in your code
Save different version of your project
work with other developers without overwriting each other's work
Go back in Time if somethings break

Use of Git

Before git, developer used:

Pendrive
Email attachments
Shared folder
Files like final_1, final_1, last_final

This makes overwhelming codes, it become causes of

Lost code
Overwritten changes
No history
No collaboration

This all of the problems solved by the version control system, That is GIT

Git Provides you to : -

Keeps your full history of changes
Shows who changes and what changed
Allow collaboration with team
Makes mistake reversible

That's why everyone loves Git

Git Basic and some core Technologies

Before using the Git command, let's have some understand the important terms.

1. Repository(Repo)

This is nothing just a folder, where Git is tracking.
It contains:

Your project files
Git history
Git configuration

Once you init a git in your project create on file inside your project, and this files tracks your all the changes and history that you have done.

2. Commit

A Commit is a snapshot of your code at a specific time

Think like this:

A unique ID

Author name

Date & time

Message describing the change

3. Branch

A Branch is an independent line of development

Main branch - Stable code
Other branch - experiments, feature, fixes

4. Head

Head is a pointer to point your current commit.
Head shows you are right now in project history.

5. Git workflows

Three stages are there in Git works

Working directory
Staging Area
Repository

Installing Git

Windows: Download from git-scm.com
macOS : brew install git
Linus : sudo apt install git
after installation check version

git --v or git --version

Common Git commands

1. git-init
initilized a new Git repo

git init

2. git status
show your current status of your project

git status

Modified files
staged files
untracked files

3. git add
Adds file to the staging area

git add or git add .

staging means : :I want to include these changes in the next commit.

4. git commit
save changes permanently to the git history

git commit -m "Message"

Always write meaningful commit message

5. git log
shows commit history

git log

you can see:

commit history
Author
Date
Message

6. git branch
show all branch

git branch

Create a new branch

git create "branch name"

7. git checkout
switch between branches

git checkout branch-name

8. git checkout -b
create + switch branch in one command

git checkout -b branch-name

Why need to learn version control for every developer

Work confidently in teams
Debug faster
Build professional habits
Prepare for Jobs & internship

Conclusion

Git is not just a tool.
it is :

A safety net
A collaboration System
A time machine of your code

Why Version Control Exists: The Pendrive Problem

Abhimanyu Kumar — Thu, 01 Jan 2026 08:22:47 +0000

Introduction

Modern developers take version control for granted.
We clone repositories, create branches, commit changes, and push code—all without thinking twice.
But this convenience was born from a time when collaboration was fragile and mistakes were permanent.

Before Git, teams didn’t share repositories.
They shared pendrives.
And that simple choice created one of the biggest productivity problems in software history.

What Version Control Actually Means

Version control is a system that:
Keeps a timeline of code changes
Records who made each change
Allows recovery of older versions
Enables multiple developers to work safely

In short:

Version control gives code a past, a present, and a recoverable future.
But why was this ever needed?
To understand that, we must revisit the **pendrive **era.

The Pendrive Workflow Era 🕰️

Imagine a small freelance project with three developers:

Dev – UI & Styling
Kunal – Business Logic
Riya - Bug Fixes & Testing

They are building a web app and decide to use a **pendrive **to share code.

There is only one copy of the project at any time.

A Realistic Pendrive Example 💾

Step 1: The First Handoff
Dev creates the basic UI and saves the project on the pendrive.
📁 web_app/
He gives the pendrive to Kunal.

Step 2: Logic Added
Kunal adds authentication and core logic.
Everything works well on his machine.
He saves the updated project and hands the pendrive to Riya.

Step 3: Parallel Work Creates Trouble ⚠️
While Riya is fixing bugs, Dev improves the UI on his local copy:

Better layout
Cleaner CSS Dev doesn’t have Kunal’s latest logic changes. Later, Riya finishes her fixes and gives the pendrive back to Dev.

Dev copies the pendrive code and overwrites his folder.

💥 What just happened?

Kunal’s logic is gone
Riya’s fixes are mixed unpredictably
Dev’s UI changes partially survive

The Worst Part: Nobody Notices Immediately

The app still runs.
So the team assumes everything is fine.

Days later:

A feature disappears
A bug returns
Someone asks, “Wasn’t this already fixed?”

No one can answer:

Who removed it?
When did it break?
Can we go back? The pendrive has no memory.

The Backup Folder Explosion 📂

To avoid losing work again, the team creates backups:

web_app_backup
web_app_backup_fixed
web_app_backup_final
web_app_backup_final_latest

Each developer has a different** “final” **version.

Ironically, backups increase confusion instead of reducing it.

Core Problems of the Pendrive Model ❌

Overwritten Work Last copy wins, others vanish.
No Change History Code changes have no explanation.
No Accountability Bugs have no owner.
No Safe Parallel Work Only one person can work confidently.
No Rollback Mistakes are permanent.

These issues weren’t caused by careless developers.
They were caused by a broken collaboration model.

The First Improvement: Tracking Changes 🧠

Developers then imagined a tool that could:

Save every change
Attach author & time
Show differences between versions

This idea solved visibility, but not coordination.
Even with tracking, everyone still worked on separate copies.

The bigger question became:

“Which version should everyone trust?”

The Shift to a Shared Source 🌐

To fix this, teams moved code to a central server.

Now:

Everyone pulled code from one place
Everyone pushed changes back

This solved synchronization —but introduced risk.

If the server failed:

Work stopped
History could be lost

Collaboration improved, but remained fragile.

Why Distributed Version Control Changed Everything 🔥

The breakthrough idea was simple but powerful:

Every developer should have the full project and full history.

This meant:

No single point of failure
Offline work became possible
Experiments were safe
Recovery was guaranteed

Instead of trusting a pendrive or a server, developers trusted history itself.

Life After Version Control

With proper version control:

Code stopped disappearing
Bugs became traceable
Collaboration scaled naturally
Developers worked with confidence

Mistakes became reversible, not catastrophic.

Conclusion

Version control was not invented as a luxury.
It was invented because:

Pendrives failed
Shared folders failed
Manual backups failed

Passing files around simply could not support growing teams and growing codebases.
Modern version control systems replaced file sharing with history sharing.
And that single change reshaped software development forever.
If you’ve ever reverted a commit or resolved a conflict, you’re benefiting from lessons learned the hard way—one pendrive at a time.

The Thought of the Blog is:

Understanding why version control exists makes you more than a tool user.

"It makes you an engineer who understands systems, failures, and evolution."

Forem: Abhimanyu Kumar

How DNS Resolution Works

Introduction: DNS as the Internet’s Phonebook

What is the dig Command?

DNS Resolution Happens in Layers

Understanding dig . NS → Root Name Servers

Understanding dig com NS → TLD Name Servers

Understanding dig google.com NS → Authoritative Servers

Authoritative servers give the real IP address

Understanding dig google.com → Full DNS Resolution Flow

What Are NS Records and Why They Matter?

Role of Recursive Resolver (Behind the Scenes)

Connecting DNS to Real Browser Requests

Less time to coverup summary

Understanding Network Devices

Let's understand With a story

Internet starts from Outside your home

Modem -- The Internet Door of Your home

Router - Who gets the internet?

Hub vs Switch - Talking Inside the network

Hub -Old Style (Not Smart)

Switch -Smart Choice

Firewall - The Security Guard

Load Balancer -> Handling Too many users

Inside Git: How It Works and the Role of the .git Folder

The Moment Git Comes Alive

Git is not the files -- Git is the history stored in .git.

Now, What is the .git Folder Really?

Let's Enter the .git folder

Each part has a clear responsibility

HEAD - Where You Are Right Now

objects/ - The heart of Git ❤️

index -> The Stagging Area

refs/ -> Branches & Tags

logs/ -> Git's Memory Timeline

config – Repository Settings

What Happens When You Run Git Commands?

Why Git Is So Fast

Git already knows.

Why Deleting .git Is Dangerous

Git for Beginners: Basics and Essential Commands

Introduction

What is Git?

Use of Git

Git Basic and some core Technologies

1. Repository(Repo)

2. Commit

3. Branch

4. Head

5. Git workflows

Installing Git

Common Git commands

Why need to learn version control for every developer

Conclusion

Why Version Control Exists: The Pendrive Problem

Introduction

What Version Control Actually Means

The Pendrive Workflow Era 🕰️

A Realistic Pendrive Example 💾

💥 What just happened?

The Worst Part: Nobody Notices Immediately

The Backup Folder Explosion 📂

Core Problems of the Pendrive Model ❌

The First Improvement: Tracking Changes 🧠

The Shift to a Shared Source 🌐

Why Distributed Version Control Changed Everything 🔥

Life After Version Control

Conclusion

What is the `dig` Command?