Forem: Purna Pattela

Networking devices 000

Purna Pattela — Wed, 28 Jan 2026 17:21:30 +0000

Internet → Modem → Router → Switch → End Devices (PC, phone, server, etc.)
This flow shows how devices connect to the Internet in a typical network setup, where the modem links to the ISP, the router directs traffic, and the switch allows multiple devices to communicate.

            Internet
               |
             Modem
               |
           Firewall
               |
            Router
               |
            Switch
      /        |       \
Device 1  Device 2   Server Cluster
                       |
                 Load Balancer
                       |
                 Server 1, 2, 3...

Modem

Modem is often described as the gateway to internet. It is the thing which connect us to the ISP(Internet Service Provider).
We can connect only one device to the modem that can be either single device or router

Internet ↔ Modem ↔ Single device (or router)

Router

Router is a device which routes the traffic between different networks. Connects local network to the internet through modem.
Takes the responsibility of local IP addressing(DHCP - Dynamic Host Configuration Protocol). Performs NAT(Network Address Translation) so multiple devices can share the same address space(single IP).

Modem → Router → Multiple devices (wired/wireless)

Switch vs Hub

Hub : simply broadcast the data it received to all connected devices
Switch : relay the data to specific device which is intended

Both switch and hub work in LAN(local Area Network)
switch reduces the collision improves efficiency

Hub: Device A → Hub → Devices B, C, D (all get the data)
Switch: Device A → Switch → Device B (only B gets it)

Firewall

It is a device which safeguards the internet. we can configure it based on our need which type of things to allow through it or block it. It is setup generally in network level

Internet → Firewall → Router → LAN

Load Balancer

Its a device we use to manage the traffic or load. It is used to distribute the traffic to scale the system.

Internet → Load Balancer → Server 1 / Server 2 / Server 3

Devices Comparison

Device Name	Can Be Hardware	Can Be Software Replacement
Modem	Yes	Rarely (mostly hardware)
Router	Yes	Yes (e.g., virtual routers like pfSense, VyOS)
Switch	Yes	Yes (virtual switches in VMware, Hyper-V)
Hub	Yes	Rarely (mostly hardware)
Firewall	Yes	Yes (software firewalls like iptables, pfSense, Windows Firewall)
Load Balancer	Yes	Yes (software like Nginx, HAProxy, AWS ELB)

Conclusion

Understanding network devices—from modems and routers to switches, firewalls, and load balancers—gives a clear picture of how data flows and how networks are structured. Each device has a distinct role: modems connect us to the internet, routers direct traffic, switches manage local communication, firewalls provide security, and load balancers ensure scalability. Together, they form a reliable and secure system that powers both everyday internet use and complex backend applications. For web developers, knowing how these devices interact helps in designing efficient, secure, and scalable systems.

DNS record for newbies

Purna Pattela — Wed, 28 Jan 2026 14:21:53 +0000

DNS (Domain Name System) is the protocol that clients use to find the IP address of a server.

*I will explain the DNS role in below steps

User
  ↓
Web Browser
  ↓
Enter domain in search bar (e.g., example.com)
  ↓
Check local DNS cache
  ├─ If IP found → go to server
  └─ If not found → ask DNS resolver
          ↓
      DNS Resolver (ISP)
          ↓
      Check root DNS servers
          ↓
      Check TLD DNS servers (.com, .net, etc.)
          ↓
      Check Authoritative DNS server (NS record)
          ↓
      Get A / AAAA record (IP address)
          ↓
Return IP address to browser
  ↓
Browser connects to web server using IP
  ↓
Server sends back website data
  ↓
Browser renders website for user

DNS Records

There are something called DNS Records which tie the complete picture of how internet finds something.

NS record : points to DNS server responsible
A/AAAA record : Tells the IP address of the server
CNAME record : It maps one domain name to another domain name instead of pointing directly to an IP address
MX record : directs mails to the correct mail server
TXT record : mainly used as external verification info

DNS Record Comparisons

CNAME vs A/AAAA

A / AAAA Record: Points a domain directly to an IP address.
CNAME Record: Points a domain to another domain name, which then resolves to an IP via an A/AAAA record.
Use CNAME: When multiple subdomains share the same IP as the main domain (centralized management).
Use A/AAAA: When the domain/subdomain has its own unique IP or for root/apex domains.

NS vs MX

NS (Name Server) Record: Points to the DNS servers responsible for a domain. Controls all DNS records for that domain.
MX (Mail Exchange) Record: Points to the server that handles emails for the domain.
Key difference: NS = controls DNS, MX = handles emails.

Conclusion

DNS is the phonebook of the internet — it translates human-friendly domain names into IP addresses so browsers can find websites.

cURL for developers

Purna Pattela — Wed, 28 Jan 2026 13:48:49 +0000

A server is just another computer somewhere else whose job is to wait for requests and send back responses. Every time you open a website, log in to an app, or load a profile picture, your device is talking to a server in request response cycle mostly over HTTP / HTTPS.

What is cURL ?

cURL is a tool used to interact with multiple protocols from the CLI (Command Line Interface).
It supports many different protocols like http, https, dict, file, ftp, pop3, smb, etc.
In this blog lets focus only on HTTP/HTTPS Protocols using curl.

Using curl for Http/Https protocols

Generally there are 5 Methods we use in http/https protocol as a developer

Get : Used to fetch data from a server
Post : Used to send data to a server
Put : Used to replace the complete existing data
Patch : Update part of existing data
Delete : Used to remove data

To keep things simple we Discuss Only GET, POST (*syntax)

If you get get then delete was the same
If you get post then put and patch are the same

Get Method

Get is used to request a resource by default if we don't specify any protocol it send a get request.

Example without explicitly specifying the get method

curl https://example.com

Example with specifying the get method

curl -X GET https://example.com

Example for DELETE based on GET method

curl -X DELETE https://example.com/id

Post Method

The only difference we have from the get & delete is we don't send any data from the body.

There is no strict rule not to send the data in the body when we use the delete method but we(developers) don't prefer

Example to send form data

curl -X POST -d "key1=value1&key2=value2" https://example.com/new

-d : When we don't specify any headers by default curl send the data as application/x-www-form-urlencoded

Example to send JSON

curl -X POST -H "Content-Type: application/json" -d '{"key1":"value1","key2":"value2"}' https://example.com/new

TIP If we have a json data in a file we can send the json data as mentioned -d @path/to/jsonfile
In the same way we send the PUT and PATCH request

Conclusion

curl : Tool name to invoke from CLI
-X : Mention method name in capital
-H : To specify the headers
-d : To specify the data when sending the POST, PUT, PATCH requests *cURL has many other features in this blog even i did not cover 1% of its features

Git One stop

Purna Pattela — Mon, 26 Jan 2026 13:30:23 +0000

Here are some of the commonly used git commands by every developer :)

📌 Table of Contents

Why should we use Git ?
Terminology in git
Initialize a git repository
Staging the code
Checking the status
Commit the code
How to check logs
What is Git remote
Pushing the code

Why should we use Git ?

Git is a Version Control System (VCS) used to track changes in source code and efficiently manage multiple versions of a project.
Here is a blog with in-depth comparison with VCS and without VCS

Terminology in git

Term	Meaning
Repository (Repo)	A storage location for a project that contains the source code and its version history
Staging Area	An intermediate area where changes are placed before committing
Commit	A snapshot of changes made to the repository with a descriptive message
Branch	A separate line of development used to add new features or fixes
Remote	A repository hosted on a server (GitHub, GitLab, etc.)
Clone	Creating a local copy of a remote repository
Main / Master	The default branch of the repository
Merge	Combining changes from different branches
Pull	Fetching and merging the latest changes from the remote repository
Conflict	Occurs when Git cannot automatically merge changes
HEAD	A pointer to the current branch or commit
Stash	Temporarily stores changes without committing them

Initialize a git repository

Initialize a git repository means adding git feature to the codebase. It creates the .git folder when we run the command. The working of git starts from here.

git init

Staging the code

Staging is the area where changes are added before committing, telling Git which files to track for the next commit.

Track all changes

This tracks the complete folder where Git is initialized:

git add .

Track specific files or folders

To individually add files or folders for tracking:

git add file_or_folder_name

Checking the status

To see the current state of the working directory and staging area:

git status

Commit the code

After staging the changes, commit them with a message:

git commit -m "Your descriptive commit message"

How to check logs

To view the commit history:

git log

You can use options like --oneline for a summarized view:

git log --oneline

What is Git remote

A remote is a version of your repository hosted on a server like GitHub or GitLab.

To add a remote repository:

git remote add origin https://github.com/username/repo.git

To see the list of remotes:

git remote -v

we can also have the read stream and write stream as different repos

Pushing the code

To send your local commits to the remote repository:

git push origin main

Replace main with your branch name if different.

Git isn't magic

Purna Pattela — Sat, 17 Jan 2026 17:05:53 +0000

Every git repository has .git folder inside it. It will be created when we run git init. Its the folder responsible for git working.

What's Inside .git ?

That's it
.git/
├── HEAD
├── config
├── description
├── index
├── hooks/
├── info/
├── objects/
├── refs/
├── logs/
├── COMMIT_EDITMSG
├── FETCH_HEAD
├── ORIG_HEAD
└── packed-refs

Why version control system exists in the first place

Purna Pattela — Tue, 30 Dec 2025 07:53:41 +0000

Before version control systems (VCS) existed, developers shared code using pen drives, email, or file-sharing platforms. While this worked for very small projects, collaborating on larger codebases quickly became slow and error-prone.

📌 Table of Contents

Before Version Control Systems
Problems with Email and Pendrives
What Is a Version Control System?
How Git Solves These Problems
A Real-Life Example
Conclusion

Before Version Control Systems

Before version control systems existed, developers working on larger codebases had to collaborate by manually sharing code. Some used pendrives to transfer files, while others relied on email or file-sharing platforms to send code between devices. This approach was slow, error-prone, and difficult to scale as teams grew.

Problems with Email and Pendrives

When multiple developers work on the same codebase, using email or pen drives to share code becomes inefficient. Developers spend a lot of time manually updating their code and sending changes to others. This process is slow, error-prone, and difficult to manage, especially as the team grows. Keeping everyone’s code synchronized becomes a major challenge.

Another major issue is the lack of a central place to track code changes—such as who made a change, which part of the code was modified, and when the change was made.

What Is a Version Control System?

A Version Control System (VCS) is software that helps developers track changes made to files over time. It works like a time machine, allowing you to go back to previous versions of the code if something goes wrong. It also keeps a clear record of who made each change, what was changed, and when it was changed, making teamwork easier and more organized.

How Git Solves These Problems

Git solves these problems by providing the features such as below :

Tracks every change : git records who made a change, what is changed and when it is changed.
No need for Email or Pen drives : Platforms like GitHub, GitLab, and Bitbucket enable easy collaboration. Teams can also self-host a Git service using tools like Gitea.
Version history (Time Machine) : you can go any previous version of the code at any point of time.
Branching & Merging : Git allows developers to create independent branches to work on features, bug fixes, or experiments in isolation. These branches can later be merged into the main codebase, enabling multiple developers to work in parallel without interfering with each other’s changes.

A Real-Life Example

Imagine a team of developers working on a web application. Without Git, each developer would need to manually share their updated files through email or pen drives, risking overwritten code and lost changes. If a bug appears, it becomes difficult to identify who introduced it or when it was added.

With Git, each developer works on their own branch and commits changes regularly. These changes are pushed to a shared remote repository, where they can be reviewed and merged safely. If a bug is found, the team can quickly trace the exact commit that caused it or revert to a stable version of the code. This makes collaboration faster, safer, and far more reliable.

Conclusion

Version control systems have become essential in modern software development. Traditional methods like email and pen drives are slow, unreliable, and do not scale for team-based projects. Git solves these challenges by providing a structured way to track changes, collaborate efficiently, and maintain a complete history of the codebase. By using Git, development teams can work confidently, reduce errors, and focus more on building features rather than managing files.

However, Git is not the only version control solution available. Other systems such as Subversion (SVN), Mercurial, and Perforce also provide version control features and may be suitable for specific use cases. Even so, Git remains the most widely adopted choice due to its speed, flexibility, and strong community support.

Test post for my blog journey

Purna Pattela — Sat, 27 Dec 2025 17:04:08 +0000

Learning markdown from below repository
git cheat sheet

Nothing here to learn. its just for my test.
But i make it public.>