Somnath Sahu

Emmet for HTML: A beginner’s guide to writing faster markup

Somnath Sahu — Wed, 28 Jan 2026 06:13:52 GMT

If you’ve ever spent an afternoon building a website, you know the feeling: your fingers are tired from typing < and > a thousand times. Writing HTML manually can feel like building a skyscraper one literal brick at a time. It’s slow, it’s repetitive, and it’s very easy to forget to close a tag, which breaks your entire layout.

Enter Emmet.

Emmet is the ultimate "cheat code" for web developers. It is a plugin (built into most modern editors like VS Code) that allows you to type short, CSS-like snippets and expand them into full blocks of HTML with a single tap of the Tab key. It turns minutes of typing into seconds of shorthand.

What is Emmet, Really?

In simple terms, Emmet is a shorthand language. Instead of writing the full "formal" version of HTML, you write a tiny abbreviation. When you hit Tab, Emmet looks at your shortcut, recognizes the pattern, and "expands" it into the correct HTML code.

Think of it like texting "omw" instead of "I am on my way." Your phone (the editor) knows exactly what you mean and fills in the rest.

The Basics: Creating Elements

The simplest Emmet shortcut is just the name of the tag. If you want a paragraph tag, you don't need to type

The Shortcut: p

The Result (after hitting Tab):

This works for almost every HTML tag: h1, div, section, footer, nav. You just type the word and Tab it into existence.

Adding Classes and IDs

If you’ve started learning CSS, you know that we use Classes (with a .) and IDs (with a #) to identify our elements. Emmet uses that exact same syntax.

Adding a Class

If you want a div with a class of "container":

Abbreviation: div.container
Result:

Adding an ID

If you want a header with an ID of "main-title":

Abbreviation: h1#main-title
Result:

You can even combine them! Typing div.box#hero will give you a div with both the class "box" and the ID "hero."

Nested Elements: Building Structures

This is where Emmet starts to feel like magic. You can describe the "family tree" of your HTML in a single line using the > symbol (which means "inside").

Imagine you want a navigation bar (nav) that contains an unordered list (ul), which contains a list item (li).

Abbreviation: nav>ul>li
Result:

<nav>
<ul>
<li>li>
ul>
nav>

Multiplication: Creating Lists Fast

One of the most annoying parts of HTML is writing repetitive lists. If you need five list items, you usually have to copy and paste. With Emmet, you just use the * (multiplication) symbol.

Abbreviation: ul>li*5
Result: Emmet will generate a ul with five li tags inside it instantly.

Attributes and Text

Need a link that points to Google? Or a paragraph that already has text inside it?

Attributes: Use square brackets [].
- a[href="https://google.com"] expands to .
Text Content: Use curly braces {}.
- p{Hello World} expands to Hello World.

The Ultimate Shortcut: The Boilerplate

Every HTML file starts with the same "head" and "body" tags. Typing this out every time is a chore. In most editors, Emmet provides a global shortcut to generate the entire starting structure of a webpage.

The Shortcut: !
The Result: A full, valid HTML5 skeleton including the , , , and tags.

Why Every Beginner Should Use It

You might think, "Shouldn't I learn to type it the long way first?"

While it's important to understand the structure, using Emmet actually helps you learn. Because Emmet uses CSS-style syntax (dots for classes, hashes for IDs), it reinforces the relationship between your HTML structure and your CSS styling. Plus, it prevents "syntax errors"—Emmet never forgets to close a tag or add a closing bracket.

How to Practice

Open VS Code.
Create a file named index.html.
Type ! and hit Tab.
Inside the , try typing div.wrapper>h2{Welcome}+p*3 and hit Tab.

CSS Selectors 101: targeting elements with precision

Somnath Sahu — Wed, 28 Jan 2026 04:22:58 GMT

Imagine you have a document with dozens of paragraphs, five different buttons, and three separate menus. If you want to change the color of just one specific button to "sunset orange," how do you tell the browser which one you mean?

This is the job of CSS Selectors. If HTML is the skeleton of your site, CSS Selectors are the laser-guided targeting system that allows you to pick out exactly which part of that skeleton you want to style.

Without selectors, CSS would be a blunt instrument; you’d be forced to change every single paragraph on your site even if you only wanted to highlight one.

The Real-World Analogy

Think of a browser as a large crowd of people.

Element Selector: Calling out, "Everyone wearing a shirt, step forward!" (Broad)
Class Selector: Calling out, "Everyone wearing a blue shirt, step forward!" (Specific)
ID Selector: Calling out, "Hey, John Doe! Step forward!" (Unique)

1. The Element Selector

The simplest way to target something is by its HTML tag name. If you want every paragraph on your site to have a font size of 18px, you use the element selector.

p {
  font-size: 18px;
}

What it does: It finds every

tag on your page and applies the style. It’s great for setting "global" styles, like the default font for your whole site.

2. The Class Selector

Usually, you don’t want every paragraph to look the same. You might want some paragraphs to look like standard text and others to look like "Alert" messages. This is where Classes come in.

In your HTML, you add a class attribute:

Be careful!

. In CSS, you target that class by starting with a dot (.).

.alert-text {
  color: red;
  font-weight: bold;
}

Why use it: Classes are reusable. You can give ten different elements the class .alert-text, and they will all turn red and bold.

3. The ID Selector

Sometimes, an element is truly unique—like your navigation bar or your main "Hero" section. For these, we use an ID. In HTML, you use id="main-header". In CSS, you target an ID by starting with a hashtag (#).

#main-header {
  background-color: navy;
}

The Rule: Unlike classes, an ID should only be used once per page. It’s like a Social Security number for an HTML element.

4. Grouping Selectors

What if you want your h1, h2, and p tags to all use the same font family? You could write three separate rules, but that's a lot of typing. Instead, you can group them using a comma.

h1, h2, p {
  font-family: Arial, sans-serif;
}

This tells the browser: "Apply this font to the h1, AND the h2, AND the p."

5. Descendant selectors

Sometimes you only want to style an element if it’s inside another specific element. For example, you might want links inside your footer to be gray, but links in your main content to be blue.

To do this, you list the "parent" selector followed by a space, then the "child" selector.

footer a {
  color: gray;
}

Translation: "Find all tags that are descendants of a

Understanding HTML tags and elements

Somnath Sahu — Wed, 28 Jan 2026 04:08:51 GMT

Building a website can feel like trying to solve a giant puzzle where the pieces are written in a foreign language. But once you peel back the layers of fancy graphics and animations, you find a remarkably simple foundation: HTML.

If a website were a house, HTML (HyperText Markup Language) would be the wooden studs, the bricks, and the foundation. It doesn’t decide what color the walls are (that’s CSS) or how the smart-locks work (that’s JavaScript). Instead, it tells the browser exactly what the content is. It says, "This is a heading," "This is a paragraph," or "This is a button."

To master the web, you have to understand the language of these building blocks: Tags and Elements.

What exactly is an HTML tag?

Think of an HTML tag as a set of instructions for the browser. On their own, browsers are actually pretty literal. If you send a browser a plain text file, it will just show a wall of text. It has no idea that the first line is supposed to be a title or that the third sentence should be a link.

Tags are the labels we wrap around our text to give it meaning. They almost always come in pairs, acting like a set of invisible bookends.

The Anatomy of a Tag

Most tags consist of three parts:

The Opening Tag: This tells the browser, "Hey, I'm starting a specific type of content here." It looks like this:
. The angle brackets < > are the signature of HTML.
The Content: This is the actual stuff you want people to see, like "Hello, world!"
The Closing Tag: This tells the browser, "Okay, that's the end of this specific section." It looks just like the opening tag but adds a forward slash:
.

Tag vs. Element: what’s the difference?

In casual conversation, people often use the words "tag" and "element" interchangeably. However, if you want to speak like a pro, there is a subtle but important distinction.

The Tag is just the individual piece of code (like
or
).
The Element is the whole package. It’s the opening tag, the content inside, and the closing tag all combined.

Think of it like a sandwich. The bread slices are the tags, the meat is the content, and the entire sandwich is the element. If you take away the bread, you just have a mess on your hands. If you take away the meat, you just have two pieces of bread. You need the whole "element" for it to be a satisfying meal for the browser.

Self-Closing (Void) elements

In every language, there are exceptions to the rules. In HTML, some elements don't need a "sandwich" structure because they don't contain any text or other elements. These are called Self-closing or Void elements.

A classic example is an image. You don't put text "inside" an image; you just tell the browser where the image file is located. Another common one is the tag, which simply creates a line break (like hitting "Enter" on your keyboard).

Because there’s no content to "wrap," these tags don't need a closing tag. They just stand alone: or . It’s efficient and keeps your code from getting cluttered with unnecessary tags.

Block vs. Inline : how elements behave

This is where beginners often get tripped up. Not all HTML elements take up the same amount of space on the screen. Depending on how they are categorized, they either like to share their "row" or they want the whole row to themselves.

1. Block-Level Elements

Block-level elements are the "space hogs" of the web. Whenever you use a block-level element, it automatically starts on a new line and stretches to the full width of the page. It creates a "block" of space.

Common examples:
,
through
,
,
, and
.

Analogy: Think of these like bricks in a wall. Each brick sits on its own level or takes up a specific chunk of vertical space.

2. Inline Elements

Inline elements are the "socialites." They only take up as much width as necessary and are perfectly happy sitting right next to other elements in the same line.

Common examples: , (links), and (bold text).

Analogy: Think of these like words in a sentence. You can have a bold word in the middle of a paragraph without that word jumping to a new line.

Understanding this distinction is the secret to moving from "my website looks like a mess" to "I know exactly why that button is jumping to the next line."

"Must-Know" tags

You don't need to memorize the hundreds of available HTML tags to build a great site. About 80% of the web is built using a small handful of workhorse tags:

Headings (
to
): These define the hierarchy of your page.
is your main title, while
might be a sub-header.

Paragraphs (
): The standard tag for any chunk of text.

Links (): Short for "anchor," this is what makes the web a web. It connects one page to another.

Divisions (
): This is a generic container. It doesn’t do anything to the text, but it’s used to group other elements together so you can style them later with CSS. It’s like a cardboard box for your code.

Spans (): Similar to a div, but it’s inline. You use it to target a small piece of text inside a larger paragraph.

Inspect element : dev tools

One of the best ways to learn HTML isn't by reading a book—it's by "spying" on your favorite websites.

If you’re using a browser like Chrome or Firefox, right-click anywhere on a webpage and select "Inspect." A window will pop up showing you the exact HTML elements used to build that page. You can see how developers used
tags to create layouts and tags for navigation. It turns the entire internet into your personal classroom.

Summary

HTML tags and elements might seem intimidating at first, but they are just the labels that give the digital world structure.

Tags are the instructions (
).

Elements are the complete units (
Hello
).

Block elements take up a whole line; inline elements sit side-by-side.

Once you understand these basic rules, you aren't just a "user" of the internet anymore—you're a creator. Every complex website you’ve ever visited, from Facebook to Amazon, is just a giant collection of these simple building blocks stacked on top of each other.

Feature	TCP	UDP
Reliability	Guaranteed delivery	No guarantee (Best effort)
Speed	Slower (due to overhead)	Faster (no handshakes)
Order	Data arrives in sequence	Data can arrive out of order
Method	Connection-oriented	Connectionless

TCP working: 3-way handshake & reliable communication

Somnath Sahu — Tue, 27 Jan 2026 08:16:09 GMT

The internet is essentially that noisy room. Millions of devices are shouting data at once, and cables can get overloaded, causing pieces of information to just... vanish. If we sent data without rules, our emails would arrive scrambled, and our software updates would be missing vital pieces of code, rendering them useless.

This is why we have TCP (Transmission Control Protocol). It is the "polite conversation" protocol that ensures every single bit of data arrives exactly as intended.

The Problems TCP Solves

Before we look at how it works, we have to understand the chaos it prevents. When data travels across the web, it is broken into small "packets." Without TCP, three big things go wrong:

Packet Loss: A packet gets dropped by a router and never arrives.

Out-of-Order Delivery: Packet #3 arrives before Packet #1 because it took a different physical path.

Corruption: A packet arrives, but its data was mangled during the journey.

TCP is designed to be the "quality control manager" that fixes all of these issues.

The Secret Sauce: The 3-Way Handshake

Before TCP sends a single byte of actual data (like your profile picture or a chat message), it needs to make sure the other side is ready, willing, and able to talk. It does this through a process called the 3-Way Handshake.

Imagine two people, Alice and Bob, trying to start a phone call.

Step 1: SYN (Synchronize)

Alice sends a message: "Hey Bob, I want to talk. My starting sequence number is 1000." In technical terms, the client sends a SYN packet. This packet contains a random "Sequence Number" that will be used to keep the data in order later.

Step 2: SYN-ACK (Synchronize-Acknowledge)

Bob hears Alice and responds: "I hear you, Alice! I’m ready too. I received your 1000, so I’m looking for 1001 next. Also, my starting sequence number is 5000." The server sends a SYN-ACK. It acknowledges Alice’s request and sends its own sequence number.

Step 3: ACK (Acknowledge)

Alice finishes the handshake: "Got it, Bob! I’m looking for your 5001 next. Let’s start!" Alice sends an ACK packet back. The "connection" is now officially established.

How Data Actually Moves

Once the handshake is done, the data transfer begins. But TCP doesn't just "send and forget." It uses a system of Sequence Numbers and Acknowledgements.

Think of it like a teacher handing out numbered worksheets to a student. The teacher gives the student Page 1, Page 2, and Page 3. The student then shouts back, "I have up to Page 3!"

If the teacher sends Page 4, but the student never acknowledges receiving it, the teacher assumes it was lost and sends Page 4 again. This is called Retransmission.

Reliability, Order, and Correctness

Reliability: If the sender doesn't get an "ACK" for a specific packet within a certain timeframe, it sends that packet again.

Order: If packets arrive in the order 1, 3, 2, TCP looks at the sequence numbers and puts them back in the correct order (1, 2, 3) before showing them to the user.

Correctness: Every TCP packet has a "checksum"—a digital fingerprint. If the fingerprint doesn't match the data, TCP rejects it as corrupted and asks for a fresh copy.

Saying Goodbye: Closing the Connection

A TCP connection isn't just "cut off" when the data is done; it is politely closed. This is often called a "Four-Way Teardown" because both sides have to agree to stop.

FIN: The client sends a message saying, "I'm done sending data."

ACK: The server says, "I hear you, I'll stop expecting data from you." (The server can still send data for a moment if it needs to finish something up).

FIN: The server then sends its own message: "I'm done too."

ACK: The client sends a final acknowledgement: "Understood. Goodbye!"

Summary

TCP is the reason the modern internet feels so stable. It takes a chaotic, unreliable network and turns it into a virtual "circuit" where data is guaranteed to be perfect. While the overhead of handshakes and acknowledgements makes it slightly slower than UDP, that is a small price to pay for knowing your data will arrive in one piece.

How a browser works: a beginner-friendly guide to browser internals

Somnath Sahu — Tue, 27 Jan 2026 04:17:34 GMT

Have you ever wondered what happens in that split second after you type google.com and hit Enter? To most of us, the browser feels like a magic window. You type a name, and a world of images, text, and buttons instantly appears.

But under the hood, your browser is less like a window and more like a high-speed assembly line. It is one of the most sophisticated pieces of software on your computer, acting as a translator that turns raw code into something humans can actually understand.

What is a Browser

At its core, a browser is a resource fetcher and a renderer. Its job is to go out onto the internet, find the files that make up a website (HTML, CSS, and JavaScript), and "paint" them onto your screen.

While we often think of the browser as just the window where the website lives, it’s actually a collection of specialized parts working in harmony.

The Main Components

The User Interface (UI): This is everything you see that isn't the website itself—the address bar, the back button, the bookmarks menu, and the tabs.

The Browser Engine: Think of this as the "manager." It coordinates actions between the UI and the Rendering Engine.

The Rendering Engine: This is the heart of the browser. It’s responsible for displaying the content. If you use Chrome, this is Blink; if you use Safari, it's WebKit; and for Firefox, it's Gecko.

Step 1: Networking (The Fetch)

Before the browser can show you anything, it needs the data. The Networking component handles this. It uses the rules we discussed previously (TCP/IP and HTTP) to talk to a server and ask for the files. It starts by grabbing the HTML file, which is the blueprint of the page.

Step 2: Parsing

Once the browser has the HTML, it has to "parse" it. Parsing is just a fancy word for breaking something down into a structure the computer understands.

Imagine I give you the sentence: "The cat sat on the mat." To understand it, your brain "parses" it into a Subject (The cat), a Verb (sat), and a Location (on the mat).

Browsers do the same with code. If it sees 1 + 2 * 3, it doesn't just read left-to-right; it parses it into a tree: it knows it must multiply 2 * 3 first, then add 1.

Building the DOM Tree

As the browser reads your HTML, it builds the DOM (Document Object Model). Think of the DOM as a family tree for your website. The tag is the grandparent, the is the parent, and
or
tags are the children.

Step 3: Handling the Style (CSSOM)

While the HTML tree is being built, the browser encounters CSS files. It doesn't just slap the styles onto the HTML. Instead, it creates a second tree called the CSSOM (CSS Object Model).

If the DOM is the "skeleton" of the site, the CSSOM is the "style guide" that tells the browser which bones should be blue, which should be hidden, and which should be 20 pixels wide.

Step 4: The Render Tree (The Blueprint)

Now, the browser combines the DOM and the CSSOM into the Render Tree.

This is a critical step because the Render Tree only contains things that will actually be visible on the screen. If a piece of code says display: none, it exists in the DOM, but the Render Tree ignores it. It’s the final blueprint used to build the visual page.

Step 5: Layout and Painting (The Finale)

We have a blueprint, but we don't have pixels yet. The browser finishes with two final, heavy-lifting stages:

Layout (or Reflow): The browser calculates exactly where every element goes. It figures out that the "Submit" button should be 50 pixels from the top and 20 pixels wide. It’s like a construction crew marking the ground with chalk before they start building.

Painting: Finally, the browser fills in the pixels. It draws the text, colors the buttons, and places the images. This happens incredibly fast, often in milliseconds.

Summary: From URL to Pixels

The journey from typing a URL to seeing a webpage is an incredible relay race:

Networking grabs the files.

Parsing turns HTML into the DOM (the skeleton).

Parsing turns CSS into the CSSOM (the style).

The Render Tree combines them.

Layout finds the coordinates.

Painting puts the color on your screen.

It’s a lot to take in, but remember: you don't need to memorize every gear in the machine to appreciate the engine. The browser is simply a master translator, turning code into the digital world we live in.

TCP vs UDP: when to use what, and how TCP relates to HTTP

Somnath Sahu — Mon, 26 Jan 2026 13:22:45 GMT

Imagine the internet as a massive, bustling postal system. Billions of messages fly across the globe every second, but without a set of shared rules, those messages would simply be a chaotic soup of digital noise. To make sense of it all, we use protocols—standardized sets of rules that determine how data moves from point A to point B.

Two of the most important rulesets at the heart of the internet are TCP and UDP. While they both live in the "Transport Layer" of networking, they behave like two very different types of delivery services.

TCP: the reliable courier

TCP (Transmission Control Protocol) is the internet’s gold standard for reliability. Think of it like a high-end courier service that requires a signature for every package.

When you use TCP, the sender and receiver perform a "three-way handshake" to establish a connection before any data even moves. Once the data starts flowing, TCP tracks every single packet. If a piece of data goes missing or arrives out of order, TCP stops everything and asks for it to be resent. It ensures that what you send is exactly what the other person receives—no exceptions.

It works via sync → sync ack → ack segment

UDP: the live broadcaster

UDP (User Datagram Protocol), on the other hand, is built for speed. If TCP is a formal courier, UDP is like a live megaphone announcement. It doesn’t care if you missed the first three words of the sentence; it’s going to keep talking anyway.

UDP is "connectionless." It just starts throwing data at the destination without checking if the receiver is ready or if the data actually arrived. There is no error correction and no re-sending. It’s fast, lightweight, and efficient, but it’s "risky" because data can easily be lost in transit.

Key Differences at a Glance

Feature TCP UDP

Reliability Guaranteed delivery No guarantee (Best effort)

Speed Slower (due to overhead) Faster (no handshakes)

Order Data arrives in sequence Data can arrive out of order

Method Connection-oriented Connectionless

When to Use What?

Choose TCP when accuracy is non-negotiable

If losing a single "packet" of data would break the entire result, you need TCP.

Web Browsing: You wouldn't want a website to load with missing text or broken code.

Email: An email missing the middle paragraph is useless.

File Downloads: A corrupted .zip file won't open.

Choose UDP when speed is the priority

In "real-time" scenarios, a slight delay (latency) is much worse than a tiny bit of missing data.

Online Gaming: If you’re playing a fast-paced shooter, you need the most current data now. If a packet is lost, the game just moves on to the next one rather than pausing to find the old one.

Video Streaming/VoIP: During a Zoom call, if the connection glitters for a millisecond, you might see a few stray pixels, but the video keeps playing. If Zoom used TCP, the video would freeze constantly to "catch up" on lost frames.

Where Does HTTP Fit In?

A common point of confusion for beginners is how HTTP (Hypertext Transfer Protocol) relates to these two. You might wonder: "If I'm using HTTP to browse the web, am I still using TCP?"

The answer is yes.

To understand this, we use the OSI Model, which layers protocols on top of each other.

TCP is a Transport Layer protocol. It handles the "how" of moving data (the pipes).

HTTP is an Application Layer protocol. It handles the "what" of the data (the actual website content).

The Relationship: HTTP Runs on TCP

Think of it this way: TCP is the train tracks, and HTTP is the train. The tracks provide the path and the safety mechanisms to ensure the train doesn't derail. The train carries the actual passengers (the HTML, images, and data of a website).

Because websites need to be 100% accurate to function, HTTP almost always uses TCP. When you type a URL into your browser, your computer first opens a TCP connection to the server. Once that "pipe" is secure and open, the HTTP requests and responses travel through it.

Why HTTP Doesn't Replace TCP

HTTP cannot replace TCP because they do completely different jobs. HTTP doesn't know how to "resend a lost packet" or "reorder data"—it relies on TCP to handle those messy networking details.

In recent years, a new version called HTTP/3 has actually started using a protocol called QUIC, which is built on top of UDP. However, QUIC adds its own reliability features to UDP to make it act more like TCP but faster. Even then, the concept remains: the application (HTTP) needs a transport layer (TCP/UDP) to move its data across the web.

Summary

The internet is a balance between reliability and velocity. TCP provides the sturdy foundation for our files, emails, and web pages, while UDP provides the raw speed needed for our calls and games. HTTP sits gracefully on top, focusing on delivering the content we love while trusting the layers below to handle the heavy lifting.

DNS resolution : how it works as a resolver and serve the web page

Somnath Sahu — Mon, 26 Jan 2026 11:27:08 GMT

DNS or Domain name system works as a phonebook. So whenever any user type the name google.com in the browser, it automatically lookup the associated IP and display the required content from that server. This entire lookup system is moreover known as a Domain Name System aka DNS.

How DNS works?

DNS works like a telephone directory, where it stores all the associated IP with the human readable domain name. So whenever you have entered any domain name or my personal website in the browser like somnathsahu.dev it goes to the DNS resolver which is your ISP.

Now this resolver looks for the name server for the IP and this root server directs it to the Top-Level Domain (TLD) server (e.g., for .dev).

The resolver asks the TLD server, which points it to the Authoritative Nameserver for somnathsahu.dev. The Authoritative Nameserver holds the actual IP address and sends it back to the resolver. And the resolver sends the IP address to your browser.

Now your browser uses the IP address to connect to the website's server and display the website content.

DIG Command and DNS resolution

DIG command is a powerful administrative tool that helps to query DNS name servers for troubleshooting, diagnostic, and educational purposes. It is available by default on Linux and macOS, often used to look up A, MX, or CNAME records directly from specific DNS servers.

Basic syntax of DIG command is

dig [server] [name] [type]

[server] it is an optional parameter for IP address or hostname of the DNS server to query.

[name] it helps to query a domain name. This is the DNS resource record about which you want information.

[type] it is an optional parameter. DNS record type to query, including A, MX, and NS. dig will query an A record if no type is specified by default.

For example, to execute an A record for below example

dig example.com it will return below response

; <<>> DiG 9.16.1-Ubuntu <<>> example.com ;; global options: +cmd ;; Got answer: ;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 12345 ;; flags: qr rd ra; QUERY: 1, ANSWER: 1, AUTHORITY: 2, ADDITIONAL: 1 ;; QUESTION SECTION: ;example.com. IN A ;; ANSWER SECTION: example.com. 3600 IN A 93.184.216.34 ;; AUTHORITY SECTION: example.com. 3600 IN NS ns1.example.com. example.com. 3600 IN NS ns2.example.com. ;; ADDITIONAL SECTION: ns1.example.com. 3600 IN A 192.0.2.1 ;; Query time: 10 msec ;; SERVER: 192.0.2.53#53(192.0.2.53) ;; WHEN: Sun Jan 25 14:00:00 UTC 2026 ;; MSG SIZE rcvd: 123

Some important DIG command

MX record

MX record returns mail exchange server details to send/receive emails. To troubleshoot this email records execute below command

dig example.com MX

... ;; QUESTION SECTION: ;example.com. IN MX ;; ANSWER SECTION: example.com. 3600 IN MX 10 mail.example.com. ;; ADDITIONAL SECTION: mail.example.com. 3600 IN A 192.0.2.2 ...

NS record

The name server (NS) record lists the name servers responsible for the domain. It helps to understand the domain’s DNS infrastructure.

dig example.com NS

... ;; QUESTION SECTION: ;example.com. IN NS ;; ANSWER SECTION: example.com. 3600 IN NS ns1.example.com. example.com. 3600 3600 IN NS ns2.example.com. ;; ADDITIONAL SECTION: ns1.example.com. 3600 IN A 192.0.2.1 ...

SOA record

The start of authority (SOA) record contains administrative information about the domain, including the primary name server and the domain administrator’s registered email.

dig example.com SOA

... ;; QUESTION SECTION: ;example.com. IN SOA ;; ANSWER SECTION: example.com. 3600 IN SOA ns1.example.com. hostmaster.example.com. 2021071601 3600 1800 1209600 300 ...

Tracing the DNS path

Tracing the DNS path involves following a DNS query from your computer to the authoritative name server. This process lets you see the route queries take to the final DNS server.

To trace the DNS path, append the +trace option to your command like this:

dig example.com +trace

The dig output shows the DNS servers involved at each step:

. 518400 IN NS a.root-servers.net. . 518400 IN NS b.root-servers.net. ;; Received 512 bytes from 192.0.2.1 #53(192.0.2.1) in 5 ms example.com. 3600 IN NS ns1.example.com. example.com. 3600 IN NS ns2.example.com. ;; Received 200 bytes from 192.0.2.1#53(192.0.2.1) in 10 ms example.com. 3600 IN A 93.184.216.34 ;; Received 100 bytes from 192.0.2.2#53(192.0.2.2) in 15 ms

Final words

In this article, I’ve covered the essential uses of the Linux dig command, from fundamental DNS lookups to more advanced queries and troubleshooting methods. In addition, mastering dig can enhance your network management skills

cURL - Introduction and how to getting started

Somnath Sahu — Wed, 21 Jan 2026 07:08:29 GMT

cURL is tool to transfer data from or to a server using URLs. cURL is known as a client URL. Without accessing through web, cURL tool allows to communicate with server directly. While transferring any data, it uses these protocols: DICT, FILE, FTP, FTPS, GOPHER, GOPHERS, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, MQTTS, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET, TFTP, WS and WSS.

How to start with cURL

cURL is a command line tool, directly accessible through terminal. In Mac OS/ Linux OS it comes with default but in Windows it will ask for permission first.

Note: For Windows users can install git bash and it will behave and supports some Linux based command

Use this following command to check the curl -v

Execute following command curl https://google.com first time in Windows will prompt for security risk and you need to accept that

Once you have accepted that command you will see all the information regarding that URL.

How cURL works:

cURL is a command line tool, it directly communicated with server and return only text content with certain attributes which are not in a good human readable format. It consists of status code, content, status description, Header, RawContent.

The returning data is completely depending upon the calling URL, if the calling URL is an endpoint of an API, it will return those data whether it contains with JSON or XML without validating the data types.

cURL becomes suitable alternative during API validation, it does not require any web interface to communicate, it directly call the server and returns the data.

Learn more about DNS Record types- How DNS works

cURL protocols:

curl supports numerous protocols, or put in URL terms: schemes. Here are the few protocols.

Protocol Description

DICT Lets you lookup words using online dictionaries.

FILE Read or write local files. cURL does not support accessing file:// URL remotely, but when running on Microsoft Windows using the native UNC approach works. Only absolute paths.

FTP(S) cURL supports the File Transfer Protocol with a lot of tweaks and levers. With or without using TLS.

GOPHER(S) Retrieve files.

HTTP(S) cURL supports HTTP with numerous options and variations. It can speak HTTP version 0.9, 1.0, 1.1, 2, and 3 depending on build options and the correct command line options.

IMAP(S) Using the mail reading protocol, cURL can download emails for you. With or without using TLS.

LDAP(S) cURL can do directory lookups for you, with or without TLS.

MQTT cURL supports MQTT version 3. Downloading over MQTT equals subscribing to a topic while uploading/posting equals publishing on a topic. MQTT over TLS is not supported (yet).

POP3(S) Downloading from a POP3 server means getting an email. With or without using TLS.

RTMP(S) The Realtime Messaging Protocol is primarily used to serve streaming media and cURL can download it.

RTSP cURL supports RTSP 1.0 downloads.

SCP cURL supports SSH version 2 SCP transfers.

SFTP cURL supports SFTP (draft 5) done over SSH version 2.

SMB(S) cURL supports SMB version 1 for upload and download.

SMTP(S) Uploading contents to an SMTP server means sending an email. With or without TLS.

TELNET Fetching a telnet URL starts an interactive session where it sends what it reads on stdin and outputs what the server sends it.

TFTP cURL can do TFTP downloads and uploads.

WS(S) WebSocket done over HTTP/1. WSS implies that it works over HTTPS.

Few cURL uses:

GET Request with cURL:

This uses default GET request while you curl any URLs like: https://jsonplaceholder.typicode.com/users/

Open your terminal and type the following: curl https://jsonplaceholder.typicode.com/users/

It will return the users and their properties as the response directly in your terminal.

POST request with cURL

POST request is mainly used to add new data or resources to a database by sending information to a server. You can make a POST request using cURL like this:

curl -X POST https://yourapiurl.com \ -H "Authorization: Bearer aoiueio2123olsudoas" \ -H "Content-Type: application/json" \ -d '{ "name": "your name" }'

Explanation

-X POST → Specifies the HTTP method as POST

-H "Authorization: ..." → Requires authorization token in the request header to authenticate with server

-H "Content-Type: application/json" → Tells the server that the request body is JSON

-d → Contains the data that will be sent to the server

This request sends JSON data to the API, allowing the server to create a new resource in its database.

Final Thoughts

Now a days there are tools like Postman, SOAP tool to communicate directly with that API using interface, but those UI tools works on the layer of cURL, so cURL is core for those tools, you can execute those command without modern tools as well. Yeah! sometimes during POST method these web tools are required to modify and update request body in the ui itself rather than using a command line.

Understanding network devices - the way internet serves

Somnath Sahu — Tue, 20 Jan 2026 07:34:26 GMT

Internet is very common term in now a days and how internet works that’s more fascinating. Internet is travelling through network devices whether it is a wireless or wired connection. Network devices are the core part of an internet. Lets dive into that network devices and how many are their and how it works.

Network devices are physical devices required for communication between multiple computer on a computer network. Depending upon individual’s functionality those devices are used for generating signals, forwarding, packet transferring, firewall, protocol conversion and access control to ensure secure and reliable connection.

Significance of network devices:

Network devices are taking key role to transmitting / receiving internet. There are following significance for the network devices.

Facilitates data communication and transmission between devices.

Enables secure and efficient packet transaction.

Reduce traffic congestion and managing the traffic.

Routes the traffic to make more fast and efficient.

Provides security by providing access controlling and unauthorized access.

Extend network coverage and solve signal limitations.

Layer 1: Physical device

This is core layer for any network devices, these devices are raw physical devices deals with electrical/optical signals in bit. It does not understand about MAC address or IP Address more over it deals with electrical signals.

1. Hub

Function: Hub is known for central connection point for devices in a LAN. It is an essential multiport device that connects multiple Ethernet devices into a single broadcast network segment, which makes them a central connection point during traffic congestion.

How it Works: It takes an incoming signal on one port and blindly broadcasts it to all other ports. It does not know who the recipient is.

Drawback: High network traffic collisions and security risks (everyone sees everyone's data).

Status: Currently this is Obsolete. Replaced by Switches.

2. Repeater

Function: A repeater operating at the OSI model’s physical layer (Layer 1) is a powered device that extends the signal to keep traveling further. It regenerates signals to extend the range of a network.

How it Works: It receives a weak signal (due to attenuation over long cables), amplifies it, and retransmits it.

Use Case: Extending WiFi range or Ethernet cables beyond 100 meters.

3. Modem (Modulator-Demodulator)

Function: Connects home network to the ISP (Internet Service Provider).

How it Works: Converts all the analog signals to digital signals (known as Demodulation) and digital signals to analog signals which transmits further to cable/ telephone wire lines (known as a Modulation).

Layer 2: Data link layer

This data link layer mostly involves to transmit the data and it holds own MAC address. More over in the layer defines the location of the receiver and sender’s data.

4. Switch

Function: Connects devices in a LAN (Local Area Network) with MAC address.

How it Works: It learns the MAC address of every connected device. It transmits data only to the specific port where the target device is connected. It reduces the network congestion and improves speed and security. It has two types of switch:

Unmanaged: plug and play (suitable for home/small office)

Managed: configurable for enterprise or large office use (configured VLANs, Qos)

5. Bridge

Function: Connects two separate LAN segments of a switch and make them appear as one.

How it Works: Filters traffic based on MAC addresses to keep local traffic local, reducing congestion. Largely replaced by Switches (which are essentially multi-port bridges).

6. Access Point (AP)

Function: Access point required to create a Wireless Local Area Network (WLAN).

How it Works: It acts as a bridge between wired Ethernet and wireless WiFi devices.

Difference from Router: An Access point can only provides WiFi signal; it does not route traffic or any assign IP addresses (unless it is a "Wireless Router" combo unit).

Layer 3: Network layer

In this layer multiple network inter connected and communicated. It manages and distributed by an IP address.

7. Router

Function: Connects multiple networks (e.g., Home LAN to the Internet WAN). It stop broad cast traffic and make them isolate from each other.

How it Works: It uses IP Addresses to determine the best path for data packets to travel. It maintains a Routing Table to make these decisions.

8. Brouter (Bridging Router)

Function: A hybrid device that acts as both a Bridge and a Router.

How it Works: It can route known protocols (like TCP/IP) and bridge unknown protocols (like non-routable legacy traffic) at the same time. Rarely used today.

Layer 4: Advance processing layer

In this layer mostly security underlying. Packets are communicating and filtered in this layer to prevent unauthorized access and make more secure.

9. Gateway

Function: Acts as a translator between two dissimilar networks. It works to translate private LAN request into a public internet requests.

How it Works: It can convert protocols, data formats, or architectures (e.g., connecting a TCP/IP network to a legacy Mainframe network).

10. Firewall

Function: Security guard. Controls incoming and outgoing traffic based on security rules.

How it works: It acts as a security guard and controls all the incoming and outgoing traffic to prevent unauthorized access. It comes with hardware and software both. In hardware it installed on the network edge and in software it is installed on a particular server. It filters data packet by looking at headers (IP/Port) and tracks all active connections.

DNS record types : explanation and detailed overview

Somnath Sahu — Sun, 18 Jan 2026 20:11:33 GMT

In this digital era, every time whenever you have visited any website and your website is failed to open, now you might think - “what the hell this website is not working properly? does my internet not working…”. So before thinking why this website is not working, let’s understand how any website works. Each website which serves the content, hosted their content in a location which is known as a server. Each server has a unique address which is known for IP address. IP address is consists or random number like 123.44.34.2 which is quite a elusive. Now, the website owner has reserved a unique name which helps them to share that name with the customer like (google.com) and that name does not change unlike IP address changes.

So whenever any user type the name google.com in the browser, it automatically lookup the associated IP and display the required content from that server. This entire lookup system is moreover known as a Domain Name System aka DNS.

How DNS works?

DNS works like a telephone directory, where it stores all the associated IP with the human readable domain name. So whenever you have entered any domain name or my personal website in the browser like somnathsahu.dev it goes to the DNS resolver which is your ISP.

Now this resolver looks for the name server for the IP and this root server directs it to the Top-Level Domain (TLD) server (e.g., for .dev).

The resolver asks the TLD server, which points it to the Authoritative Nameserver for somnathsahu.dev. The Authoritative Nameserver holds the actual IP address and sends it back to the resolver. And the resolver sends the IP address to your browser.

Now your browser uses the IP address to connect to the website's server and display the website content.

Why DNS records are required?

Generally, DNS is not only showing the website content. More over DNS records are used to control of a domain and its authority. DNS contains many records like A, AAAA, CNAME, MX, TXT, NS and each records types has different work to manage the domain, sending emails, creating aliases and many more.

So more over DNS has different types of records for different purposes.

Website server and file management publicly.

Email delivery and communication.

Manages / ownership validation of domain.

Manages the subdomain or aliases.

DNS records has 4 columns i.e. type, name, value , TTL.

type refers to record type like A, MX, TXT etc.

name refers to domain name or subdomain name (mostly it is written as @, blog)

value refers to where that name is pointing too whether it would be any text or any IP.

TTL refers how long a DNS resolver (like your ISP's server) caches that particular DNS record

A Record:

The "A" stands for "address" and this record stores the IPV4 address of the website where the website is hosted. It looks similar like this 123.34.45.2

This A record is only the responsible records which allows to directing the web traffic. If you are using a managed web hosting or even an EC2 or a VPS, these servers are allocated an IP address which is actually directing the web traffic to that destination website.

Here is an example of an A record:

somnathsahu.dev record type: value: TTL

@ A 198.0.2.1 14400

AAAA Record:

AAAA records match a domain name with respect to an IPv6 address. This AAAA records are exactly like DNS A records, except that they store a domain's IPv6 address instead of its IPv4 address.

Here is an example of an AAAA record:

somnathsahu.dev record type: value: TTL

@ AAAA 2891:0db8:87c3:0000:

0000:8a2e:0b70:7334 14400

CNAME Record:

A "canonical name" (CNAME) record points from an alias domain to a "canonical" domain or subdomain. A CNAME record is used in lieu of an A record, when a domain or subdomain is an alias of another domain.

For example, blog.somnathsahu.dev has a CNAME record with a value of "hashnode.network" (without the "blog"). This means when a DNS server hits this blog.somnathsahu.dev domain, it actually triggers another DNS lookup for somnathsahu.dev and their it found CNAME with “blog” named which is referring to a hasnode.network domain. Now it actually triggers another DNS lookup to hashnode.network and returning hashnode.network’s IP address via its A record.

Example of a CNAME record:

somnathshau.dev record type: value: TTL

blog CNAME hashnode.network 32600

MX Record:

MX either way Mail Exchange record directs email to a mail server. The MX record indicates how any email message should be routed in accordance with the Simple Mail Transfer Protocol (SMTP, the standard protocol for all email).

Example of an MX record:

somnathsahu.dev record type: priority: value: TTL

@ MX 10 mailhost1.example.com 45000

@ MX 20 mailhost2.example.com 45000

TXT Record:

TXT record lets a domain manager to enter text into the Domain Name System (DNS). Text is stored in the form of one or more strings within quotation marks. The TXT record was originally intended as a place for human-readable notes. However, now it is also possible to put some machine-readable data into TXT records. One domain can have many TXT records.

Example of a TXT record:

somnathsahu.dev record type: value: TTL

@ TXT "txt:22323njf" 32600

Today, two of the most important uses for DNS TXT records are email spam prevention and domain ownership verification, although TXT records were not designed for these uses originally.

NS Record:

NS stands for ‘nameserver,’ and the nameserver record indicates which DNS server is authoritative for that domain. Basically, this records tell the Internet where to go to find out a domain's IP address. A domain often has multiple NS records which can indicate primary and secondary nameservers for that domain. Without properly configured NS records, users will be unable to load a website or application.

Here is an example of an NS record:

somnathsahu.dev record type: value: TTL

@ NS ns1.exampleserver.com 21600

Wrap up

DNS is a quite important topic which actually keep your website live.

And now we have discussed the five main DNS record types:

A Record – Website address IPV4

AAAA record - similar like A record but contains IPV6 address

CNAME Record – Domain alias or subdomain creation

MX Record – Email routing

NS Record – DNS control

Why version control exists: the pen drive problem

Somnath Sahu — Thu, 08 Jan 2026 06:29:03 GMT

Developing an application is easy, but the difficulties come with maintaining that application. Any application is built on someone’s local machine, and now the challenge is to ship that application to a server or someone else's machine. Generally, shipping a physical product through a courier and shipping an application are not very different; it works the same way, but the medium has changed.

Let's say you have written a complete todo application where you can add and delete your daily todo list and maintain it on your local machine. Now, your friend wants to use that application on his system. So the general and easiest way to share that code is to copy all the files to a pen drive and give it to your friend. Now, your friend is using your todo application on his machine, and wahoo! You will feel so proud that you did a wonderful job.

One fine day, after gaining some coding knowledge, your friend added a simple and important feature where he can modify his created todo item, which is a new feature that was not present earlier. He modifies all his code in the existing coding files that you shared with him.

Meanwhile, you have changed some design layouts of that application to look more appropriate and beautiful on your system.

Now the time come when you want to share that design with your friend and your friend want to share that additional feature with you.

If you took your friend’s code into your machine, your recent design changes will be overwritten and the other side if your friend took your code, his functionality will be overwritten.

Now the problem arise!! This problem occurs when only two person involved but think of a large application where multiple team member are working on same project, multiple people are working on even same project files.

So to solve this problem version control system has introduced, using version control every change (add, delete, modify) to project files in a special repository, creating a history or "time machine" for your code, allowing you to see who changed what and when, compare versions, and easily revert to older, stable states if errors occur, all while enabling seamless collaboration by managing simultaneous edits from multiple people through concepts like branching and merging. It prevents lost work and conflicting edits by offering a central record and controlled ways to integrate changes, making development safer and more efficient.

Types of Version Control System:

there are two types of version control system:

Local Version Control Systems (Local VCS)

A Local Version Control System operates entirely on your local machine without any connection to a remote repository. All changes and version history are stored in a local database on your computer.

Centralized Version Control Systems

In a Centralized Version Control System, all the files and their version history are stored in a single central server. Developers connect to this server to access or modify files.

Image reference: https://www.geeksforgeeks.org/

Git for beginners: basics and essential commands

Somnath Sahu — Tue, 06 Jan 2026 19:24:07 GMT

Git is an open-sourced distributed version control system (DVCS) to manage the collaborative or personal coding files effectivity. Git installed in the local system and manages from the local with the remote repository. In the server side, modern management system like Github, GitLab manages the coding files and extends to deploy those code in the server destination like CI/CD approaches.

Why git is used

Git's main ideas include its distributed setup, where developers have the entire project history on their local machines, a repository as the main storage, commits as snapshots of the project, and branching and merging for working separately and then combining changes.

How git works

Git workflow, from https://madewithml.com/courses/mlops/git/

To start working on git, you need to install and configure the git in your local system. To understand the git as how it works and the role of this .git folder. Refer this article: Inside Git: How It Works and the Role of the .git Folder

Starting from git init to initialize the local repo → git add . to stages all the local changes → git commit to commit all the local changes with message → git push to store all the local changes to server → git pull to take other’s committed file in to the local system to keep the system at sync.

Git basics and core terminologies

Repository (Repo): A project's storage location, containing all files and their complete revision history.

Commit: A snapshot of your files at a specific point in time. Each commit has a unique ID (SHA) and a description of changes.

Branch: A parallel version of the repository. It allows you to develop features or fix bugs in isolation from the main codebase (usually called main or master or dev).

Staging Area (Index): A "buffer" zone where you prepare changes before they are officially committed to the history.

HEAD: A pointer to the current branch or specific commit you are currently working on.

Remote: A version of your repository hosted on a server (e.g., GitHub, GitLab) that allows for collaboration.

Merge: The process of combining changes from one branch into another.

Clone: Creating a local copy of a remote repository on your computer.

Fork: A personal copy of someone else's project on a remote server, used for contributing to open-source projects.

Basic git workflow

To manage changes effectively, Git follows a specific workflow involving three main trees: the Working Directory, the Staging Area, and the Repository.

Initialize/Clone: Start a new repo with git init or copy an existing one with git clone [URL].

Modify: Make changes to files in your Working Directory.

Stage: Use git add [file] to move changes to the Staging Area.

Commit: Use git commit -m "message" to permanently save staged changes to the Repository history.

Push/Pull: Share your work by sending commits to a remote repo using git push, or update your local repo with others' changes using git pull

Common git commands

git config --global user.name “[firstname lastname]” : set a name that is identifiable for credit when review version history

git config --global user.email “[valid-email]” : set an email address that will be associated with each history marker

git init : initialize an existing directory as a Git repository

git clone [url] : retrieve an entire repository from a hosted location via URL

git remote add [alias] [url] : add a git URL as an alias

git fetch [alias] : fetch down all the branches from that Git remote

git merge [alias]/[branch] : merge a remote branch into your current branch to bring it up to date

git push [alias] [branch] : Transmit local branch commits to the remote repository branch

git pull : fetch and merge any commits from the tracking remote branch

git status : show modified files in working directory, staged for your next commit

git add [file] : add a file as it looks now to your next commit (stage)

git reset [file] : unstage a file while retaining the changes in working directory

git diff : difference between file about what is changed but not staged

git diff --staged : difference of what is staged but not yet committed

git commit -m “[message]” : commit your staged content as a new commit snapshot

git branch : list all the branches. a * will appear next to the currently active branch

git branch [branch-name] : create a new branch at the current commit

git checkout : switch to another branch and check it out into current working directory

git merge [branch] : merge the specified branch’s history into the current one

git log : show all commits in the current branch’s history

git stash : Save modified and staged changes

git stash list : list stack-order of stashed file changes

git stash pop : write working from top of stash stack

git stash drop : discard the changes from top of stash stack

git rebase [branch] : apply any commits of current branch ahead of specified one

git reset --hard [commit] : clear staging area, rewrite working tree from specified commit

git log branchB..branchA : show the commits on branchA that are not on branchB

git log --follow [file] : show the commits that changed file, even across renames

git diff branchB...branchA : show the diff of what is in branchA that is not in branchB

git show [SHA] : show any object in Git in human-readable format

git rm [file] : delete the file from project and stage the removal for commit

git mv [existing-path] [new-path] : change an existing file path and stage the move

git am : applies the specified patch to the current branch.

git am --abort : cancel the entire operation and revert your branch to its original state before you started the am command.

Inside git: how it works and the role of the .git folder

Somnath Sahu — Tue, 06 Jan 2026 06:12:19 GMT

Git is a distributed version control system which helps a developer to track and manages personal or collaborative code files over the time. GIT is an open-source system created by Linus Torvalds in 2005.

To start working on git, you need to install and configure the git in your local system. To understand the git as how it works and the role of this .git folder. Let’s dive into this.

What is .git folder:

.git folder is automatically created during your first initializing the project or folder by running git init command in your terminal. Git stores everything including files, directories, and history. It stores as immutable objects identified by a 40-character SHA-1 hash. These are stored in .git/objects.

Key components of .git folder

The contents of the .git folder might seem confusing at first, but every file and subdirectory has a specific purpose.

1. HEAD

The HEAD file points to the current branch reference.

For example: ref: refs/heads/main

It tracks which branch you're currently on.

2. config

This config contains repository-specific configuration settings (like remotes, user info, aliases), separate from global git config.

Example:

[core] repositoryformatversion = 0 filemode = false bare = false logallrefupdates = true symlinks = false ignorecase = true [remote "origin"] url = git@github.com:user/repo.git fetch = +refs/heads/*:refs/remotes/origin/*

3. description

This description is text file which used mostly by graphical interfaces or Github desktop or git lenses to describe the repository. Usually ignored in bare repositories.

4. hooks/

This hooks folder Contains scripts that git can trigger at key events, such as before a commit (pre-commit) or after a push (post-receive). It has stored custom logic for code quality checks, CI/CD, etc., can be executed here.

5. info/

Inside this info/ folder consists of the exclude file, which can be used to ignore files locally, supplementing .gitignore. It helps prevent pushing any confidential or unnecessary files.

6. objects/

This objects/ folder is known for the heart of Git’s content storage. Here git stores everything—files, directories, commits—as objects using the content-addressed storage model. Here the objects are named based on the SHA-1 (or SHA-256) hash of their content. In this folder every objects have a unique address.

blobs: store file contents

* trees: represent directory structures

* commits: record changes and metadata

* tags: point to specific objects

Structure example: objects/bg/3cg3434567r34...

7. refs/

This refs/ folder contains references, or pointers to commits.

refs/heads/: Referred local branches

refs/tags/: Referred for Tags

refs/remotes/: Referred for Remote branches

8. logs/

Logs folder stores recent updates to references which helps recover the lost commits or even you can see previous HEAD position. The command is used to check the recent updates : git reflog

9. index

index is a binary file which keeps track of changes staged for the next commit. In this file every content has been tracked.

10. Packed files

Git may also optimize storage using packfiles (visible as pack subfolder within objects/). It combines many objects into compressed files to save space and improve performance.

Final words

The .git folder is much more than a hidden subdirectory—it’s a central nervous system of your project repository. By understanding what’s inside and how Git builds its history through objects, trees, commits, and references.

Disclaimer: image sourced from https://www.geeksforgeeks.org/

Python Is Eating the DATA & AI World!

Somnath Sahu — Wed, 16 Apr 2025 08:43:35 GMT

🧠💡 Why Python? Because Even AI Likes Simplicity!

Let’s face it. Python isn’t just a snake 🐍 anymore — it’s the new king of the Data & AI jungle! From machine learning to data analysis, Python is seamlessly integrating into every tech stack like it owns the place.

But why Python? Why not Java, C++, or even, dare I say, Excel macros? 😅

📊 Most Popular Programming Languages in 2025

(Based on GitHub usage, Stack Overflow trends & developer surveys)

Here’s a snapshot of how the programming languages are stacking up in 2025:

🏆 Top 7 Languages (2025):

Rank Language Popularity (%)

1️⃣ Python 29.5% 🔥

2️⃣ JavaScript 19.7% ⚡

3️⃣ Java 14.3% ☕

4️⃣ C# 9.2% 💻

5️⃣ C/C++ 7.8% 🔧

6️⃣ TypeScript 6.1% 🚀

7️⃣ Go 4.9% 🐹

Python is #1 — leading the charge thanks to Data Science, AI, and Automation dominance. 🧠🚀

⚔️ Python vs. The World: Why Python Wins 🏆

Let’s settle this once and for all

🔹 1. Less Code, More Chill

Python: if hungry: eat()

Java: public class Hunger { public static void main(String[] args) { if(hungry) { eat(); } } }

Javascript: if (hungry) {eat();}

🔹 2. Easier to Learn (Even for Non-Tech Folks)

Python reads like plain English. It’s great for:

Students 👨‍🎓

Scientists 🧪

Developers 🧑‍💻

And anyone who is willing too..

🔹 3. Massive Libraries & Frameworks

From TensorFlow to scikit-learn, Pandas to PyTorch, Python has a package for almost everything:

Machine Learning 🧠

Data Science 📊

Web Scraping 🌐

Automation ⚙️

🔹 4. Huge Community = Faster Help

As Python has large community support. So Stuck? Just Google it. Chances are, someone on Stack Overflow has already solved it — twice. 💬

🔹 5. Cross-Platform & Versatile

Write once, run anywhere. From small Raspberry Pi projects to giant AI systems on the cloud — Python doesn’t discriminate. 🥧☁️

🤯 How Python Powers the DATA & AI World 🔍📊

In the Data & AI realm, Python is like that kid in class who knows everything, finishes assignments early, and still helps everyone else.

Here’s how it shines:

🧬 1. Data Science

With Pandas, NumPy, and Matplotlib, Python makes data analysis a piece of cake 🍰
Just don’t eat the pie chart.

🧠 2. Machine Learning

Frameworks like scikit-learn, PyTorch, and TensorFlow make training models as smooth as butter.

🛰️ 3. AI & Deep Learning

Whether you're building self-driving cars, image recognition tools, or just teaching a bot to flirt on Tinder — Python’s your wingman 💘🤖

🏆 Big Brands That ❤️ Python

Python isn’t just for hobbyists and side hustles. These tech giants are riding the Python train too:

Google – Uses Python for AI & automation 🤖

Netflix – Python recommends your next binge 📺

Instagram – Built using Django, a Python framework 📸

🚀 The Future of Python in DATA & AI

Will Python stay on top?

✅ Easy syntax
✅ Endless libraries
✅ Open-source love ❤️
✅ Works with cloud, edge, and IoT

👨‍💻 TL;DR — Python is the Real MVP

🥇 Easiest to learn

🚀 Rich in libraries

🧠 Built for AI, ML & data

🤝 Supported by a huge global community

🧩 Integrates easily with cloud, IoT, APIs, you name it.

🐍 Ready to ride the Python wave?

Start learning today — because in the world of DATA & AI, Python isn’t just a trend,
…it’s a full-blown revolution. ✊📊

Protocol	Description
DICT	Lets you lookup words using online dictionaries.
FILE	Read or write local files. cURL does not support accessing `file://` URL remotely, but when running on Microsoft Windows using the native UNC approach works. Only absolute paths.
FTP(S)	cURL supports the File Transfer Protocol with a lot of tweaks and levers. With or without using TLS.
GOPHER(S)	Retrieve files.
HTTP(S)	cURL supports HTTP with numerous options and variations. It can speak HTTP version 0.9, 1.0, 1.1, 2, and 3 depending on build options and the correct command line options.
IMAP(S)	Using the mail reading protocol, cURL can download emails for you. With or without using TLS.
LDAP(S)	cURL can do directory lookups for you, with or without TLS.
MQTT	cURL supports MQTT version 3. Downloading over MQTT equals subscribing to a topic while uploading/posting equals publishing on a topic. MQTT over TLS is not supported (yet).
POP3(S)	Downloading from a POP3 server means getting an email. With or without using TLS.
RTMP(S)	The Realtime Messaging Protocol is primarily used to serve streaming media and cURL can download it.
RTSP	cURL supports RTSP 1.0 downloads.
SCP	cURL supports SSH version 2 SCP transfers.
SFTP	cURL supports SFTP (draft 5) done over SSH version 2.
SMB(S)	cURL supports SMB version 1 for upload and download.
SMTP(S)	Uploading contents to an SMTP server means sending an email. With or without TLS.
TELNET	Fetching a telnet URL starts an interactive session where it sends what it reads on stdin and outputs what the server sends it.
TFTP	cURL can do TFTP downloads and uploads.
WS(S)	WebSocket done over HTTP/1. WSS implies that it works over HTTPS.

somnathsahu.dev	record type:	value:	TTL
@	A	198.0.2.1	14400

somnathshau.dev	record type:	value:	TTL
blog	CNAME	hashnode.network	32600

somnathsahu.dev	record type:	priority:	value:	TTL
@	MX	10	mailhost1.example.com	45000
@	MX	20	mailhost2.example.com	45000

Rank	Language	Popularity (%)
1️⃣	Python	29.5% 🔥
2️⃣	JavaScript	19.7% ⚡
3️⃣	Java	14.3% ☕
4️⃣	C#	9.2% 💻
5️⃣	C/C++	7.8% 🔧
6️⃣	TypeScript	6.1% 🚀
7️⃣	Go	4.9% 🐹

Somnath Sahu

Emmet for HTML: A beginner’s guide to writing faster markup

What is Emmet, Really?

The Basics: Creating Elements

Adding Classes and IDs

Adding a Class

Adding an ID

Nested Elements: Building Structures

Multiplication: Creating Lists Fast

Attributes and Text

The Ultimate Shortcut: The Boilerplate

Why Every Beginner Should Use It

How to Practice

CSS Selectors 101: targeting elements with precision

The Real-World Analogy

1. The Element Selector

2. The Class Selector

3. The ID Selector

4. Grouping Selectors

5. Descendant selectors

Understanding HTML tags and elements

What exactly is an HTML tag?

The Anatomy of a Tag

Tag vs. Element: what’s the difference?

Self-Closing (Void) elements

Block vs. Inline : how elements behave

1. Block-Level Elements

, , , and . Analogy: Think of these like bricks in a wall. Each brick sits on its own level or takes up a specific chunk of vertical space.

2. Inline Elements

"Must-Know" tags

to ): These define the hierarchy of your page. is your main title, while might be a sub-header.

): These define the hierarchy of your page. is your main title, while might be a sub-header.

is your main title, while might be a sub-header.

might be a sub-header.

Inspect element : dev tools

Summary

TCP working: 3-way handshake & reliable communication

The Problems TCP Solves

The Secret Sauce: The 3-Way Handshake

Step 1: SYN (Synchronize)

Step 2: SYN-ACK (Synchronize-Acknowledge)

Step 3: ACK (Acknowledge)

How Data Actually Moves

Reliability, Order, and Correctness

Saying Goodbye: Closing the Connection

Summary

How a browser works: a beginner-friendly guide to browser internals

What is a Browser

The Main Components

Step 1: Networking (The Fetch)

Step 2: Parsing

Building the DOM Tree

or tags are the children.

Step 3: Handling the Style (CSSOM)

Step 4: The Render Tree (The Blueprint)

Step 5: Layout and Painting (The Finale)

Summary: From URL to Pixels

TCP vs UDP: when to use what, and how TCP relates to HTTP

TCP: the reliable courier

UDP: the live broadcaster

Key Differences at a Glance

When to Use What?

Choose TCP when accuracy is non-negotiable

Choose UDP when speed is the priority

Where Does HTTP Fit In?

The Relationship: HTTP Runs on TCP

Why HTTP Doesn't Replace TCP

Summary

DNS resolution : how it works as a resolver and serve the web page

How DNS works?

DIG Command and DNS resolution

Some important DIG command

MX record

NS record

SOA record

Tracing the DNS path

Final words

cURL - Introduction and how to getting started

How to start with cURL

How cURL works:

,
,
, and
.

Analogy: Think of these like bricks in a wall. Each brick sits on its own level or takes up a specific chunk of vertical space.

to
): These define the hierarchy of your page.
is your main title, while
might be a sub-header.

): These define the hierarchy of your page.
is your main title, while
might be a sub-header.

is your main title, while
might be a sub-header.

or
tags are the children.

`DIG` Command and DNS resolution

Some important `DIG` command

What is `.git` folder:

Key components of `.git` folder