Before diving into these components, it’s important to understand how JavaScript itself is executed.

🧠 How JavaScript Executes Inside Node.js

JavaScript execution is often misunderstood as simply being parsed and executed line by line. While parsing does happen first to check for syntax errors, modern engines like the V8 Engine go a step further.

After parsing the code and generating an internal structure (AST), V8 uses Just-In-Time (JIT) compilation to convert JavaScript into machine code. This allows the code to run much faster compared to traditional interpreted languages.

Execution then takes place using mechanisms like the call stack and memory heap, where functions are executed as they are invoked, rather than strictly following a simple top-to-bottom flow.

In short, JavaScript is neither purely interpreted nor purely compiled—it uses JIT compilation, combining the best of both worlds.

1. 🔥 V8 Engine: Executing JavaScript at High Speed

The V8 engine, developed by Google, is responsible for running JavaScript code in Node.js.

It uses Just-In-Time (JIT) compilation, which means it converts JavaScript directly into machine code at runtime instead of interpreting it line by line. This makes execution extremely fast.

When you write JavaScript in Node.js, V8 is the component that actually runs it.

V8 also manages:

• Heap memory (for storing objects)

• Call stack (for tracking function execution)

However, V8 has its limits. It does not handle:

• File system operations

• Network requests

• Timers

In short:
👉 V8 executes JavaScript and manages memory, but knows nothing about async tasks.

2. 🔄 libuv: The Backbone of Asynchronous Behavior

While V8 executes code, it does not handle asynchronous operations like file reading, network requests, or timers. That responsibility is handled by libuv.

It is libuv is a C library that is responsible for

• Event loop (core of async behavior)

• Thread pool (for handling heavy tasks)

• OS-level asynchronous I/O (files, network, etc.)

• DNS lookups

Node.js is single-threaded by design, but thanks to libuv, it can handle multiple operations at the same time without blocking the main thread.

For example, when you read a file or make an API call, libuv interacts with the operating system and processes the task without blocking the main thread.

In short:
👉 libuv handles everything V8 cannot—especially async operations.

3. 🔗 Node.js Bindings: The Bridge to the System

JavaScript alone cannot directly interact with low-level system operations like file systems or networking. This is where Node.js bindings come in.

Bindings are written in C/C++ and act as a bridge between JavaScript and the underlying system libraries (including libuv).

When you use built-in modules like fs or http, you are indirectly using these bindings. They pass your JavaScript requests to the system and bring the results back.

In short:
👉 Bindings = Connect JavaScript with system-level operations

As we know, let and const are block-scoped and variable is function-scoped. Let's talk about scope let, var, and const

1. Let : let gives block scope. Variable declared with let have block scope, meaning they are only accessible within the block in which they are declared. let prevents redeclaration within the same scope, reducting errors.

2. var : var is function-scoped, meaning a variable declared with var is accessible within the function it is declared in , or globally if declared outside any function. When declared outside any function, a var variable becomes a global variable.

3. const : Like let, const is block scoped. It does not allow ressaiging. While const prevents reassigning a value to a variable, it does not prevent modifying the contents of objects or arrrays. This is because const is applied to the binding( the reference) of the variable not the data stored in the object and array.

Hoisting

We talked in the previous blog that all code is scanned, and every variable and function is loaded into memory during the memory phase.

var declarations are hoisted to the top of their scope with values undefined. This means you can reference the variable before its declaration, but it will return undefined until it is assigned a value.

console.log(x)//undefined
var x = 20
console.log(x)//20

NOTE: Only the declaration is hoisted, not the initialization.

let and const are loaded to the memory phase, but they remain uninitialized and stay in the Temporal Dead Zone (TDZ) until their declaration is executed.

Temporal Dead Zone:
It is the period between when a variable is hoisted and when it is declared. During this time accessing the variable results reference error.

• This only occrus with the let and const.

• Starts at the befinning of the block and ends when the variable is initialized.

• Prevents the use of variable before declaration, avoiding unintended behavior.

let and const variable are hoisted but stay in the TDZ until the declaration is reached.

console.log(x)// throws reference errror(TDZ)
consoel.log(y) // says variable is not declared
let x// TDZ ends here

console.log(x)// throws undefined

x = 5 

console.log(x) // print 5

So if someone ask you if let and const are hoisted in JavaScript?
Say :
Yes they are hoisted , but unlike var they remains in the TDZ until their declaration. This means you can not access them before the declaration or you will get a reference error.

In case of functions, tfunctions are fully hoisted. Maybe clarify:

• function foo() {} → fully hoisted (callable before definition)

• var foo = function() {} → behaves like var, only the variable is hoisted, not the function body.

What is the Execution Context?

JavaScript first prepares the workspace/container/environment that holds all the information needed for JavaScript to run the piece of code. That environment is called the execution context.

• Global context: It is the default context when code runs outside any functions. Or we can say the global code runs in this execution context.

• Local Execution Context: Every time a function is called, a new execution context (local execution context) is created and pushed onto the call stack. It has its own memory location for the variable and the functions declared inside the function. This context is removed after the execution of the function

Execution Context Phases

1. Memory Phase

setting up your tools on a desk

This is the first phase where JavaScript sets up the environment for your code before actually running it. The memory phase is also known as the creation phase.

JavaScript scans all code before executing it. All variables are loaded into memory with the value "undefined," and functions are stored with their full definitions(fully hoisted).

In the above example, the name variable is loaded in the memory with the value "undefined". And the greet function is loaded with the full definition. This is why we can access the function before its declaration. This concept is called hoisting in JavaScript.

2. Code Execution Phase

actually using the tools to do the work

Now JavaScript starts running your code line by line. This is where values are assigned, expressions are evaluated, and functions are called.

What happens here:

• Variables get their assigned values.

• Function calls create new local execution contexts, which are pushed onto the call stack.

• Code executes in order.

Let's see the table for how the code in the above figure works.

JavaScript first prepares memory and then executes code. Understanding these two phases makes it easier to follow how your code runs.

Now that you know this, you’re ready to dive deeper into JavaScript!

Read more about hoisting in this blog : scope and hoisting in js

Programming is all about:

What we should do with what?

a. Data (numbers, text, true/false…)

b. Processing (loops, functions, etc.)

Let's talk about terminologies:

1. Data type: Data types are like labels that tell the computer what kind of value a variable holds. They define
   a. What kind of data can be stored (numbers, text, true/false, etc.)
   b. What operations can be done on that data

2. Context: It is the environment in which a piece of code runs. It consist of :
   a. execution thread and
   b. memory

3. Global Context: This is the default context when code runs outside any function. In browsers, this in global context refers to the window object. Variables and functions declared globally belong to this context.

4. Local Context: When code runs inside a function, it has a local context.

5. Execution Thread : An execution thread is the part of the JavaScript engine that runs your code line by line. It is like the “worker” that executes instructions in your program.
   Main thread and local exectuion thread are it's type.. based on the context.

6. Call stack: It is a structure in js that keeps track of funcitons. When function is encountered by exectuion thread(main thread), it pushes the function in to the stack. This call stack works in LIFO manner. After the execution function is popped out.

Git is a version control system. It helps developers to track changes in files. It tracks all the information like: who changes the code, what changes are done, when the changes are done. It also lets you revert any changes if needed. Git uses diffing algorithm to track changes. Git enables developers to work on same project independently without breaking others code. Git allows every user to have the local copy of the repository(so that we call it distriubuted)

we use platform like github, gitlab,bitbucket, aws code commit, azure, git tea etc to store our local repository on the internet and enable collaboration with other developers.

Why git is used?

Git is used because it solves the real problems of developers:

• Keep track of every change in code(when it is made, who made it)

• Provide better collaborative environment

• Prevents code loss

• Helps to roll back if you realised the change was a mistake.

How to install git?

To get started with git, we need to install git in our machine first

For windows:
visit the officail git website: https://git-scm.com/install/windows

Download the latest installer (64-bits is recommended) and run it.

For MacOs: install home brew if not already and then run following command

brew install git

After installing git successfully, you need to set your email address and username. This is important because git commit willl use this information and permanently save in the commits you create.

git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

In this , —global means your information will be used by all the repository in your machine.

Make sure by running command below:

git config --list

this will show something like this:

user.name="Your Name" user.email="your email address”

Now every commit you create will contain your your name and email address as author.

Git core terminologies

1. Repository

   Any project maintained by git is called repository. A repository is the main project folder that git tracks. Every changes in the files inside this folder. This folder contains project files, git history and the branch information. Once we run git init command, git starts tracking changes on our files and the folder becomes repository.

2. Commit

   Commit is the snapshot of your code at a point of time. It has a unique id(hash) and message. Or we can say any version of your project is a commit. If you permanenlty save your changes to your project with git, it is a commit. You basically move changes in your staging area to the repository area, that’s a commit. To move you use git commit -m “message to explain the change”.

3. Branch

   When many developer works on the same project or even when you are working on new feature by yourself, you do not want to break your code, then you use soemthing called branch. Branch is a independent and separate line of development in your repository. It allows developers to work on new feature , bug fix etc without affecting the main version or stable version. Once your work is done you have to merge it into the default branch i.e. master or main.

4. Head

   Head is a pointer that points to the current branch you are working on and the latest commit on that branch. When you make new commit, head updates HEAD to point to the new commit. You can move HEAD to a different branch or commit using git checkout or git switch.

5. Remote

   Remote refers to the online-hosted version of your repository. It allows many developers to collab and share changes. Default remote name is usually ‘origin’.

   You can run:

   git remote -v shows the remote repository linked to your local repository.

   git remote add <any_name_(origin is default)> <url> to add new remote repository to your local repository

   Similary you can remove and rename too.

   After adding remote repo to your local repository , you push your commits over there.
   git push -u origin main

   -u sets origin as the default so future git push commands can be run without specifying it.(-u sets the default remote and branch for your local branch, so you don’t have to type the remote and branch every time you push or pull.)

6. Clone

   Clone is used to copy the remote repository to your local machine.

   git clone <repo_url>

   This creates local repository with all the commits, files, and branches for the remote repository and allow you to work on the project locally.

7. Merge

   Merge is the process of combining changes from one branch into another, usually merging a feature or bug-fix branch into the main branch. Git automatically integrates the changes, but if the same lines were edited in both branches, you may need to resolve conflicts manually. After merging, the target branch contains all commits from both branches, preserving their history.

   git checkout main // swich to main branch(where you wanna merge other branch)

   git merge <brancName> // this will merge

8. Push

   Push refers to sending commits you did on the local repository to the remote repository so that other can see and access the change.

9. Pull

   Let's say some collaborator to your project added some code on the remote repository and you want sync your local repository with the new changes, for doing this we need to download the repository changes. We can do it using the git pull origin main command.

Three areas in Git

To maintains our files git uses three areas:

1. Working Area

Wokring area or working directory is the actual folder that we are writing code on. This is where we write code, make changes or delte files. Once we run git init command on this folder, git starts tracking changes on our files. Git just notices the changes does not save them in its history yet.

2. Staging Area

Working area is where we write, edit code. Once git notices these all changes if we decided to save the change, git put those changes in the staging area. Git does not do it automatically we have to run git add <filename> or if you want all the changes git add . . Any changes if file/files present in this area are those which wil be part of next version/commit*(in the world of git version is also referred as commit).*

2. Repository Area

Repository area or local repository where we hve those changes which are already part of some earlier vesion. When the files in the staging area are committed using the git commit command, Git stores those changes in the repository along with a commit message, date, and unique commit ID.

Read about git command here

let’s suppose you have a song lyrics file. Now you want to change one verse. You keep changing a lot of times. But after some time, you realise that the older one was better. So what will you do? nothing but regret. Cause you don’t have backup and history of the change.

Now one of your friends says, “ let’s do this song together.” And ask you for lyrics file to write his lyrics on. How would you give that to him ?I believe, you will either send it via email / whatsApp or you copy file in a pendrive and give him pendrive. Imagine,

• One good line got triggered on your mind and you want to add that right now on the file. You can not do it because file is with him.

• He does not write his lyrics but modified yours too.

• He records the song himself that it’s his own song. You will lose the ownership**.**

This is problematic, right?

So, this is where version control comes into the picture. Version control is a system that

• keeps track of all the changes in your files(like: when changes are made, who made the changes)

• allows Multiple people collaborate independently.

• allows you to rollback to the previous version if needed

The Pendrive Analogy in Software Development

Before version control came into the picture, developers used to write code back then too. They used to use pendrive. Pendrive used to be shared among all the developer in the team. So typical workflow used to be like this:

• Developer A writes code

• Copies it to a pendrive

• Gives it to developer B

• B edits the same file

• Copies it back to the pendrive

• gives it to developer

It’s look simple but if B can overwirte the codes and there will be no history for that. They don’t wanna take risk they used to make copies. B will make a new version instead updating it so that they can track changes later. That led to name project like final, final, final_real, final_actual_real. This can cause a lot of confusions to get which is the final.

To solve all these kind of issues, version control is used.

Before I start, I expect you to have basic understanding of IP addresses. You know, they are just numerical label that is given to each devices in a computer network to uniquely identify them, right?

So, let suppose I wanna talk to a web server. I must have the IP address of that server right? So basically if I wanna access anything in the internet(network of computer network) I must need to know the IP addresses. Wait, wouldn’t this gonna give you a headache? Internet is suppose to make your life easier now it is making you remember lots of things.

Solution before DNS

To solve this, computers started using a hosts.txt file to map hostname to IP address. It was manual text file stored in each computer(you can still finds that file : etc/hosts).

It looks sth like:

192.168.1.10        server1
192.168.03.12       server2

This file was manually maintained/ updated by system administrators. Even today, every computer still has a hosts file. It’s mainly used for testing or blocking websites.

DNS

As you know more manual work quickly become problem. And we know every problem has a solution(either it’s already found or we will have to… haha). Don’t worry somebody has already found the solution.
Do you remember every contact numbers that you have in your phone? Hell No. Then what you do? you just open phonebook and type name and you can get number and make a phone call.

So there is something named DNS that is like the phonebook of the internet.

DNS is distributed(no single server controls DNS, it’s spread across many servers worldwide), robust(keeps working even some servers fail) and scalable(can handle billions of request ) system of the interne. It translates human-readable domain names like(www.google.com) into IP address that computers use to communicate. Without DNS we would have to remember IP address for every website.

DNS does note exist to serve browsers. Browers are just one of its users. Email, security, cloud, verification all use DNS

DNS tells you who should you talk to next.

But DNS does not only translate the human readable domain names to an IP address. It does much more than that:

• translates domain names into IP addresses.

• Guides your request to the correct server across the internet.

  ex. Your browser asks DNS for cs.harvard.edu → DNS tells which authoritative server to contact.

• Directs emails to the right mail servers (MX records)

  ex. Sending email to example@mail.com → DNS points to Gmail’s mail servers

• Handles subdomains and organizes services

  ex. cs.harvar.edu .. cs is subdomain

• Supports load balancing and faster content delivery (CDNs)

  ex. www.netflix.com DNS may give IP of the nearest server to your location.

• Caches results to make internet access faster

  ex: Visiting www.youtube.com again → your local DNS cache returns IP instantly

DNS Hierarchy

DNS hierarchy is the structured organization of domain servers. It is tree like structure starting from root server branching down to subdomain. This structure makes DNS distributed, robust and scalable.

1. Root Server

This is the top most level in the DNS system. This is the first POC(point of contact). Root servers know the location of all TLD(top-level domains) servers. There are 13 root server groups globally(with many copies). So in reality, there are hundreds of physical root server instances worldwide, but only 13 logical root servers from the DNS perspective.

This is the top most level in the DNS system. There are the first POC(point of contact). Root serves know the location of all TLD(top level domains) servers. There are 13 root server groups globally(with many copies). So in reality, there are hundreds of physical root server instances worldwide, but only 13 logical root servers from the DNS perspective.

2. Top Level Domain

TLD is the last part of the domain name that comes after the last dot(.). TLD servers manages domains under specific TLD like .com, .edu, .org etc.

Example: .edu TLD server knows where the cs.harvard.edu’s authoritative server is.

.edu is Top level deomain

.edu’s TLD server doesn’t know the exact IP of cs.harvard.edu itself.
But it knows which server is authoritative for harvard.edu (the second-level domain).

3. Second level Domain

The second-level domain is the part of a domain name that comes directly before the top-level domain (TLD). It is usually the name of organization, company etc.

Second level domain’s authoritative server stores the actual DNS record for this domain.

harvard.edu → harvard is second level domain and .edu is the TLD

Authoritative server for second level domain is where DNS records live.

4. Sub Domain

A subdomain is a part of a domain that comes before the second-level domain.
It is used to organize different sections or services of a website and can have its own DNS records.
If needed, it can also have its own authoritative server, separate from the main domain.

cs.harvard.edu → cs is the subdomain of harvard.edu (second-level domain) with .edu as the TLD.

Subdomains let you divide or manage a domain without buying a new domain.

DNS Resolution

when you type google.com in browser, what happens actually? let’s discuess

1. Check host.txt file

Your computer first checks the hosts file (already discussed above) If it finds an entry here (for google.com → ip address), it skips all other steps and uses this IP.

2. Query Initiation

Now, your computer or device verifies its local DNS cache to see if it already has the IP address corresponding to google.com . If it doesn't have the IP address, the DNS resolution process begins.

3. Recursive DNS Server

Next, your computer sends a query to a recursive DNS server, often provided by your internet service provider or a public DNS resolver like Google Public DNS. These servers are responsible for carrying out DNS resolution on behalf of the client. This is the point of contact. Recursive DNS server first check its local cache .

If you are from Nepal, do you remember Nepal once banned tiktok. The authorities did not block TikTok’s IP addresses directll but they blocked access only at the DNS level. This means that the ISPs’ DNS servers refused to translate TikTok’s domain name (like www.tiktok.com) into its corresponding IP address, making it impossible for users to reach the site using default settings. However, users who switched to public DNS servers such as Cloudflare’s 1.1.1.1 or Google’s 8.8.8.8 were still able to access TikTok, because these DNS servers could resolve the domain normally. In other words, the ban affected only the domain resolution at the ISP DNS level and did not block the actual TikTok servers or their IP addresses.

4. DNS Hierarchy

If the recursive DNS server doesn't have the IP address for the google.com either, it initiates the DNS resolution process by sending a request to the root DNS servers. These servers are critical to the DNS infrastructure and store a list of the top-level domain (TLD) servers for each domain extension like .com, .org, .net, etc. g1 TLD servers: The root DNS servers respond to the recursive DNS server with the IP address (i.e. .com ) of the TLD server that manages the specific domain extension requested like .com, .org, etc. The recursive DNS server then sends a query to the .com TLD server.

5. Authoritative DNS Servers

The TLD server responds to the recursive DNS server with the IP address of the authoritative DNS server for google.com. The authoritative DNS servers store the DNS records (such as A records, CNAME records, MX records, etc.) for specific domain names. The recursive server fetches the IP from here and sends it back to your device. Usually, the IP is also cached locally to speed up future requests.

Following are some usefull git commands

git init

This initializes a new git repository in an existing project. This command creates a new hidden folder (.git). It contains all the necessary repository files and subdirectories to manage version control for your project.

To initialize the git in your project, go to root folder and run following command

git init

git status

This command is used to check and display the current status of your project. This command tells the informaiton like which files are modified, which files are staged for the next commit, and which files are untracked. This is very helpful command to know the state of your project.

git status

git add

The git add command is used in order to begin tracking a new file or stage changes in the working directory so that the changes can be included in the next commit. Staging is an essential step in the Git workflow because it allows you to choose which changes should be included in the commit and which ones should be excluded.

#1 to add all the changes and new files
git add . 
#2 to add single file
git add filename
#3 to add multiple file 
git add filename filename

git commit

Commit is a snapshot of the project at any specific point in time. Each commit has a unique identifier (a hash) and includes a message that describes the changes made in that commit. The git commit command is used to save staged changes in your Git repository as a new commit.

git commit -m "message that describes the change made"

git log

This command is used to list the commit history of a repository. It shows information about past commits, including hashes, authors, dates, and commit messages.

#1 displays history commits
git log

#2 Displays commits history in short
git log -oneline

#3 Displays details of a commit
git log -p <commit_has>

#4 Display last n number of commits
git log -n <number_of_commit>

#5 display for specific branch
git log <branch_name>

#6 display commits by auther
git log --author <author_name>

git diff

This command is used to compare various parts of your git repository

#1 Compares working direcotry to last commit 
git diff

#2 compares two commits
git diff <commit_has> <commit_hash>

#3 compare staged changes to last commit
git diff --staged

git pull

The git pull command is used to fetch changes from a remote repository (usually the origin) and merge them into your current branch. It essentially combines two operations git fetch and git merge.

Fetching changes (git fetch) - Git fetches new changes from the remote repository (usually named "origin" by default) into your local repository without immediately merging them into your current branch. Merging Changes (git merge) - After fetching changes, Git automatically tries to merge them into your current branch.

#1 fetch form remote main branch and merge to current branch
git pull
#2 fetch from another remote branch to current brach 
git pull origin branchname

git clone

The git clone command is used to make a copy of a remote Git repository on a local machine. It allows us to start working on a project that is hosted on a remote server by downloading all the project’s files, commit history, and branches

git clone <url>

git push

This command is used to upload local commits to a remote repository, allowing developers to share their work and synchronize changes across multiple machines.

git push -u origin main # for first time then  git push

git stash

The git stash is a useful Git command used to temporarily save the changes in your working directory and index without committing them. This is particularly handy when you need to switch to a different branch or perform some other operation that requires a clean working directory.

The main purpose of git stash is to save changes that are not ready to be committed yet but need to be temporarily stored. This allows you to switch branches or perform other operations without committing to halffinished work.

#to save changes without commit
git stash

# retrieve stashed change
git stash apply

#list all the stashed changes
git stash  list

git checkout

This is versatile command with the multiple uses.

#1 to switch to existing branch
git checkout branch_name

#2 create and switch to a new branch
git checkout -b branch_name

git branch

The git branch command in Git is used to list, create delete, and manage branches with a Git repository. Branches are used to isolate development work and manage different lines of code.

#1 list all branchs
git branch

#2 create a new barnch
git branch <branchName>

#3 delete 
git branch -D <branchname>

#4 rename
git branch -m newname

git reset

The git reset is a powerful Git command that allows you to reset the current branch to a specified state. It’s used to undo changes, unstaged files, or move the branch to a pointer to a different commit.

It is a Git command used to move the HEAD (and the current branch pointer) to a specified commit and optionally update the staging area and working directory.

HEAD points to the current branch, while the branch pointer points to a commit; when a branch moves, HEAD follows it.

There are three primary options for git resets
1. Soft reset: This moves HEAD and the current branch pointer to the specified commit without changing the staging area or working directory. All changes remain staged for the next commit.

2. Mixed reset: Moves HEAD and the branch pointer to the specified commit, unstages all changes, but keeps them in the working directory. Useful when you accidentally staged files.

3. Hard reset : Moves HEAD and the branch pointer to the specified commit, removes all staged and unstaged changes from the working directory, effectively discarding all changes. Use with caution.

Use cases are give below

#1 Undo the last commit(When you commit to early or with the wrong message
git reset -- soft HEAD^
(Keeps changes staged)

#2 Unstage files accidentally added ( you did git add. and wanna unstage some )
git reset <file_name>

#3 Discard all local changes.....( you tried some changes but want to start fresh)
git reset --hard HEAD 
(Removes all staged and unstaged changes in the current branch.)

#4 Move the branch to a specific commit
git reset --<commit_hash>

etc,..

git merge

The git merge is a Git command that is used to integrate changes from one branch to another branch. This is typically used to combine the changes made in a features branch back into the main branch.

git merge <branch_name>

git squash

The git squash is not a standalone Git command, but it refers to a technique used to combine multiple Git commits into a single, more meaningful commit. This is typically done to maintain a cleaner and more organized Git history.

git merge --squash <branch_name>

//Squash combines changes ... you need a single commit to save them.

git rebase

Git rebase is a Git command used to move or reapply commits from one branch onto another, creating a linear commit history. It rewrites commit hashes for the rebased commits. After rebasing, you won’t see a merge commit, but all the changes from your branch will appear as if they were applied on top of the target branch from the beginning. In other words, it acts as if the branch was created from the latest state of the main branch, even though it originally started earlier. Rebase is used instead of merging to avoid unnecessary merge commits and keep the history clean.

#suppose you have a branch feature  and you want to rebase on top of the main branch

#1. make sure you are on the main branch
git checkout main
git pull origin main

#2. switch to the feature brahcn
 git checkout feature

#3 rebase the feature branch on the main branch
git rebase main

git revert

The git revert command is used to create a new commit that undoes the changes made by a previous commit or a range of commits. It effectively applies the inverse of the specified commit(s) to the current branch, allowing you to ‘revert the changes without altering the commit history

#single commit  revert
git rever <commit_hash>

#range of commit 
git revert <commit_hash> .. <commit_hash>

If any two or more than two entities are connected to communicate with each other, then that connection is called as network. Example of network can be social network (connection between two or more people), network or highways etc.

Similary, when the two or more computers are connected, it is called computer network. Computer network make communication possible for computers. The network of multiple computer networks is internet. We need certain physical appliances to establish a network for computers , these physical appliances are know as network devices. Some of network devices are : Router, Modem, Switch, firewall etc. these devices help you to access the internet.

Function of Network Devices

1. Enabling communication between computers

2. Managing and controlling data traffic to avoid congestion

3. Amplifies weak signal to boost speed and extend network coverage

4. Provice secure connection

Network Devices

When you open a website, your data travels through multiple devies before reaching its destination.

• your device genereates data(like http request)

• NIC converts data into signal to travel over local network

• Hub or switch or access point directs data within your local network

• router choose the best path for data to leave your network

• modem converts your LAN signal into analog signal suitable for transimsiion over the ISP medium then you get connected to the internet

Finally your request reach to the server and it gerenates the response and it come back to you same way it went.

1. NIC

NIC stands for network interface card. This is the chip(used to be an external card) inside your device that makes your device able to connect to network physically or wirelessly. NIC is present in every network-connected device. NIC has mac address assigned to which is required for the communication inside local aread network. NIC converts data to the electrical signal(if you are connecting with ethernete cable) or radio waves(if using wi-fi) so it can travel over the medium. The receiving device’s NIC converts the signal back into digital form tha computer can understand

2. HUB

HUB Is used to connect multiple computers in a local area network. When hub receives data from any devices connectd to it’s port, it broadcast the data to all other ports. It does not know MAC address, IP address. It is dumb. So every device connected to its port wil get the data but only the intended device will receive it, others just ignore. The transmission mode in hub is dubplex, meaning sending and receiving of data can not be done simultaneouly.

3. Repeater

When signal travels through the medium like wire, air they might lose weight with the distance. In order to make the signal sharp as the original we need some extra work to do. This is where repeater are used. Repeater does not understand data but they just signals. Let’s suppose you max length for a ethernet cable is 100m, if you need 200m you have to put a repeater in between.

4. Modem

Word modem came from the work it does; modulation and demodulation. Modem converts signal(generated by NIC) from your network to the form requried by your ISP’s physical medium and vice verca. It acts as a translator between your network and your internert. It is placed between your router and ISP connection. Modem provides internet to the network that is connected through a hub or switch.

5. Switch

Switch is the better version of HUB that is used to connect all the fevices is a local area network. It is much smarter. It forwards data only tot the device that needs it using mac address. It stores mac of all the connected devices and upon receiving a message from sender it checks mac address of the message and then sends the message to the receiver that mathces the mac address.

6. Bridge

Bridge is a network device that connects two LAN segments and manage traffic between them. You can think it as a small overpass connecting two neighborhood allowing only relevant traffic to pass. Bridge uses MAC address to decide whether to send data between LAN segments. Suppose you have LAN1 and LAN2. Device A in LAN1 wants to send data to device B in LAN2. Bridge check MAC address table: if the destination MAC is in the other LAN , it forwards the data, and if same it blocks the data.

7. Access Point (AP)

AP is a networking device that allows wireless devices to conne t to a wired network (LAN). AP is connected to a switch or router using ethernet cable. Wireless devices connet to the AP via wi-fi. AP forwards wireless traffic to the wired network, and vice-versa.

8. Router

Router is a device that connects two or more networks and forwads data between these based on IP address. It connets a LAN to the WAN or Internet. It maintains MAC address of local devices using an ARP(address resolution protocol) table. When a router receives a packet it checks the destination IP address. If destination IP belongs to the local network the router forward the packet by creating frame with the destination device’s MAC address and sends it to the switch. If the destination IP is outside the local network , the router forwards to ISP gateway by encapsulatin it in a new frame with the ISP gateway’s MAC address.

9. Firewall

Firewall is network device that sits between. your local network and the outside world to control and filter the traffic. It monitors and filters incomming and outgoing traffic according to predefined rules. This is the best place to control the traffic because it is right in between the router and outside world. All of the traffic or packets have to pass through this. Imagine you wanna put a security guard at your home to block all of the unknown person to enter, where would you let him stand? at the main gate from where the any unknown person can come right? So firewall is also a gatekeeper for you LAN.

10. Load Balancer

It is a networking device that distributes network traffic across multiple servers to make sore no single server get overloaded. Load balancers are used in the server side. Server use it to share the load. Suppose you have 3 servers. If any user requuest come load balancer will direct it to the server that has less requests, to make sure user get response faster and no server become overloaded.