DEV Community: Ankith Deegoju

Internet - A Basic Overview

Ankith Deegoju — Sun, 12 Jul 2026 12:58:35 +0000

What is a network?

In the context of Internet, network can be a group of devices which are connected with each other.

What do you mean by inter? That is among the devices. The network which is among all the devices can be roughly termed as Internet. Okay, extending this definition, Internet can be called as a network of networks which is providing capability to connect with everyone around the world.

We have another term called Intranet. Internet has two terms, intra and net. Net again here refers to network. Intra means within a group or which is limited to a small area or within people. For example, a network which is within a campus or within an institution or within an office can be termed as an intranet.

These are just fun to have definitions and are not completely correct.

If we deep dive into the technical aspect of Internet, especially for CS grads or engineers, we can think of Internet as a hybrid distributed system. I'll explain you why.

Hybrid in the sense it's not completely centralized/controlled by a central authority, neither is it completely decentralized.

Distributed. Why is it distributed? Because Internet is not operating from a single central server or something like that. It is controlled by many individual organizations which are distributed across the world.

Firstly to understand Internet better, I think we should answer the question, how and why did we build it? Let's go into the background of how Internet was in the first place.

Background-

Internet was a project started by DARPA . DARPA stands for Defense Advanced Research Project Agency started during the Cold War ensuring development in terms of technologies by USA as a consequence of the launch of Sputnik 1 by Russia. [This is not the exact history, a rough idea is assumed for simplicity]

Initially, an organization called ARPA, Advanced Research Project Agency, has developed a network called as ARPANET.

Why was this developed? This was developed to provide/enable communication systems for universities, research organizations, defense forces.

United States Defense Agency has funded the project and it has eventually evolved into Internet. We will understand what were the requirements of the network which they wanted to develop. The requirements were simple.

Decentralization - There should be no single point of control over the communication architecture.

Interoperability - Any device should be capable to operate/connect within the network. There should be no constraint of devices or hardware, something like that.

Survivability - In case of any failure within the network or a small component within the network has been compromised or failed, the network should survive/it should work.

Scalability - The network should be scalable. It should scale to many, many number of devices.

We have developed entire architecture based on the mechanisms that met our requirements.

Architecture

Initially an architecture to implement the Internet was OSI model. We can read about it, but it's a theoretical model which was presented. Now we will deep dive into practical model, TCP/IP model which is used by us right now.

TCP|IP model follows a layered approach in which we have allocated specific functionalities associated with each layer so that we can ensure the functionality of the internet to be more robust.

Each layer is beautifully designed/made up so that it deals only with a particular component of the infrastructure. Each layer is agnostic of the above layer i.e. considers entire above layer data as payload.

Application layer is used to enable communication between applications/software which are built into the devices. Some of the protocols which application layer uses are HTTP, SMTP. HTTP is generally used by web applications, SMTP it’s used for mailing services.

Transport layer is used for process-to-process communication, it's mostly handled by operating system, and there are two main protocols within transport layer which the processes use to communicate, TCP and UDP. TCP stands for Transport Control Protocol, UDP stands for User Datagram Protocol.

The next layer which we have is network layer. It is also known as, IP layer as IP [ Internet Protocol ] protocol is and it deals with the routing of information between two devices within the network. It's the protocol which is used by all the data packets within the network. It is implemented by OS and partially by routers.

IP is not a single protocol, it's a protocol suite. It is sued to provision each device within the network a unique IP address to identify the device in the network.

We use IP addresses to navigate the device in Internet, but data is transferred form one device to another using MAC address of the device.

MAC layer is used to communicate with the very next device/ hop-to-hop delivery [ I will explain this part in later section ] within a network or within a network among switches, bridges to reach. This layer involves used by intermediate hardware devices for forwarding data packets. There are many protocols within MAC layer, such as we have CSMA-CA for wireless transfer of data, other protocols such as FDM, TDM, token passing protocols etc. We need to understand MAC a bit in a different sense. This is useful for communication between hardware devices within a network/intranet. This layer functionality is implemented by NIC [ Network Interface Card ] within the device.

Physical layer, it deals with modulation, demodulation, converting the data into electrical signals or waves. In physical layer, we have wires, fiber optics, etc.

If you observe we have divided our architecture into these layers based on the specific functionality associated with each layer. Each layer is very much different from one another. This gives us modularity / feel of loose-coupling where components and functionality of a layer are neither constrained nor are attached together with other layers. Even if there is an issue with one part of the system, you can just get into that layer and fix the issues at that layer without interrupting the entire system.

Each layer works with the help of protocols of the layer. What are protocols? Protocols can be considered as a system of rules which are followed by devices to enable communication between them.

We have HTTP, an application layer protocol to transfer HTML files or images, text, everything else among applications. We have TCP protocol to communicate with the other process running on the other device and many more.

Working part -

Let’s see how the system works from end to end? We'll explain using a small diagram. You can get a better idea/feel of what these layers are and how are they communicating with one another.

Few important concpets to understand the diagrams below -

How IP's are allocated to a system within a network.
Whenever your device is connected to WIFI | LAN it will be dynamically allocated a IP address via ARP | DHCP by a router. [Try to learn about subnetting and Classless Interdoamin Routing [CIDR].]

Port - Number associated with a process assigned by OS to uniquely identify the process among other running processes.

Whever a router receives a MAC packet from a device it processes the IP address within it, perform pattern matching with all routes available in its routing table and chooses the closest route matched to the dest IP of the packet and forwards it to the device in the matched route by attaching its own MAC header.This process is called hop - hop delivery.

I have run a experiment where I have used one of the systems within my college LAN that behaves as an client and other system behaves as an server.

Excalidraw Whiteboard

Excalidraw is a virtual collaborative whiteboard tool that lets you easily sketch diagrams that have a hand-drawn feel to them.

excalidraw.com

Device - A Server - Acting as a Server - Campus Wifi connected Laptop
IP Address - 172.24.135.46 [ Assigned by Router to my device]

Device - B Client - LAN Connected System
IP Address - 10.9.68.25 [Private IP]

Here we did not use any application layer protocol like HTTP, SMTP as we configured our own simple format to communicate with each other using simple commands.

TCP Layer uses ports and configures socket connection at both ends using socket data structure formed by src port, src IP address, dest port, dest IP address.

Conclusion-

Internet is a system involving entire ecosystem of multiple devices and multiple applications within it. It's not a single thing or a single entity. That is the major idea what I wanted to drive or derive out of this blog/video.

Understanding of GIT by implementation

Ankith Deegoju — Fri, 15 May 2026 06:56:11 +0000

In this blog we will explore the concept of -

Branches
Push, pull, merge
Pull Request and how can we contribute to any repo.

To understand above concepts we will follow a hands on approach of doing things -

Repo - Repository - Folder tracked by Git.

Methods to access an existing repo -

Directly download the repo from GitHub and open it in our terminal
We can fork the repo using fork button on github - This creates your own copy of the repo.
We can use git clone command to clone the repo locally. Command - git clone “Add repo-link here”

We will understand the concepts of cloning, remote conenction establishment, branching through the below steps.

Let’s create a new repo in GitHub. I have created a test_repo.

We get something like this -

Copy the link here.

Use the git clone command to clone the repo locally -

Let’s add a few files into it and we will also use some of the commands from our previous blog to add the files into staging, commit the changes, then push the code into GitHub.

I have created two files in the repo. [ You can refer prev blog / google it to create files in a repo ]

To push the code to GitHub we need to establish a remote connection with the GitHub repo. By default a remote connection with name origin is created if we use git clone command.

Why do we want to push code - Everyone with the repo link can view the updates in the code.

Command to establish remote connection - git remote add “remote-connection-name” “repo-link”

To view all existing remote connections in that repo .
Command - git remote -v

We can remove connection using command - git remote remove “remote-connection-name” .

Suppose we want to develop a project and we have a team of developers. We create a repo on GitHub. We then add a remote connection to that repo via our terminal, to make changes in our local system independently and then push those changes to the repo.

Why do we create a remote connection - To make changes locally in our system verify them once if they are properly working from our side and then pushing those to the github for the team to look into and review before deploying it.

I have also forked a public repo for example and did few things in the code.
Ex- git remote add origin https://github.com/NirDiamant/RAG_Techniques.git

To view all existing remote connections - git remote -v

Generally what happens is the repo’s MAIN / MASTER branch is generally connected to the hosting platform where our application in deployed [This is not always true]. Any changes to the MASTER branch will be reflecting in our production directly. To avoid any unnecessary issues , the MASTER branch of the repo is locked so that none of the developers can directly push the code to the production without proper check . So each developer creates a separate branch of the same repo, makes his/her changes then raises a pull request [PR], the manager / testing team after verification of the changes pushes the code into MASTER branch.

By default after cloning a repo, a MASTER branch is created in the local repo, which will be connected to the MASTER branch of the repo.

In my local experiments the default branch name is MASTER. Modern GitHub repositories use main by default not MASTER.

We need to use remote connection name and branch name to push changes into GitHub / MASTER branch.

What is a branch - Independent line of development

How do we create branches - Using command
git branch

To view all existing branches - git branch -a
Naming convention followed while creating branches- Developer Name/Feature Name

Fetch - Used to download the latest updates from GitHub repository and updates the remote tracking branch like remotes/origin/MASTER, without modifying our local working branch.

Use command - git fetch origin [ This fetches all branches from origin]

git fetch origin "branch-name" [ The changes are fetched from the specified branch name ]

We will manually add few changes in our repo from GitHub to understand fetch command in the GitHub repo. I have added changes in the two base files created via GitHub web app.

To compare changes from your local repo MASTER branch to the github repo’s MASTER branch we use - git diff MASTER origin/MASTER

So we have made changes directly in the MASTER branch of repo in the GitHub.

Using fetch command we can compare our repo code with latest github repo code and if needed the new changes can be copied into our local repo to maintain sync with the changes in the repo.

Branching - Switch command

We can update our repo with the newly made changes using git pull command. But we need to set upstream for a branch to enable push and pull changes. This upstream links a local branch to a remote branch.

Command - git branch —set-upstream-to=origin/MASTER

Now we can pull changes using pull command -

git pull origin [If upstream is already set- fetch and merge latest changes into the current local branch from the connected remote branch]

git pull origin "branch-name" [ The changes are pulled into the specifed branch name ]

To observe all the commit history of the branch - We can do it using command git log —oneline.

The branch Ankith/Feat1 is at commit 7864cda i.e. behind the MASTER branch of the local repo by two commits. So now we can merge these changes in Ankith/feat1 branch from the MASTER branch of local repo to keep all the branches in sync.

Explore checkout and restore commands in git.

Let’s understand merge -— squash . Suppose we make multiple commits in Ankith/feat1 branch .

Head pointer in the git always points the currently executed / checked-out commit.

Here we did few commits in the specific branch - Ankith/Feat1

When we use merge command all the three commits are merged into MASTER .

Instead we can also merge all the commits of Ankith/feat1 into MASTER branch using single commit by squashing all the commits into a single commit.

As we merge the changes from Ankith/feat1 branch to MASTER branch, the changes are placed into staging area. On commit operation these changes are made to MASTER branch with a single commit.

Generally we delete the branch once the changes are pushed to MASTER branch.

Pushing - To push changes made in the local MASTER branch into Github
Command - git push origin.

Rebase - Suppose we have two branches Ankith/Feat2, MASTER. Suppose my friend has added many features into the MASTER branch. In this case of many changes in a MASTER branch i.e. all the structure of your Ankith/Feat2 branch is different from initial setup then we can use rebase to place your branch commits on top of latest MASTER branch, creating cleaner linear history.

Here we can resolve merge conflicts either automatically or manually.

We can explore the above topics in a bit depth by using these commands and playing with them.

Explore about how Pull Request is created in an org and in open source contributions, if possible add pull request to my repo - https://github.com/ANKITHDEEGOJU/Test_Repo

If possible do create your open repo and configure it to allow PR”s from others by modifying the branch settings. [ Explore Protected Branches]

A small clarity - if you are the owner of the repo then you have the permission to directly push changes to MASTER branch, else you can push code directly to your custom branch and then raise a PR [if admin of the repo provides you access to create your own branch]. Generally people fork the repo , create their individual branch in the local repo , then push code to the MASTER branch of this local repo, check if everything is fine. Then send PR to admin/ maintainer to accept the updates. Then the maintainer verifies the code changes then accepts the pull request , merges changes into the main/MASTER branch of the repo.

Reference - Git Cheat Sheet

Basics of Git -

Ankith Deegoju — Fri, 20 Mar 2026 11:37:06 +0000

What is Git.

Git is a version control system. Version Control System is a software that manages changes of your code/files in a folder/directory.

What is the problem its solving -

Provides us tracking of changes in codebase.
Provides us simultaneous access to codebase enabling collaboration
[ via GitHub -> Simply say git in a server || Even I need to deep dive into it ]
Provides us a single source of truth i.e. provides us exact state of code base that is constantly being updated with changes done by members accessing the code base.

To understand it's importance and need of git.

Scenario - Imagine how you would collaborate with other developers and build together a project.

Suppose you have multiple people working with the same codebase but need simultaneous access and push changes independent of others in different parts of codebase.

Era before git - By sharing code via pendrive.
Think of use cases like - How can we provide simultaneous access and consistent updates of code across all developers of the code base.

I would like to know about ideas which you can think of in the above context.

How was git built - [Just a short story]

Linus Torvald was working on Linux. As it was open source project many developers pushed code to improvise it, eventually the code base was too big to track and update changes. To solve this issue git was developed as his side project.

How do we use git -

[Start doing it in a system with me]

Create a folder - LearningGit
Create two files - ex - demo1.txt , demo2.txt
Open your terminal and let's work in it now on.

Few basic commands -

ls - to list files in a folder.

              Linux/WSL         Command Prompt (cmd)
List Files   ls               dir

Detailed List   ls -l             dir

Show Hidden ls -a            dir /a

All Details ls -la               dir /a

nano - Linux -> To create and edit files

edit - Windows -> Installation Command - winget install Microsoft.Edit

Usage:- > edit <filename>

Key Bindings { Shortcut Keys } ->

Ctrl+S to save.

Ctrl+F for find and replace.

Ctrl+Q to exit.

Add some info into your files .

cat - Linux -> To view file data

type - Windows

Usage - type file.txt

Concatenate/Merge files: type file1.txt file2.txt > combined.txt

Let's now start using our git commands .

git init - Initializes git inside your folder with by creating a .git file.

O/P => Initialized empty Git repository in C:/WebDev/LearningGit/.git/

git status- To check the status

Red - Untracked
Green - Files that are being tracked / staged to be tracked.

Staging -

We need to stage files that we wish to track. A way to tell git to look into these files.

git add <filename> => For individual file to be tracked

git add . -> For all files within the directory to be tracked.

Committing -
Once we are okay with changes we can commit the changes, we can store them as checkpoints for reference of changes or revert back in-case of any fallback.

Command-

git commit -m "Initial files"

Try to change the code a few times and try to commit.

Once committed -> changes are permanently stored in .git file.

How does it work.
Under the hood we create a linked list of commits to file. Each new node stores a hash of prev node as a reference. As we have a head pointer in linked list similarly, we have a head pointer which points to the most updated node.

We can perform git add and commit both in a single command.
git commit -am "msg"

git log - gives us history of commits performed.

You get the list of commits with a unique hash value associated with each commit.

We can compare changes form one commit to another using commands-

git diff <hashval of commit> <hashval of commit to be compared with>
git revert hash_id=> Creates a complement of the given hash_id and attaches head to it.

The attached screenshot would be helpful.

We will explore .git folder,git branching, GitHub concepts in the upcoming blogs.

Git Cheat Sheet