Forem: Gurnav224

JWT Made Easy: A Beginner’s Guide to Authentication

Gurnav224 — Tue, 15 Jul 2025 04:40:22 +0000

📝 Introduction

Authentication is a key part of almost every web application today, and JSON Web Tokens (JWT) offer a modern, stateless, and secure way to manage it. If you’ve ever wondered how websites keep you logged in or verify who you are behind the scenes, chances are JWT is involved.

In this article, we’ll break down what JWT is, how it works, and how you can use it to protect your routes and user data. Don’t worry—this guide is written with beginners in mind, with simple code examples and clear explanations.

✅ What You’ll Learn in This Article

What is JWT and why it’s used
The structure of a JWT (Header, Payload, Signature)
How to generate a token using jwt.sign()
How to decode and verify the token using middleware
Real-world use case: authenticating users in a Node.js app
Common mistakes and best practices when using JWT

🔐 What is JWT and Why It’s Used

JWT stands for JSON Web Token — a secure and compact way to send user information between a client and a server. Once a user logs in, the server creates a token containing user data, signs it using a secret key, and sends it back to the client. The client then includes this token in future requests to prove they are authenticated.

JWT is commonly used in stateless authentication. This means the server doesn’t need to remember who the user is—everything is stored in the token and verified on each request.

🧬 The Structure of a JWT

A JWT is made up of three parts, separated by dots (.):

Header.Payload.Signature

1. 🧾 Header

The header typically contains two pieces of information:

The type of the token (always JWT)
The signing algorithm (like HS256)

{
  "alg": "HS256",
  "typ": "JWT"
}

2. 📦 Payload

The payload contains the actual data (also called claims), such as the user ID or username. You can add custom data too.

{
  "id": 1,
  "username": "gurnav",
  "iat": 1625674832,
  "exp": 1625678432
}

iat: Issued At – when the token was created.
exp: Expiration – when the token will expire.

3. 🔐 Signature

The signature is created by combining the header, payload, and a secret key. It ensures that the token wasn’t tampered with.

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret_key
)

If someone tries to change the data in the payload, the signature won’t match, and the token will be rejected.

🔐 How to Generate a Token Using jwt.sign()

After a user successfully logs in (by entering the correct email and password, for example), we usually want to create a token to identify them in future requests. This is where jwt.sign() comes in.

jwt.sign(payload, secretKey, options)

payload: Object with user info like ID, username, role, etc.
secretKey: A string used to sign the token (keep this private!)
options: An object with additional settings like expiresIn

💡 Code Example: Creating a JWT Token in Node.js

const jwt = require('jsonwebtoken');

const user = {
  id: 1,
  username: 'gurnav',
};

const secretKey = 'my_secret_key';

const token = jwt.sign(user, secretKey, { expiresIn: '1h' });

console.log('Generated Token:', token);

output

Generated Token: eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...

This token can now be:

Sent back to the client
Stored in localStorage or cookies
Used in future requests as a proof of identity

📌 Real-World Use Case

In a real application, you'd generate this token after verifying the user's credentials:

app.post('/login', (req, res) => {
  const { username, password } = req.body;

  // Fake user authentication (replace with DB check)
  if (username === 'gurnav' && password === '123456') {
    const token = jwt.sign({ username }, secretKey, { expiresIn: '1h' });
    res.json({ message: 'Login successful', token });
  } else {
    res.status(401).json({ message: 'Invalid credentials' });
  }
});

🛡️ How to Verify a JWT Token Using Middleware

Once a token is created and sent to the client, it’s included in every protected request—usually in the Authorization header or cookie. The server then verifies this token to check if the user is authenticated and allowed to access the route.

We use a middleware function in Node.js (Express) to handle this verification.

✅ Middleware Code Example

const jwt = require('jsonwebtoken');

const secretKey = 'my_secret_key';

function authenticateToken(req, res, next) {
  // Get the token from the Authorization header
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer <token>

  if (!token) {
    return res.status(401).json({ message: 'Access token missing' });
  }

  // Verify the token
  jwt.verify(token, secretKey, (err, user) => {
    if (err) {
      return res.status(403).json({ message: 'Invalid or expired token' });
    }

    req.user = user; // Attach the user info to the request
    next(); // Proceed to the next middleware or route
  });
}

📌 How to Use the Middleware

You can use this authenticateToken middleware on any route you want to protect

app.get('/dashboard', authenticateToken, (req, res) => {
  res.json({ message: `Welcome ${req.user.username}!`, user: req.user });
});

Now only users with a valid JWT token will be able to access /dashboard.

🔒 Key Points

Tip: Always send tokens from the frontend using the Authorization: Bearer header.

The jwt.verify() function will:

"Decode the token"
"Check its signature"
"Check for expiration (exp)"

If valid, you can access the decoded user info via req.user

🏁 Conclusion

JWT makes authentication in web applications simple, secure, and scalable—especially for APIs and SPAs. In this article, you learned how to create, structure, and verify JWTs using Node.js.

Now you’re ready to secure your routes like a pro! 🚀

# What Are the Different Types of Errors in JavaScript?

Gurnav224 — Sat, 31 May 2025 08:32:14 +0000

In JavaScript, errors are inevitable parts of programming. They act as helpful messages that let us know when something has gone wrong. JavaScript provides a built-in Error object that contains valuable information about the error. Understanding the types of errors and their causes is crucial for debugging and writing robust code.

Let’s explore some of the most common types of errors in JavaScript: Syntax Error, Reference Error, and Type Error.

1. Syntax Error

A Syntax Error occurs when we write code that does not follow the correct syntax rules.

Example:

console.log('hello world'

Reason: There’s a missing closing parenthesis. The JavaScript engine cannot parse this code.

Reference Error A Reference Error occurs when we try to access a variable or function that has not been defined.

Example:

console.log(a);

Reason: The variable a is not declared.

Type Error A Type Error occurs when a value is used in an unexpected way or is of an unexpected type.

Here are a few common reasons why Type Errors occur:

Calling a non-function If we try to invoke a variable as a function, but it is not actually a function, a Type Error will be thrown.

Example:


const obj = {};
obj();
// TypeError: obj is not a function

Accessing properties of undefined or null This error occurs when we try to access a property of a variable that is undefined or null.

Example:


let myVar;
console.log(myVar.name); 
// TypeError: Cannot read property 'name' of undefined

Modifying a constant variable A Type Error also occurs when we try to change a constant variable’s value.

Example:

const x = 5;
x = 10;
// TypeError: Assignment to constant variable

How to Approach Any Coding Problem or Development Task

Gurnav224 — Sat, 31 May 2025 06:43:26 +0000

To tackle any coding problem or develop new features effectively, there are a few things you should prepare before jumping straight into coding.

The most important first step is understanding the problem or the feature requirements. If you don’t fully grasp what’s being asked, you won’t be able to solve it effectively.

Step 1: Read and Understand the Problem

Read the problem carefully, focusing on what’s given and what you need to solve. Clarify any confusing parts and make sure you understand the scope of the problem.

Step 2: Plan Your Approach

Before diving into the code, take some time to plan out your solution. Ask yourself questions like:

What functionality do I need to develop?
Does it involve a user interface? If yes, sketch a rough layout.
What are the inputs and expected outputs?
Will I need to get user input to generate the desired output?

This planning phase will help you avoid confusion later.

Step 3: Write Pseudocode

Writing pseudocode helps you think through the problem in plain English (or any language you’re comfortable with!). It forces you to slow down and figure out the steps you’ll need in your actual code.

Example pseudocode: Checking if a user is eligible to drive

Take user’s age as input.
Store the user’s age in a variable called user_age.
Check if the user is eligible:
If user_age > 18:
Print “You are eligible to drive.”
Else:
Print “You are not eligible to drive.”

Step 4: Divide and Conquer

Breaking big problems into smaller sub-problems makes them easier to solve. Here’s how it might look:

Problem Statement:

Check if a user is eligible to drive.

Sub-problems:

✅ Take user input (age).

✅ Check if age > 18.

✅ If true, print “You are eligible to drive.”

✅ Else, print “You are not eligible to drive.”

By following these steps—understand, plan, pseudocode, and break down—you’ll find coding and development tasks much more approachable and easier to handle!

How javascript engine excuted the Javascript code

Gurnav224 — Thu, 29 May 2025 10:14:38 +0000

JavaScript code runs within the JavaScript engine, such as V8 in Chrome or SpiderMonkey in Firefox. or Node.js
The engine will take care of the code execution life cycle like parsing, compilation, and execution

1. Parsing: In the first phase, the engine will parse the JavaScript code into an AST abstract
syntax tree structure

before parsing
let a = 5; let b = 10; let sum = a + b; console.log(sum);

after parsing
Program ├── VariableDeclaration (let a = 5) │ ├── Identifier (a) │ └── Literal (5) ├── VariableDeclaration (let b = 10) │ ├── Identifier (b) │ └── Literal (10) ├── VariableDeclaration (let sum = a + b) │ ├── Identifier (sum) │ └── BinaryExpression (+) │ ├── Identifier (a) │ └── Identifier (b) └── ExpressionStatement (console.log(sum)) ├── MemberExpression (console.log) │ ├── Identifier (console) │ └── Identifier (log) └── Identifier (sum)

2. compilation phase: in this phase engine compile the AST into byte code or machine code

modern day javascript engine use JIT or JUST-in-time compliation to make the excution faster

3. excution phase : in the excution phase engine excuted the compile code
call stack keep track of the function call which function currenlty excuted

SQL vs NoSQL

Gurnav224 — Sat, 24 May 2025 04:15:47 +0000

SQL vs NoSQL

SQL: SQL databases store data in tables consisting of rows and columns, similar to spreadsheets.
They are designed to handle structured data with support for constraints and data integrity.
When new data is added, it typically grows vertically as new rows are inserted.

Key Points:

constraints: Rules for data definition like primary key, foreign key, and not null that ensure data validity
data integrity: Maintained through constraints and transactions to prevent invalid or inconsistent data
vertical growth: Adding records means adding rows (not columns)

NoSQL: NoSQL databases store data in a document-based, schemaless format, typically using BSON (Binary JSON). Data is represented as key-value pairs, making these databases well-suited for unstructured or semi-structured data.

They are designed to handle frequent and dynamic data changes, making them ideal for scenarios like analytics, social media posts, and real-time applications.

When new data is added, NoSQL databases typically grow horizontally—by adding more documents or nodes, rather than modifying the structure.

Key Points:

Schemaless: No fixed schema; documents can have different fields
Horizontal Growth: New data means adding more documents (not fields/columns)
Ideal Use Cases: Unpredictable or fast-changing data like user-generated content, logs, etc.

Real-World Applications Use Both Types of Databases According to Their Use Case

Example 1: Flipkart

SQL Uses: Used when data is highly structured and relationships between entities are important.

Categories have a well-defined structure: id, name, parent_category_id, etc.
Easy to represent with foreign keys (e.g., subcategories reference parent categories)

NoSQL Uses: Used for flexible, high-volume, and fast access data, often with denormalized structures.

Each product can have varying attributes depending on category (e.g., phones have battery capacity; clothes have size, color)
Storing in a document format (like in MongoDB) allows flexible schema per product

Example 2: Netflix Hybrid Architecture

SQL Uses: Netflix uses SQL to store metadata management (e.g., movie title, genre), billing and subscriptions, and user accounts and profiles

NoSQL Uses: Netflix uses NoSQL to store user activity logs, playback events, recommendations, and device and session management

Example 3: Uber's Hybrid Data Architecture

SQL Uses: Uber uses SQL databases (like MySQL or PostgreSQL) to store structured and relational data such as user accounts, ride history, driver profiles, and static relational data

NoSQL Uses: Uber uses NoSQL databases (like Apache Cassandra) for storing data like trip state management (live updates) and user-trip interactions (real-time locations, status)

Why We Use SQL and NoSQL

SQL: We use SQL databases to efficiently handle structured and relational data, where the schema is well-defined and data consistency is critical (e.g., user accounts, transactions, relationships between tables).
NoSQL: We use NoSQL databases to handle unstructured or semi-structured data, non-relational data models, and highly dynamic or large-scale data that changes frequently. NoSQL is ideal for use cases requiring flexibility, horizontal scalability, and fast read/write performance.

What is CAP Theorem?

CAP Theorem is a principle in distributed systems that says:
A distributed system can only guarantee two out of these three things at the same time:

C — Consistency: Every user sees the same data no matter which server they connect to.
Example: You book a cab, and your friend no longer sees that cab as available—because the system has updated everywhere at the same time.
A — Availability: The system always responds, even if it can't give the most up-to-date data.
Example: You always get a ride request response—even if the data might be slightly outdated.
P — Partition Tolerance: The system keeps working even if there's a network issue or some servers can't talk to each other.
Example: If two Uber servers in different cities can't communicate, both still handle local requests.

What type of language JavaScript Is?

Gurnav224 — Tue, 15 Apr 2025 04:32:43 +0000

JavaScript is a single-threaded, dynamically typed, interpreted programming language that supports multiple programming paradigms, including object-oriented, functional, and imperative styles. Its features provide prototype-based object orientation and an event-driven architecture. making it well-suited for building interactive and asynchronous web applications.

didn't get much idea with this definition, let's explore each part of it's definition in details

🧵Single Threaded: JavaScript is single-threaded, meaning it has only one main thread of execution. This means it uses a single call stack to manage function execution.

When a function is called, it is pushed onto the top of the call stack. Once the function finishes executing, it is popped off the stack, and control returns to the next item below. JavaScript code is executed in a sequential manner, one step at a time.

Despite being single-threaded, JavaScript provides Web APIs (like setTimeout, fetch, and Event Listeners) that allow asynchronous operations. These APIs work with the event loop and callback queue to handle asynchronous tasks without blocking the main thread.

console.log("Start");

setTimeout(() => {
  console.log("Inside setTimeout"); // runs later
}, 1000);

console.log("End");

// Output:
// Start
// End
// Inside setTimeout

Dyamically Type:
In JavaScript, variables are not explicitly declared with a type. Instead, their types are inferred from the values assigned to them at runtime. This means a variable can hold a value of one type and later be reassigned to a value of a completely different type during the program’s execution.

let data = 10;       // data is a number
data = "hello";      // now it's a string
data = true;         // now it's a boolean

console.log(typeof data); // Output: boolean

This flexibility makes JavaScript powerful but also prone to type-related bugs if not handled carefully.

Interpreted Language:
JavaScript is an interpreted language, which means the code is read, interpreted, and executed line by line at runtime, rather than being compiled ahead of time like some other languages (e.g., C++ or Java).

However, modern JavaScript engines in browsers (like V8 in Chrome) use Just-In-Time (JIT) compilation to enhance performance. JIT compiles frequently used code on the fly during execution, combining the benefits of both interpretation and compilation.

let message = "Hello, Gurnav!";
console.log(message); // Output: Hello, Gurnav!

Object Oriented: Object-Oriented Programming (OOP) is a paradigm that organizes code around objects, which are instances of classes. JavaScript supports OOP by allowing you to create and work with objects to encapsulate data and behavior.

Although the class syntax was introduced in ES6 (ECMAScript 2015) for cleaner and more familiar OOP syntax, JavaScript is fundamentally built on prototype-based inheritance under the hood.

class Person {
  constructor(name) {
    this.name = name;
  }

  greet() {
    console.log(`Hi, I'm ${this.name}`);
  }
}

const user = new Person("Gurnav");
user.greet(); // Output: Hi, I'm Gurnav

Imperative Programming:
Imperative programming is a programming paradigm that focuses on how to perform tasks step by step using explicit statements and control flow (like loops, conditionals, and assignments).

In this style, you tell the computer what to do and how to do it, modifying program state along the way.

const numbers = [1, 2, 3, 4];
const doubled = [];

for (let i = 0; i < numbers.length; i++) {
  doubled.push(numbers[i] * 2);
}

console.log(doubled); // [2, 4, 6, 8]

Functional Programming:
Functional programming is a paradigm where programs are constructed by applying and composing pure functions. It emphasizes what to do rather than how to do it.

Key principles include:

Pure functions (no side effects)
Immutability (data is not modified)
First-class functions (functions can be passed around like variables)
Higher-order functions (functions that take or return other functions)
Function composition: Building complex functionality by combining simpler functions.

const numbers = [1, 2, 3, 4];

const doubled = numbers.map(num => num * 2);

console.log(doubled); // [2, 4, 6, 8]

🧬 Prototype-Based Orientation:
JavaScript uses prototype-based object orientation, which means that objects inherit directly from other objects, rather than from classes (like in classical OOP languages).

Every JavaScript object has an internal link to another object called its prototype. When you try to access a property or method that doesn't exist on the object itself, JavaScript looks for it in the object's prototype chain.

Even the class syntax in JavaScript is just syntactic sugar over this prototype-based inheritance.

function Person(name) {
  this.name = name;
}

// Adding method to the prototype
Person.prototype.sayHi = function () {
  console.log(`Hi, I'm ${this.name}`);
};

const user = new Person("Gurnav");
user.sayHi(); // Hi, I'm Gurnav

note: sayHi is not directly on user, but JavaScript finds it through the prototype chain.

⚡ Event-Driven Architecture:
Event-driven architecture is a programming model where the flow of the program is determined by events — such as user actions (clicks, typing), messages from other programs, or timers.

In JavaScript, especially in the browser environment, this is a core concept. JavaScript uses event listeners to react to events asynchronously without blocking the main thread. This allows for building highly interactive and responsive applications.

<button id="greetBtn">Say Hello</button>

<script>
  const button = document.getElementById("greetBtn");

  button.addEventListener("click", () => {
    alert("Hello, Gurnav!");
  });
</script>

Here, JavaScript listens for the "click" event. When the event happens, the callback function is executed.

Real-world use cases:

Button clicks
Form submissions
Keyboard input
Mouse movements
API responses (like fetch)
Timers (setTimeout, setInterval)

Let Understand MERN Stack In Practical way

Gurnav224 — Mon, 08 Apr 2024 06:49:10 +0000

MERN stands for MongoDB, Express.js, React.js, and Node.js. It's important because it helps us build powerful web applications.

Imagine we're running a company and we want to keep track of our employees' information, like their names, emails, phone numbers, salaries, and how often they come to work.

Here's how we can see the information about our employees:

👀 Look at this table:

Name	Email	Phone	Salary	Attendance
John Smith	john.smith@example.com	+1234567890	$60,000	95%
Emily Johnson	emily.johnson@example.com	+1987654321	$55,000	98%
Michael Brown	michael.brown@example.com	+1654321890	$65,000	92%
Sarah Lee	sarah.lee@example.com	+1765432980	$70,000	96%
David Wilson	david.wilson@example.com	+1876543210	$75,000	97%

MONGODB

Now, to keep this information safe and organized, we need to put it in a special place called a database. We can use databases like MongoDB or MySQL for this.

So, MERN helps us make sure all the information about our employees is kept safe and easy to find whenever we need it.

Nodejs

Imagine you have a magical toolbox called Node.js. This toolbox lets you do special things on your computer or server, like making apps or websites. But instead of using regular tools like hammers or screwdrivers, Node.js lets you use JavaScript, the language of the web.

With Node.js, you can do cool stuff like:

Run JavaScript Outside of Browsers: Normally, JavaScript runs inside web browsers, but with Node.js, you can run JavaScript code directly on your computer or server.

Build Web Servers: You can create your own web server to handle requests from web browsers, which means you can make your own websites and web apps.

Access Files and Databases: Node.js lets you read and write files on your computer and connect to databases like MongoDB or MySQL.

So, Node.js is like a magical toolbox that empowers you to do all sorts of cool things with JavaScript on your computer or server.

Express.js:

Now, let's talk about Express.js. Imagine you have a super smart assistant called Express.js. This assistant helps you build web applications quickly and easily.

Here's how Express.js works:

Simplifies Web Development: Express.js provides a set of tools and shortcuts to make it easier to build web applications with Node.js. It saves you time and effort by handling common tasks, like routing and handling HTTP requests.

Middleware: Express.js uses middleware, which are like small plugins or functions that you can use to add extra features to your web app, such as authentication, logging, or error handling.

Routing: With Express.js, you can easily define routes for different URLs in your web app. For example, you can create a route for "/login" to handle user login requests or a route for "/products" to display a list of products.

Integration: Express.js works seamlessly with other Node.js modules and libraries, making it easy to add additional functionality to your web app.

So, Express.js acts as a smart assistant that helps you build web applications faster and with less effort by providing tools, middleware, and routing capabilities.

React:

Imagine you have a magical toolkit called React. This toolkit helps you build amazing user interfaces for your websites or web applications. It's like having a set of super-powered building blocks that you can use to create all kinds of cool things on the web.

With React, you can do awesome stuff like:

Component-Based Development: React lets you break down your user interface into smaller, reusable components. Each component represents a part of your UI, like a button, form, or header. You can then combine these components to build complex UIs, making your code more modular and easier to maintain.

Virtual DOM: React uses a virtual representation of the DOM (Document Object Model), which is like a blueprint of your UI. When your data changes, React updates only the parts of the DOM that need to change, making your apps faster and more efficient.

Declarative Syntax: React uses a declarative syntax, which means you describe what you want your UI to look like, and React takes care of updating the DOM to match. This makes it easier to reason about your code and write cleaner, more maintainable UIs.

So, React is like a magical toolkit that empowers you to build interactive and dynamic user interfaces for your web applications with ease.

Client:

Now, let's talk about the client. Imagine you have a friendly guide called the client. The client is like a person who interacts with your website or web application using a web browser, like Chrome or Firefox.

Here's how the client works:

Accessing Web Content: The client opens a web browser and types in a web address (URL) to access your website or web app. Once connected, the client can view and interact with the content you've created using technologies like HTML, CSS, and JavaScript.

Sending and Receiving Data: The client can send requests to your web server to fetch data or perform actions, like submitting a form or logging in. It then receives responses from the server, which it can display or use to update the UI.

Interactivity: The client can interact with your web app by clicking on buttons, filling out forms, or navigating between pages. It can also respond to user input, like keyboard or mouse events, to provide a dynamic and engaging user experience.

So, the client is like a friendly guide that helps users interact with your website or web application, enabling them to access content, send and receive data, and engage with the UI in meaningful ways.

Server:

Imagine you have a helpful butler called the server. The server is like a dedicated assistant that works behind the scenes to handle requests and deliver information to your website or web application.

Here's how the server works:

Handling Requests: When the client (the person using a web browser) wants to access your website or web app, they send a request to the server. This request includes things like the web address (URL) they want to visit or the data they want to retrieve.

Processing Requests: Upon receiving a request, the server swings into action. It processes the request, which might involve fetching data from a database, running calculations, or performing other tasks needed to fulfill the client's request.

Sending Responses: Once the server has processed the request and gathered the necessary information, it sends a response back to the client. This response contains the requested data or instructions on what to display in the web browser.

Managing Resources: The server also manages resources like files, databases, and other services needed to run your website or web app. It ensures that everything runs smoothly and efficiently to provide the best possible experience for users.

So, the server is like a helpful butler that works tirelessly behind the scenes to handle requests, process data, and deliver information to users, ensuring that your website or web application functions smoothly and reliably.

How the Web Works ?

Gurnav224 — Mon, 29 May 2023 12:29:45 +0000

In this blog , I,ll be writing about the how web works ?

In short World Wide Web is system of interconnected of documents and resource that accessed all over internet
It allow user to navigate different website and various information ,communicate and engage in various online activities

Client :

An Application , such as fire-fox or chrome that runs on a computer and is connected to internet. It primarily focus to take user interaction translate them into request to another computer called server. we use web browser to access internet in our daily lives. you think your computer as client in client-server model.

Every client computer has unique address are called Ip address.
Other computer use Ip address to find the computer.

Server :

The term server refer to the computer or collection of computers that host requested web resource. The server receives the request message from the client

IP Address :

Internet Protocol Address. A numerical identifer for a device such as computer , server , router on A TCP/IP address.

Every computer on the internet has an Ip address it uses to identify them and communicate with each other. Ip address four set of numbers separated by decimal (eg: 224.155.65.2). This is called logical address. In order to locate device in the network . The logical address is converted into physical address by TCP/IP software. The physical address (eg: MAC ADDRESS) is built into hardware

ISP:

Internet Service Provider : an ISP is company or organization that Provide to access the internet to individual , business, office, school ,etc.
ISP is middle man between client and server .

When your browser get request from you to go to www.google.com, It doesn't know where to look for google.com . so it ISP job to do as DNS (DOMAIN NAME SYSTEM) lookup to ask what IP address the site you trying to visit is configured to

DNS

DOMAIN NAME SYSTEM : A distributed database which keep track of computer's domain names and their corresponding IP addresses on the internet

Domain name : used to identify one or more ip address.
User use the domain name (e.g www.google.com) to get the website on the internet.

when you type the domain name into your browser. the DNS uses it to look up the corresponding ip address for that given website.

TCP/IP

Transmission Control Protocol / Internet Protocol . The most widely used communications protocol . TCP/IP is used as a standard for transmitting data over networks.

PORT Number

A 16-bit integer that identifies a specific port on a server and is
always associated with an IP address . It servers as a way to identify

a specific process on a server that network requests could be forwarded to

Host

A computer connected to a network- It can be client, server or any other type of device. each host has unique ip address. we need host to put our website online access everywhere 24/7

HTTP

Hyper-text Transfer Protocol. The protocol that web browsers and web servers use to communicate with each other over the internet.

URL

Uniform Resource Locators . URLs Identify a particular web resource .
A example https://github.com/someone. The URL specifies the protocol ("https"), host name (github.com) and file name (someone profile page).

A use can obtained the web resource identified by this URL via HTTP from a network host whose domain name is github.com

What is Internet ?

Gurnav224 — Sun, 28 May 2023 04:58:29 +0000

In This blog , I am Writing about What is internet in a very simple way

Internet is nothing but a network of wire's connected to each other.
wire are like copper wire , fibre optic and wireless
These wire spread through out the ocean all over the world.

wire connect's to our computer make's it online and communicate with each other and share our information through these wire

There are dedicated computer known as server directly connected to the internet 24/7 and store information such as Image, video , document etc

These computer's/server's having their own unique IP address.
The IP address like home address help them to reach the server.
These IP address looks like 192.168.12. it hard to remember

so we can associate these number's with name basically Domain Name Server
eg :
goole.com => 142.250.196.78

day 01

Gurnav224 — Fri, 12 Feb 2021 04:09:28 +0000

Learning git and GitHub
working my portfolio

Forem: Gurnav224

JWT Made Easy: A Beginner’s Guide to Authentication

📝 Introduction

✅ What You’ll Learn in This Article

🔐 What is JWT and Why It’s Used

🧬 The Structure of a JWT

1. 🧾 Header

2. 📦 Payload

3. 🔐 Signature

🔐 How to Generate a Token Using jwt.sign()

💡 Code Example: Creating a JWT Token in Node.js

📌 Real-World Use Case

🛡️ How to Verify a JWT Token Using Middleware

✅ Middleware Code Example

📌 How to Use the Middleware

🔒 Key Points

🏁 Conclusion

# What Are the Different Types of Errors in JavaScript?

1. Syntax Error

How to Approach Any Coding Problem or Development Task

Step 1: Read and Understand the Problem

Step 2: Plan Your Approach

Step 3: Write Pseudocode

Step 4: Divide and Conquer

How javascript engine excuted the Javascript code

SQL vs NoSQL

SQL vs NoSQL

Real-World Applications Use Both Types of Databases According to Their Use Case

Example 1: Flipkart

Example 2: Netflix Hybrid Architecture

Example 3: Uber's Hybrid Data Architecture

Why We Use SQL and NoSQL

What is CAP Theorem?

What type of language JavaScript Is?

Real-world use cases:

Let Understand MERN Stack In Practical way

MONGODB

Nodejs

Express.js:

React:

Client:

Server:

How the Web Works ?

Client :

Server :

IP Address :

ISP:

DNS

TCP/IP

PORT Number

Host

HTTP

URL

What is Internet ?

day 01

151days of code