DEV Community: Rahul kumar parida

Understanding HTML , Tags, Elements(Basics)

Rahul kumar parida — Sun, 01 Feb 2026 16:34:41 +0000

Let us start by understanding what is HTML and why it is used.

So, HTML stands for a Hyper Text Markup Language which as the name suggests is a markup language which mean data showned in a structured format keeping the related data together .

It is the backbone of modern web technologies . HTML is the skeleton of the website which decides where and how a data will be shown.

HTML uses CSS as skin to fill the webpage with color and animations and what not and JS is the brain which decides when to show data when to not and what to do on diffrent events.

Intresting Fact : Did you know that HTML uses C under the hood while rendering or getting parsed beacuse browser are made from C lang. to be fastest and efficient.

Now that we know what HTML is let’s understand what HTML tags are and how they are used

As we now that HTML is a markup language so it uses some tags which help it to embed texts , images and videos in a diffrent formats. All of them have a common syntax

<Opening> <TagName>  <Closing>
    <       content     >

 HTML Element:
< Content> </ Content >

‘<’ and ‘>’ are Opening and Closing Brackets ‘/’ is used only in the closing bracket and show that the work of the tag ends here.

‘Content’ contains the TagName being used and according to the Tag the content should be added inside or to that Tag.

When we add both the Opening and Closing Tag together this Creates a HTML element.

For Example for heading there are tags from h1-h6 which vary in sizes as we go higher:

Now along with these Opening and Closing Tag there are also some Self Closing Void Elements which does not have any Closing Tags but work the same as HTML elements.

An example of is


 <img  src=”” />

This is an Example of self closing void element and there are many more like input , label , video Tags etc.

Now they are some other fancy term to call this elements Block- level elements and Inline-level elements , they differ slightly.

Block-level elements:

This elements are those element that starts from a new line takes up some space and margin like they take up a part of the page completely for themself as much as they require for their content.

<div style="border: 1px solid black;"> 

</ div>

Inline-level elements:

This elements are those elements that only take space as they need without disturbing other elements on the same line , without taking the entire page space or line space only takes what is required.

 <span style="border: 1px solid black;">
        World <b>This is HTML</b>
    </span

Some of the Commonly used HTML tags:

<div> </div> -- This is a container tag acts as a container is of block level 
<span> </span> -- This is also a Container tag but is of inline level
<p> </p> -- This is paragraph tag used to write paragraphs.
<h1...6> </ h1...6> -- This is a Heading tag used to write headings
<img src="" /> -- This is a Image tag used to embed image in your web page in the src you provide the link of the image.
<video src="" /> -- This is a video tag used to embed image in your web page in the src you provide the link of the video.
<section> </section> -- This is used to divide and create sections for a webpage.
<button> </button> -- This creates a button which acts as a button
<table> </table> -- This is used to create tables.

This blog about the basic understanding of HTML , it’s Tags and Elements.

Thank you for reading and would love have your feedback!!

Emmet for HTML

Rahul kumar parida — Fri, 30 Jan 2026 16:36:14 +0000

What do you think when you here HTML . Ohh!! those long lines of tags each having there own personal attribute and writing them manually is like doing something that is not as prodocutive as it looks , No offence to HTML coders.

If you used VS code from the start you won’t understand the pain of writing HTML on notepad manually feels like the head is gonna burst. But my friends thanks to Sergey Chikuyonok who developed Emmet a HTML shortcut provider before Emmet existed people used to manually write the complete HTML and CSS **** by themselves which was tiring and boring so Sergey thought of making this to help a lot of developer all over the world in 2012 .

Emmet is a plugin which helps us to write code much efficiently and easily than ever before.

So how it works?

It uses the logic of abberviation syntax in simple words tagName{and some command then}. This improves the learning of HTML beginner much faster and easy to understand without writing the entire block by themselves.

So how does is work?

In VScode you might have noticed that whenever you type something in HTML there are some utilities you find out like creating a class and div using a single line , ever wondered how does that happen and how we can do that . Well that is the magic of emmet.

Let start by giving some basic commands to start:

1. When you type ‘!’ in HTML file in VScode and click enter:

You see the arrow mark when you click ! command the top written Emmet Abbreviation if you click enter it automatically writes all that for you. This is the complete HTML boilerplate used while creating a page and is common so we ‘!’ this to get the boiler plate.

2. Let say you want to create div with a classname and id :



    div.someclassname#someID

3. If you want to create a nested fields:


        div>span*5.span

4. Similarily adding custom attribute using ‘[]’ :


    div[idea="0000"]

5. You can also create nested + siblings elements using + and >:


    div>span>a^h1+h2
    div>(span>a)+h1+h2

‘>’ means it is nested or children element and ‘+’ means they are sibling elements. ‘^’ means to to upper parent and be there sibling

if you use (tag>tag) you are creating a sibling with thier own custom properties inside them.

These are some examples there are more but these are the fundamentals of the one you willbe requiring as a starter and will enjoy more as you go deeeper.

That’s it that’s the work of an emmet it is a plugin helps you to write HTML faster and efficiently.

Thank you for reading this!! Would love to have your feedback on this!!

TCP working (Communication Between Networks)

Rahul kumar parida — Thu, 29 Jan 2026 16:46:41 +0000

TCP (Transfer control protocol) is itself is a lot to understand in theory, Let’s start slowly by understanding where it came from .

TCP is a reliable control protocol residing or works in transport layer of the TCP/IP network model. its primary work is to transmit data over the network to a reciever’s end.

So how does it do that. Let’s walkthrough the process step by step :

1. Adding the layer : Transport layer adds a layer over the data which includes some required data such as IP header , Ordering , Control Flags , Checksum(Error Control mechanism)

a. IP header : Containing the source and the destination address along with some metadata.
b. Ordering : TCP send the data in order so it provide a serial number to each of the data packets such that receiver can order them as expected.
c. Control Flags : These are the flags containing the signaling what it the could be the next block of packet might contain. These are of few types:
i. SYN: Syncronizes with the receiver end initializes the data transfer.
ii. ACK: Acknowledgement which are sent until the connection is going on and required.
iii. FIN: Finish is the final signal first sent by the sender to receiver and then from receiver to sender to close the connection.
iv. RESET: Resets the connection for sending the data from the sender to reciever again in case the data is corruppted or failed to reach .
d. Checksum : This is sent to verify that the required data is reached or not and if there is any data loss during transmission.

2. Connection is established : The connection is established from the sender to reciever through a process of 3-way handshake. The sender sends signals SYN to initiate the connection , the reciever reads and replies with a SYN and ACK and then sender sends a ACK to fully establish the connection between them.

3. Data Packet Transfer : Once the connection is established the data packets are sent one by one from the sender to the reciever from a single consistent network. The sender sends data once the data is reached it is checked using checksum if the data length matches then the reciever send a ACK to the sender and sender sends another chunk of data if error is found in the data packet the reciever does not send the ACK and after a interval the sender understands that the data was not recieved properly and that is why no ACK so sender retransmits the same packet again .

4. Closing connection: Once all the data is transffered and the data is recieved successfully the sender send the final block and FIN which is acknowledged by the reciever and then a ACK and a FIN is sent to the sender , the sender again sends the FIN to reciever and finally ends the connection this is a 4-way handshake. Data transffered successfully.

This is the complete process of how TCP works , it establishes a secure connection does the data transfer and closes the connection this is a large process but it happens so fast that you feel like nothing happend.

Advantages of TCP:

TCP is reliable all the data is sent without any error or any loss
Network Congestion Control: Which is the best part if the network is crowded and slow , then TCP packets sending time interval increases so that no data loss is done and if the the network has less traffic or less crowded then the time interval decreases and the packets are sent faster.
Error handling statergy: TCP uses checksum which is used to calculate if the length data packet sent matches the data packet recieved and if the length matches upon calculating on the reciever’s side then the data is most likely intact

TCP is designed to solve reliability over an open connection of large network such as the Internet so that the data could be transmitted securely without any data loss and in correct order compromising a slice of time which is accepted because the time is almost negligible 99% of the time.

This is my understanding of how TCP works and what it is!! Thank you for reading till the end . Would love to get any feedback possible!!

TCP vs UDP

Rahul kumar parida — Wed, 28 Jan 2026 16:32:15 +0000

Have you ever wondered how you can chat with a person so far or voice or video call them so easily , Well let’s talk about network layers and how each of them help.

There are basically two models of network transmission stack :

TCP/IP model
OSI model

Both have a great theory but only TCP/IP is the only one that comes in handy in today’s internet.

The TCP/IP model is basically consist of 4 network stack:

Data Link Layer : The Data is converted to Binary or they opposite in this layer .
Network Layer : The stream of bits of data are gathered here and the shortest and most efficient route is found for the data packets to be transffered to the destination address.
Transport Layer : This is where TCP or UDP is chosen based on the data being transferred through the network.This handles error detection and ordering when a the data packets are sent or recieved.
Application Layer : Handles transferring data end to end.

Each of the layer has there work but lets understand about Transport Layer a bit more:

Transport layer is used to send data packets across the network along with the loads of data sent by other users around you.

So What Special does the Transport Layer does? It basically adds a layer to the data packets containing the IP headers , Ordering , Checksum

IP headers : Headers contain the Source address , Destination address , MAC address of the network passed from and other metadata.
Ordering : This layer assigns a special unique number to each of the data packets in a serial manner so that if a data packet reaches late they can be correctly ordered by the application layer.
checksum : It is a method which to used to handle error and is used in error detection.

All these are handled by Transport layer but vary depending on what you are using TCP or UDP

TCP (Transmission Control Protocol):

TCP is a very reliable communication and is always safe to send data through this protocol. TCP uses almost all of the transport layer utilities along with the it’s own advantages(discussed later).

UDP (User Datagram Protocol):

UDP are very fast but uses some of the utilities in available in Transport layer.

TCP-Process:

TCP establishes the connection to the other end user using a 3-way handshake.

Once the connection is established and the network is set TCP starts sending data packets using that connection and everytime the reciever recieves a data packet it sends an acknowlodgement (ACK) to the sender once the ACK is recieved the sender sends another packet and the process goes on if in anytime the the reciever does not send a ACK then after a interval the sender sends the previous data packet again and the process goes on once this finishes the sender sends a finish(FIN) request to the reciever and the reciever sends a FIN then ACK to the sender and then sender send the FIN again to close down the connection.

This process is little slow but is reliable and no data loss is found , error handling is done using checksum to check if any data is lossed while transmission.

TCP also handles network congestion which is if the network is crowded or slow then it increases the time to send the data packets while if the network is fast it decreases the time of transmission of each packet and this is how it adjust according to the network speed.

TCP is widely used e.g. When you browse something on a HTTP server or in FTP ,TCP is used.

Basically it is used in every aspect unless it is not about real-time streaming of data. So you must be asking me if TCP is protocol so are HTTP and FTP why are they not doing something like this . The answer is simple HTTP and FTP and many other protocols are of application layer protocols they only help keep the data authentic and only to the end user(reciever).

UDP-process:

UDP doesn’t establish any connection to the reciever end it is connectionless. It start sending data packets(datagram) to the reciever address without any reliable connection , so , there is no single network used it send the data through multiple networks never thinking about ordering , it oonly think of how i can make the packets reach faster to the receiver rather than the quality.

A real life example would be video calling you must have notices that the quality of video calling is not as good even with fast internet connection it might loose some bits of data which may create a laggy interface to you.

UDP is generally used in fast data transferring like DNS search , DHCP , Live streaming etc.

UDP is faster in general compared to TCP but if you compare it yourself you wont see much difference unless a very large stream of data is being transffered.

Best Meme to understand TCP and UDP is :

This meme shows exactly what each of they mean , TCP is very gentle while UDP is careless.

This is my understanding of TCP and UDP . Would love to have your feedbacks.

Getting started with cURL (as a beginner!!)

Rahul kumar parida — Tue, 27 Jan 2026 16:33:44 +0000

Before exploring cURL let’s understand what is cURL

so what is curl?

curl in the simplest of word is a postman for terminal you can send ,request ,delete data from an api(application programming interface) using the required credentials and data from the terminal only , curl is used widely among developers or programmers who love terminal . it is used to request something to or from a server . curl helps a lot when you need to automate api calls and it supports almost every protocol available from HTTP , HTTPS to SMTP , FTP etc.

You can perform all the request methods like GET , POST , PUT , DELETE etc for HTTP/S

For all the requests i will be making i will be using Jsonplaceholder which help in fake api testing

Let’s see how it works on the basic commands

GET-method:

When you type the first and since no method is mentioned it by default uses GET request for whatever the api is. You can also write the second one mentioning the method:

 curl https://jsonplaceholder.typicode.com/posts/
 curl --request GET https://jsonplaceholder.typicode.com/posts/

POST-method

Post method is used to post data to an API

curl --request POST https://jsonplaceholder.typicode.com/post -d '{data in json format}'

DELETE-method

Delete method is used to delete data to an API of the particular endpoint.

curl --request DELETE https://jsonplaceholder.typicode.com/post/100/

and this is how you communicate with the API there are a lot of diffrent methods and protocols these are some basics.

Request-Response Cycle is as the name suggests when a user request something the server serves them that as a response. if you order pasta then pasta will be delivered this is request response cycle

if your order is late you get status like time limit exceeded or if the shop(server) is closed you see Not found that is it everything that can happen to a pasta from you ordering to being delivered to you or not is the request response cycle.

Things To avoid doing as a begginer:

Don’t use unneccessary commands like —request GET or -x POST if you are using -d command to post some data
Make sure you are writing the correct commands and shortcuts an alphabet here and there can get you diffrent result than expected.
As i said curl is like postman not postman so you need to carefully check the command line before executing it.

This is my understanding of curl , Would love to have more knowledge on this.

DNS Record Explained

Rahul kumar parida — Mon, 26 Jan 2026 16:02:34 +0000

So What are DNS Record exactly , What are the types , what are each of their use cases Let’s understand step by step

DNS records are instruction that live on the authoritative server which is accessed to find diffrent ways in which a server requests are handled records could be the IP address to the server or to a load balancer leading to that IP address or anything which helps you connect to the server

There are various types of records but some of the important records among them are :

A record: This holds the IP address of the server in IPv4 format . 32-bit long string

AAAA record: This holds the IP address of the server in IPv6 format . 128-bit long string

CNAME record: Forward one domain to another domain e.g. www.example.com —> example.com

does not points to any IP

MX record: This are mail records and can be created for literally any domain that you bought, Format is simple: @ here @ represents that this is a MX record

NS record: This record holds the direction to the authoritative server which keeps the rest rest of the records.

Let’s understand them one by one

A record and AAAA record:

This record hold the actual IP address of the requested domain name and this is where the server lives this records are what actually stored in the Name server or Authoritative server. The only diffrence is that A record contains IPv4 address 32-bit long so limited avaliability and AAAA-record contains 128-bit long address which are of IPv6 address and are highly avaliable with wider range.

CNAME record(Cannonical Name):

This record stores another domains or subdomain names not IP address like if you want to have a separate service to run under the same domain name you can create a subdomain and point it to the domain name but with diffrent services e.g. blog.example.com —> example.com but since the domain has a subdomain it is redirected to the blog services of example.com

MX Record:

This record is mail service for a domain , it can be created with any domain name the server has access to it . if a MX record is created any one can mail; using that mail@domainname.TLD

e.g. rahul@example.com can work as a mail if the MX is created on this name

All the server has to to is create a MX record for this username and the @ here represents that the domain is used as a MX record.

NS record:

This is Name Server record and as the name suggests it keeps the name and IP address of the server it is the authoritative server which holds records of a server information , They generally have 2 records Primary and secondary . Secondary is used when primary goes down is slow.

And these are some of the important records that you need to know

This is my understanding of the records happy to get feedbacks

If you like this hope you will like this : DNS Resolution(Why name instead of IPs?)

DNS Resolution(Why name instead of IPs?)

Rahul kumar parida — Sun, 25 Jan 2026 16:55:07 +0000

DNS-Domain Name Service this is one of the most interesting topic when it comes to networking and connection have you ever wondered how so domain have names while hardware can understand only numbers how is that you click example.com and voila the website appears right in front of you , Why names are used instead of IP ??

Well the answer is simple it’s because it is Humanly readable and can be easily remembered that’s it!! You cannot remember 127.0.03.10 a number like this can you that too this is just of a single server.

So before jumping to how the DNS resolution works lets first understand what it conatains.

if you would have noticed when you search example.com you type two word what are these and there any hidden domains added to it

for example.com it might be example.com.

The DNS server reads backward like this:

Let’s try to unserstand by example what happens here .Suppose you want to visit a website say example.com (personal favourite) when you click enter the request goes to the DNS servers(this are static and doesn’t not change unless required) these servers recieve your request and checks if they have that IP of that domain listed in their directory(maintains a frequently visited website list) a.k.a DNS resolver cache(temporarily store the IP until the ttl has ended) and if it is avaliable then it sends it back to the browser else a process starts the request is then sent to a Recursive DNS server or the root server what this does is recursively tries to find the Top level Domain(TLD) of the requested server (.com,.org,.in,.dev..etc are some common top level domains) now for this example it is .com so the Recursive DNS server sends the request to that TLD , Now the TLD checks the request and send it to a Authoritative DNS Server which has the IP of the requested server example.com the IP is then sent directly to your browser through your IP address present in the Headers of the request. Then your Browser request it to the given IP and you website appears.

This might feels like a long process but it all depends on the networking speed of your device and your network . So , the next time you try to browse a website remember this is the process your request has to go through. All though it’s speed is negligible sometimes it can lag up.

You can also check that out using a dig command. Which is avaliable in Linux or WSL(Windows Subsystem for Linux) if you are on windows.

To check follow these steps:

sudo apt install bind9-dnsutils
dig google.com

As you can see the highlighted section is the IP address of example.com (changes overtime)

and just below that is SERVER which is the DNS server which was used to query and find the IP address and ass you can see the query time is 44 msec(average for their time but) is almost negligible to a normal human.

There are also other commands like

dig example.com NS : Shows all the Name servers it has (these servers contains which authoratative server holds the domain’s IP)

dig example.com ANY : Shows Every Record of IP address for the server example.com

dig example.com +short : shows the IP in a single line

and there are many more you can checkout

Summary,

Your request —> DNS recursive server —> Root server or TLD —> Authoratative server (has the IP) —> you browser —> requested server

This is my understanding of the DNS server and how it works.

Networking devices ,Firewalls ,Load Balancers (Connected?)

Rahul kumar parida — Sat, 24 Jan 2026 16:34:52 +0000

So hoping you read this blog Networking Devices we will continue with the rest . If not recommended for the context else read this you will get the idea of how it works.

So as we know how the devices connect with each other on the devices level which is the physical level let’s understand what are the steps taken to keep this networks up and running Ready-to-use.

Ok we know that routers are used to direct the data packets from your computer to your friends over the internet which is a open connection everyone having a internet connection device can access it , Which means that the signals you are sending is open to everyone which means your data can be interpreted and altered this is a type of network attack which can occur if a third device except your friend’s device knows your IP address the packets can be interpreted and altered so how it is prevented, for that there exists a firewall for each of the network devices including your and your friend’s and the routers which checks on with hop(router transferring data packets from one network or switch to another to reach the destination) these firewalls check and verify each of the data packets HEADERS they don’t check the data only headers and check the source and destination IP of the packet and for each it checks the hop where the data came from and is it a valid network to pass through if not it blocks that specific network from accessing other packets so whenever other data packets transfer they don’t travel through that route also when some data packets are send to your computer they pass through the firewall to check the integrity which is if the data is safe to load on the device , These firewalls in the latest(2026) are weak alone so we use hooks like TLS and SSL(nowadays) which secures the data transfers maintaining the integrity and confidentiality to specific user having the access and that’s how firewall come in hand for network securing you data and your computer from getting any malware .

But how do they handle this much network and how does it happens that it doesn't lag the network how is it so fast even with so many routes to pass through how can you read this blog upon clicking the link or probably the post on this website that’s where load balancers come in these balancers divide and pass multiple requests into diffrent routers which then directs them to there networks. for example: let say you are browsing multiple websites at once like 100 tabs (not possible but just for an example) and you are sending like 30-50 requests from your network to other servers or devices these is where network load balancers come in they receive your requests divide the requests and direct it to different routers each of them vary one can be slow one can be fast and one can fail (these states a request can go into) these network load balancers work is to divide the network request into different routers or switches which decreases the load from a single router or switch significantly so that it can handle load of networks and work efficiently

And that’s how Firewalls and Load balancers come in hand with the network so that you can enjoy your online services , there’s a lot more to know about this network but this is my understanding of how networking works.

Some Fundamental Networking Devices

Rahul kumar parida — Wed, 21 Jan 2026 16:39:51 +0000

Networking devices have you ever wondered how our devices communicate with each other or with the internet which you are using to read this blog traditionally there were a lot of large devices were added together to communicate with diffrent devices

Let’s take you through an example before understanding what they are , Suppose you and a friends wants to communicate to each other over the internet you connect to each other, so when you send a message to your friend what happens is the message is first converted to binary(0s and 1s)on your device and then sent to the modem which converts these digital signals to analog signals and sends over to the ISP(Internet service provider) then ISP uses routers to route those signals to the destination device , and vice versa the communication moves left to right.

Let’s understand modem and router in details:

Modem

Works as the medium between you and the internet
Modem work is to convert digital to analog signals and vice versa
Modem sends request to the nearest ISP.

Routers

Routers are as the name suggests are used for direction of those signals sent by the modem.
Routers maintain a routing table record which they can later refer when they check the headers of the data packets and refer to the routing table to find the address they have to send the data packets to.
Routers route millions of data packets to their destination in a second
Routing tables are divided into two types: a. Static routing table in this the network admin engraves routes manually and is manually updated only the path of the routes are fixed doesn’t matter if they are fast are slow. b. Dynamic routing is more efficient than static because it uses routing protocols to determine the fastest and the slowest path to reach a destination network and updates it's route dynamically when it finds a faster route.
There are various protocols to find there way to the destination first a. IP(Internet Protocol) the router checks IP headers of the data packets to find out where they came from and where they have to go and redirects them as required. b. BGP(Broader gateway protocol) is a dynamic routing table which tells who controls which IP in other words have the complete knowledge of which ip address directs to which network destination to determine and use it dynamically , we use 2methods i. OSPF (open shortest path first ): This one dynamically determines the fastest and the slowest path to reach the network ii. RIP (routing information protocols): This one uses hop count which is checks how many routers it has to jump or go through to reach the destination and finds the shortest path to the destination.

And this is how you communicate with your friend

Ok now what about how you communicate with a server let say google.com how do you browser know and how do they get the address of the required domain , Now am not going to explain DNS on this blog but I’ll make sure to make one for that

So let say you now know how you communicated with your friend on a LAN(local area network) what about how you connect to different servers that are built far far away how do you connect with them

Traditionally we used Hub’s which is now replaced by Switches which are much more faster and less energy taking than Hubs , let’s understand the difference

Then vs Now,

Hubs they were very popular in early 90s and were broadly used to connect it to people across the globe so how they were used were exactly,

So think of hub as a docking station for all the networks that were avaliable near you so what happend was when you sent a message to your friend who live far from you what happens is the signals from the routers pass it on the signals to the nearest hub and the hub send it to all the devices connected to it only the destination device accepts the message and the rest reject it so this was how message was sent but this also had some capacity because sending a message to someone means you have to go through all and it increases the bandwidth the so what happened was bridge was created what it does is it saves the MAC address(a type of unique address for a device) of destination that is asked and later it could be accessed and sent directly now if we put this process inside a box that is a switch . Switch directs the request to the requested server but also keeps log or you can say maintains a dairy which have the route and addresses saved so switch doesn’t makes request to anybody it directly sends it to the destined device this reduces the bandwidth significantly and it able to communicate to other switches and that’s how the network all over is connected using multiple switches and routers.

and that’s my friend is how the Internet works and how you can communicate with a friend far far from you.

I might not have covered all the devices but this are the basic requirements or used-to-be requirements for establishing a connection over a network

Inside Git ? How it works and what is inside .git?

Rahul kumar parida — Tue, 20 Jan 2026 15:38:20 +0000

if you reading this means I will assume you know what exactly git is for!! , We will not talk about how push or commit here we will talk about what happens when you commit or push the code.

All of this starts from the command git init which initializes the repo gets the .git file ready to use.
Once you have committed the first commit , you will see a .git folder in the working directory , Before knowing what is inside it let's first understand what it is and how it operates. Think of .git as the database storing the entire history of commits along with the data(code) in form of objects it used to retrieve and store data pretty differently than previous Version Control Systems(VCS) which follow traditional method of storing the entire file structure that has been changed unlike other VCSs , Git helps to store data pretty efficiently and effectively and reduces space significantly.

So what happens inside that when you get inside the .git folder you see multiple folders inside it

As you see multiple folders inside the .git folder each have it's own work but for now let's focus on the objects/ folder when you get inside that you will see 3 folders since you have committed the first time and two folders named info/ and pack/.

Ignore this two let's focus on other folders , each of the folders named a numbers like 01/ 02/ 03/ or anything else. Now we comeback to our terminal check that when you run git log.

This will log the commit you did with a random hash value(gibberish mixture of letters and numbers) , and meta data about your commit (who did it and when) as you can see on the image.
Now you may want to notice that the first two digits of the hashvalue is the name of one of the folders inside the .git/objects/ directory if you open that folder you will see the rest of the hashvalue as a file stored there
Ex: complete hashvalue : 4834726f1da14527eb539cf75be80db8f6f286ae
Now look at it this way :48 / 34726f1da14527eb539cf75be80db8f6f286ae

Now what is this file and what is it doing here

ok before that let me give you some information about what exactly is stored in this objects folder as you saw it contains multiple folders if we ignore those other 2(info/ , pack/)
What are these folders?

So what happens is . Git divides your commits into three parts

Commit : contains the metadata about the commit made including all the info of who and when also a hashvalue which redirects to tree folder.
Tree : contains the directory structure at that point of time when committed and may or maynot connects to another trees which contains the blobs of the previous versions with no change in code.
Blob: This actually stores the code snippets (the changes you made the actual data and lines of code) which is connected from the tree to get those version of data These are the 3 pillars of .git which help it work as database for your commits.

Now, the 48 is the commit folder that we know what is the hash value given if you check inside using the git cat-file hashid you will see it will show the metadata and another hashvalue with title tree this hashvalue points to the tree folder and the hashvalue named file similar to what we gave example for commit (48 / awdada ) , if you peak into it you will see that it is pointing to some other directories it can either be a blog or another tree containing different blogs it is like tree hierarchy structure each commit put on top of other connecting each other when required or creating blobs if necessary

Now let's think it redirects to a blob let's explore that
blob is also found in similar method filename/hashvalue
If you peak into it each blob contains some gibberish stuff which actually are the changes made each time in each file this is where the code snippets live and are hashed using SHA-1 algo.
And that is how the git commit —>store works

What happens when we retrieve a previous version or commit , when we do git checkout #hashid of the commit what git does is the thing first it retrieves the commit file from the objects folder then retrieves the tree structure with the hashvalue present at that file and once git fetches all the tree files and blobs it reflects it to the working directory of the user pretty simple right ;|

This is what my understanding .git folder is its amazing how it is storing data and the way of retrieving it

if you like this you might like to read this too What is git?

What is git?

Rahul kumar parida — Mon, 19 Jan 2026 17:10:24 +0000

For many it is just a storing and retrieving an old project or file but to many it is a life saver
Git as you may know even as a beginner is a version control system now what does that mean "VERSION CONTROL SYSTEM" sounds like a heavy phrase isn’t it but isn't.
It simply means keeping track and record of your previous versions or stages of project in such a way that they could be later be retrieved and seen or reverted back to.
Let's understand that by an example,
You create a project a todo app with your friend and you do that with the help of a pendrive , you did basic CRUD and kept it as is ,Now let suppose you decide you are going to add dates and calender system features to the project , so you decided to divide the feature among yourselves,
so adding calendar system is your task and your friend will do the dates part to it.Now , after your finished the date feature he hands over the pendrive to you it's your turn now so let's say calendar part was a bit difficult you add this and that and suddenly the code is all messed up and it is not working anymore you have no way of getting back to the previous stage and you dont have a copy of the project so that you can use that as a backup. so you both decide to create a copy of the project everytime you share the pendrive ok now that is resolved but another problem occurs you added so many features together to the todo that it is causing multiple problems.

You have too many folders to track having multiple redundant files
Your pendrive space is almost full because of the too much redundant code files

So you decide to delete the oldest folders keeping track of the previous 1-2 versions of the project

Soon after sometime you realize that after you added some features and removed the oldest features folders. Now, the Todo needed some of its basic functionality added by someone of you and you have no records about the oldest versions of the project to retrieve the code and use, So that creates another problem .

This is where git comes in as a saviour now let's say all those things happened but now everytime you make some changes you stages or pushed(later on this) a tested code to git you have that version saved inside the .git folder in a amazing format so even if you mess up the code you can backtrack to the previous version and keep it running so your users don't forget about there todos.

You might be asking isn’t it the same thing as our pendrive , Soon the storage might get full . Yeah valid question but git have something up it’s sleeves it compresses the changes done each time not the FULL block of codes but only those changed or added to git at that point of time so when you figured that you needed the old feature you could go back and retrieve that version whenever required. git gets those code snapshots of the changes done at that point and the directory from that version and show it in your working directory this helps reduce the space significantly than the other version control systems which follow the traditional method of the no. of files changed and create version on those like you used to do with your pendrive , and not only that but they are also stored in compressed version , they have an amazing concept of tracking also.

when you commit the project what it does is inside the .git folder there is a objects/ folder containing 3 folders namely blobs(Binary large object)-(contains the actual changes made on the code ) , tree(directory history)-(how the file structure was at that version) , commit(metadata )-(contains the meta data and the hash-id) what it does is on every commit git creates unique hash-id using the SHA-1 algorithm and assign those to the snapshots saved in the blob and tree which connect it to the rest of the node so whenever you ask for a previous versions using a particular hash-id git first checks the commit folder containing the metadata and hash-id to the tree from there it retrives the folder structure and the blobs hash-id at that point of time and gather all the required blobs for that directory at that point in time , which is then shown in the working directory of the user which is you .
And that's how git core works and to keep this more user friendly and easy to understand github is used.

Simple Devloper Workflow,

Now now you maybe wondering what this init, add, commit, push, track and all this means.
Let's start from

Init command

git init

This command initializes the git and creates .git basically saying that your files are ready to be tracked please stage your files.

Add command

git add <filename>

This command stages your file or files tells git they are ready to be pushed and no longer needed to work
REMEMBER add command doesn't mean your code is saved that might be dangerous
It's just gets you file staged to go and the snapshot of the directory have been taken.

Commit command

git commit -m  "your message here"

This may seem like a no-need command but this is useful later when you have so many versions and want to get to where you added a particular feature or block of code
The message you write should be in short describing what you did on that particular part what you added or optimised or deleted in the commit message make sure it's understandable to others clearly
Helps a lot when you get into big projects.

Final git push

git push origin <branch>

The push command is the command which pushes your code to git and the project is now being tracked by git
This is the final spell you write before git creates the version of the particular stage of the project you are/were in.
Finally push to the git

Now as you push more commits each version will be saved from when you made the CRUD for todo to the advanced features and all. So, how we do we handle such many commits and revert back.

Before we move to backtracking the versions lets first understand what is a branch?

Branch it just means multiple pointers each working in a diffrent part of the code , git by default creates the master branch in which you work but you shouldn't, because you can create multiple branches and push code to those branches and test the code before pushing it to the master branch which contains the safe and tested code working in the production

In a production level project there is no single developer but the project is made using multiple devs pushing the code in and out simultaneously to a single source , you might think that this may cause error and could cause overlapping exactly that is why this branches are made.

Let suppose your todo app has two devs you and your friend so what you will do is create a 3 three branches one for him, one for you and one to test if your code doesn’t conflict with each other when added, these branches help you to divide the projects into chunks for diffrent devs.

For more detailed information visit : Git Branch Docs

Now let's say what if you cooked so hard that the code is now cooked
How do we revert that code
There are very simple commands and steps

You need to check the version you want to jump back to.

git log—> Displays the complete meta information about each of the commit and the hash-id to that version.

git log - - oneline—> displays the short oneliners only displaying the hash-id and the commit message added at that time.
Get the hash-id of the version you want to revisit #01xyz2 once you have the hash-id checkout that branch

git checkout 01xyz2 —> displays the branch/version of the code files in the project but keeps you in a detached state not connected to any branch as soon as you checkout to the previous branch you will get those latest codes

git checkout -b <a-new-branch-name> hash-id —> displays the version of code but also creates a new branch of the given name so that it can be revisited again and the pointer is not in detached state it is connected to the new branch which was created on this command
After you revisit the code there are two options if you just wanted to check that you can do and use the previous code if needed but it you want to completely go back to that version there are three version of options

git reset - - soft hash-id —> You revisit the previous code completely but you have all the after changes you did after that as staged so if you commit at that point all the code from the latest commit will be back to the latest commit

git reset - - mixed hash-id or git reset hash-id—> You revist the branch and at that point if you stage and commit your latest code will be assigned to that commit / branch but with the latest code

git reset - - hard hash-id —> You revisit the old branch but here all the code you have wriitten after that commit will be removed along with any unstaged changes (very harmful).

And that’s how you backtrack to any version of the code safely soundly.

This was a simple overview of what i understood git was and how it is used as beginner and how can we handle the code collaboration such that our Todo repository doesn’t get any bugs or conflict