DEV Community: tanishmohanta

Joins in SQL

tanishmohanta — Wed, 21 May 2025 13:02:45 +0000

TCP/IP Network Model💻 : Deep Dive with an example

tanishmohanta — Sat, 22 Jul 2023 16:06:27 +0000

So, let's get started😃.

The TCP/IP model is a conceptual framework used for understanding and implementing network communication protocols. It stands for Transmission Control Protocol/Internet Protocol and is the foundation of the modern internet and most networks.

The TCP/IP model consists of four layers, each serving a specific purpose. Let's break down each layer:

Application Layer:
- The Application Layer is the top layer of the TCP/IP model, and it is responsible for providing network services directly to user applications. These services allow software applications to communicate over the network. Examples of applications that operate at this layer include web browsers, email clients, and file transfer programs.
- Some common protocols at this layer are HTTP (Hypertext Transfer Protocol) for web browsing, SMTP (Simple Mail Transfer Protocol) for email, and FTP (File Transfer Protocol) for file transfers.
- This layer is where user data is generated or consumed, and it formats the data in a way that is understandable by the application.
Transport Layer:
- The Transport Layer is responsible for end-to-end communication between devices on the network. It ensures reliable and orderly data delivery, error detection, and flow control.
- The two most commonly used protocols at this layer are:
  - TCP (Transmission Control Protocol): It provides reliable, connection-oriented communication. TCP ensures that data packets are delivered without errors and in the correct order. It also handles flow control to prevent overwhelming the receiving device with too much data at once.
  - UDP (User Datagram Protocol): It is a simpler, connectionless protocol that offers minimal error checking and no guaranteed delivery. UDP is used for applications where speed is more critical than reliability, such as real-time video streaming or online gaming.
- When data is passed down from the Application Layer, it is divided into smaller chunks called segments (TCP) or datagrams (UDP) for transmission over the network.
Internet Layer:
- The Internet Layer is responsible for addressing, routing, and forwarding data packets between different networks. It ensures that data packets reach their destination across the internet or any interconnected network.
- The primary protocol used at this layer is the Internet Protocol (IP). It assigns a unique IP address to each device connected to the network, allowing routers to direct data packets to the correct destination based on these addresses.
- When data segments or datagrams arrive from the Transport Layer, the Internet Layer adds the source and destination IP addresses, forming an IP packet.
Link Layer (Network Access Layer):
- The Link Layer is the lowest layer of the TCP/IP model and is responsible for the physical transmission of data between nodes on the same network. It deals with hardware addressing, error detection, and the reliable transmission of frames (data packets) within a local network segment.
- This layer has different implementations depending on the type of physical network being used, such as Ethernet, Wi-Fi, or PPP (Point-to-Point Protocol).
- At this layer, the IP packet is encapsulated in a data frame with a specific hardware address, known as the MAC address, of the receiving device on the local network.

So concluding, the TCP/IP model provides a framework for communication between devices over a network. It starts from user applications at the Application Layer, which generate data. This data is then broken down into segments or datagrams at the Transport Layer, assigned IP addresses at the Internet Layer, and finally transmitted in data frames with MAC addresses at the Link Layer. As data flows through the layers in the reverse order, it gets reassembled, error-checked, and delivered to the appropriate application on the receiving device.

Let's understand with an example😃.

Suppose, I connected my desktop💻 to internet (airtel), Opened browser, Typed www.facebook.com and Hit enter. The following steps will happen in TCP/IP model.

Application Layer:
- You open your web browser (e.g., Chrome, Firefox) on your desktop. The web browser operates at the Application Layer of the TCP/IP model.
- You type "www.facebook.com" in the address bar and hit Enter. This action triggers the web browser to initiate a request to access the Facebook website.
Transport Layer:
- At the Transport Layer, the web browser uses the HTTP (Hypertext Transfer Protocol) to send the request to access the Facebook website. The request is divided into smaller segments for transmission over the internet.
- TCP (Transmission Control Protocol) is used for HTTP requests as it ensures reliable data delivery. The browser establishes a TCP connection with the web server that hosts the Facebook website.
Internet Layer:
- The TCP segments are passed down to the Internet Layer, where the Internet Protocol (IP) comes into play. The IP layer adds the source and destination IP addresses to the segments, forming IP packets.
- In this step, the browser's request for the Facebook website is encapsulated in an IP packet. The destination IP address is determined based on the domain name "www.facebook.com," which is resolved into an IP address using DNS (Domain Name System) lookup.
Link Layer (Network Access Layer):
- The IP packets now move down to the Link Layer, where the appropriate network interface is determined. Since you are connected to the internet through Airtel, the Link Layer prepares the data frames for transmission over the Airtel network.
- The data frames are encapsulated with source and destination MAC addresses. The destination MAC address is typically the MAC address of the Airtel router (gateway) that connects your desktop to the internet.
Transmission:
- The prepared data frames are sent over the local network (your home network) to the Airtel router, and from there, they are forwarded to the Airtel network infrastructure.
Routing:
- Within the Airtel network, routers examine the destination IP address of the packets and use their routing tables to determine the next hop (the next router) to forward the data towards its destination.
Internet Backbone:
- The IP packets traverse through multiple routers and network devices in the Airtel network and possibly other networks in the global internet backbone. These devices work together to route the packets closer to the destination server hosting Facebook.
Reaching the Facebook Server:
- Eventually, the IP packets reach the data center where the Facebook website is hosted. The data center's routers further direct the packets to the specific server that hosts the Facebook website.
Server Response:
- The Facebook server processes your request, generates the webpage content, and prepares a response to send back to your desktop.
Transmission Back to Your Desktop:
- The server response follows the same path in reverse, going through the Internet Layer and Link Layer. The response data travels through the Airtel network, your home network, and finally arrives at your desktop.
Link Layer Decapsulation:
- At your desktop's Link Layer, the data frames are decapsulated, removing the Link Layer header and leaving the IP packets.
Internet Layer Decapsulation:
- The IP packets move up to the Internet Layer, where the IP headers are removed, leaving the Transport Layer segments.
Transport Layer Decapsulation:
- At the Transport Layer, the TCP segments are reassembled into the original HTTP response from the Facebook server.
Application Layer Decapsulation:
- The web browser at the Application Layer processes the HTTP response, interprets the webpage content, and displays the Facebook website on your browser window.

This entire process happens rapidly behind the scenes, enabling you to access websites and communicate over the internet seamlessly, thanks to the TCP/IP network model.

Until next time😃.
If you liked the article, do hit like💖.

Journey Through the Digital Highway🗺️: How Data Travels From Your Laptop💻 to Your Friend's Laptop🙋‍♂️: Deep Dive.

tanishmohanta — Sat, 22 Jul 2023 13:56:31 +0000

Just read this part (first paragraph) once, below you will understand in deep.

Imagine that the internet is like a vast highway system, and internet backbones are the main highways that connect major cities and towns. These highways (backbones) are essential for fast and efficient communication between different regions.

Example: (Note: Just read it once, you will get it below)

Highway System (Internet): The internet is like a network of highways that allows data (traffic) to flow between various locations (websites, servers, computers, etc.).

Main Highways (Internet Backbones): Internet backbones are like the main highways in this system. They are large, high-capacity data transmission lines made of fiber-optic cables that connect major cities and data centers worldwide.

Data Transmission (Internet Traffic): Data, such as emails, web pages, videos, and more, travels along these main highways (backbones) to reach its destination quickly and efficiently.

Regional Roads (Internet Service Providers - ISPs): The data leaves the internet backbone at certain points and enters the networks of Internet Service Providers (ISPs). These ISPs are like the regional roads that connect smaller towns and communities to the main highways. They serve as the gateways for users to access the internet.

Local Streets (End Users): From the ISPs, the data is further distributed to end users (like you and your friend). These end users are like local streets where the data reaches its final destination.

📌Here's the explaination of the data transfer🗺️:

Your Laptop💻: You send data from your laptop.
Airtel Network (Airtel Tower - T)🗼: The data is transmitted wirelessly from your laptop using electromagnetic waves to the nearest Airtel tower (T). The tower serves as an access point for your laptop to connect to the Airtel cellular network.
Regional Area (Local Network - T -> T -> R -> R -> R): From the Airtel tower (T), the data may be transmitted wirelessly to the next nearby Airtel tower (T). This process can involve several tower-to-tower hops (T -> T) within the regional area, extending the coverage of the Airtel network (There can be n number of T's and R's).
Airtel Router (R): Once the data reaches the last tower in the regional area, it is handed off to an Airtel router (R). Airtel routers are typically located at central facilities, network exchanges, or data centers.
Internet Gateway (Airtel - R): From the Airtel router (R), the data is then forwarded to the Airtel internet gateway. The internet gateway serves as the connection point between Airtel's local network and the broader internet (main highway).(Regional Area of Airtel ISP ends here !!!.)`
Internet Backbone (Main Highway): After passing through Airtel's internet gateway, the data enters the internet backbone (main highway). It travels through high-capacity data transmission lines (e.g., fiber-optic cables) operated by various companies like Tata Communications, Google, Level 3 Communications, and others. These backbones form the core infrastructure of the global internet.
Internet Routers (Various Providers): As the data travels through the internet backbone(main highway), it encounters internet routers operated by various ISPs and network providers, including those mentioned above(like Tata Communications, Google, Level 3 Communications). These routers direct the data packets toward their intended destination, guiding them through the complex network of interconnected pathways.
Jio Network (Regional Area - Destination Area): As the data approaches its destination area (e.g., your friend's location served by Jio), it will leave the internet backbone and enter Jio's network (regional area). This transition involves routers and other network components to guide the data closer to its final destination.
Jio Tower (Jio Access Point)🗼: From the network, the data may be transmitted wirelessly through the air via Jio's tower, which acts as an access point for mobile devices to connect to the Jio network.
Your Friend's Laptop💻: Finally, the data reaches your friend's laptop, where it is received and processed by their computer or device, enabling them to read the email or interact with the data you sent.

Here's a demonstration of undersea Internet Backbone(main highway).In similar way, there are also Internet Backbone on land.

In summary, data📑 is transferred through electromagnetic waves between the towers (T) within the regional area. Once it reaches the last tower, it is then passed to an Airtel router (R) before being forwarded to the internet gateway and entering the main internet backbone. From there, it goes through a network of internet routers and eventually reaches the destination, your friend's laptop.
Until next time. Happy Learning😃 !!!.
If you liked the article, do hit like💖.

Client-Server Architecture🤝 : Deep Dive

tanishmohanta — Fri, 21 Jul 2023 16:03:59 +0000

Welcome, let's deep dive into the concept😃.

Client-server architecture is a common model used in computer networks to allow multiple devices to communicate with each other. It involves two main components: the "client" and the "server."

Let me explain it in simple terms😃:

Imagine you want to order food from a restaurant. In this scenario:

You (the customer) are the "client."
The restaurant staff who takes your order and prepares the food is the "server."

Here's a step-by-step explanation of client-server architecture:

Clients: Clients are devices like your computer, smartphone, or tablet. They initiate communication and request services from the server. In our restaurant example, you (the customer) are the client.
Servers: Servers are powerful computers or devices dedicated to providing services or resources to clients. They wait for incoming requests from clients and respond accordingly. In our restaurant example, the restaurant staff taking orders and preparing food is the server.
Communication: Clients and servers communicate over a network, like the internet. When you order food, your request is sent over the network to the restaurant's server, which processes the order and sends back the response.
Request-Response Model: The communication between clients and servers typically follows a request-response model. The client sends a request for a particular service, and the server processes the request and sends back a response with the required information. In our restaurant example, you request specific dishes, and the server (restaurant staff) processes your order and prepares the food as per your request.
Stateless: Client-server communication is usually stateless, which means each request is treated independently. The server doesn't remember past interactions with a specific client. For instance, in our restaurant example, each time you place an order, the restaurant staff doesn't remember your previous orders.
Scalability: Client-server architecture allows for easy scalability. If more clients need to access the server simultaneously, it can handle those requests by distributing the workload efficiently.

Examples of client-server architecture in real-life:

Email: Your email client (like Gmail) communicates with the email server to send and receive messages.
Web Browsing: When you visit a website, your web browser acts as the client, and it communicates with the website's server to retrieve and display the web page content.

In the scenario described above, when a client wants to request data from a server, the following steps occur:

The client needs to know the IP address of the particular server it wants to communicate with. To obtain this information, it sends a request to the Domain Name System (DNS) server, providing the domain name of the target server.

The DNS server responds with the IP address associated with the requested domain name.

Armed with the IP address, the client sends its request to the server. The request includes the destination IP address and a specific port number that corresponds to the particular application running on the server that the client wants to communicate with.

The server receives the client's request and processes it.

After processing the request, the server generates a response message.

The response message is then sent back to the client using the IP address and port number specified in the client's request.

The client receives the response packet and extracts the information it needs based on the port number.

At a high level, the communication between the client and server takes place using HTTP packets. HTTP (Hypertext Transfer Protocol) is the protocol that allows the client and server to communicate over the internet and exchange data. It is a standardized set of rules that define how requests and responses should be formatted and handled.

📌Types of Client-Server Architecture

Certainly! Client-server architecture can be categorized into different types based on how the communication and responsibilities are distributed between clients and servers. Here are some common types of client-server architectures:

📍Two-Tier Architecture (Client-Server):
- In this type, the client directly communicates with the server to request services and retrieve data.
- The server handles both the presentation logic (user interface) and the business logic (processing the request and data).
- This architecture is suitable for small-scale applications but may become less scalable as the application grows.
- Example: Traditional client-server applications where a desktop application communicates with a central server to access a database.
📍Three-Tier Architecture:
- In this type, the client interacts with an intermediate layer called the "application server" or "middleware," which acts as a bridge between the client and the database server.
- The three tiers are:
  1. Presentation Tier (Client): Responsible for the user interface and capturing user input.
  2. Application Tier (Middleware): Handles the business logic and processing of requests. It communicates with the database server to retrieve and store data.
  3. Data Tier (Server): This is the database server that stores and manages the data.
- This architecture enhances scalability, as the workload can be distributed between the application server and the database server.
- Example: Web applications where the web browser is the client, the web server is the application server, and the database server stores the data.
📍N-Tier Architecture:
- N-Tier architecture is an extension of the three-tier architecture and allows for more layers or tiers to be added for specific purposes.
- Additional tiers may include security servers, caching servers, load balancers, etc., depending on the complexity and requirements of the application.
- This architecture provides better modularity, flexibility, and performance optimization.
- Example: Large-scale enterprise applications with multiple layers for security, caching, and load balancing.
📍Peer-to-Peer Architecture:
- In this type, there is no distinct differentiation between clients and servers. Each device (peer) can act as both a client and a server, sharing resources and services directly with other peers.
- Peers communicate and collaborate with each other in a decentralized manner.
- This architecture is commonly used in file-sharing applications and collaborative systems.
- Example: BitTorrent, a peer-to-peer file-sharing protocol.
📍Cloud Computing (Service-Oriented Architecture - SOA):
- Cloud computing often uses a service-oriented architecture where clients access services provided by remote servers over the internet.
- Clients interact with cloud services via APIs (Application Programming Interfaces) rather than direct communication.
- Cloud services may encompass various functionalities, like storage, computation, databases, etc.
- Example: Cloud-based platforms like Amazon Web Services (AWS) or Microsoft Azure.

📌Deep Dive into 2-Tier and 3-Tier Architecture🛠️

Sure! Let's delve deeper into both the 2-tier and 3-tier architectures, including their features, advantages, and disadvantages:

✒️2-Tier Architecture (Client-Server):

📍Features:
- Also known as the Client-Server architecture.
- Consists of two main tiers: the client and the server.
- The client is responsible for the user interface and interacts directly with the server to request services and retrieve data.
- The server handles both the presentation logic (user interface) and the business logic (processing the request and data).
- Typically used for small-scale applications with a limited number of users.
📍Advantages:
- Simplicity: 2-tier architecture is relatively simple to implement as it involves only two tiers.
- Performance: Since there is a direct connection between the client and the server, the response time can be faster compared to more complex architectures.
- Low Network Traffic: Communication occurs directly between the client and server, reducing network traffic.
- Easy Maintenance: With fewer components, maintenance and troubleshooting are generally straightforward.
📍Disadvantages:
- Scalability: As the application grows and the number of clients increases, the server may become overloaded, affecting performance.
- Limited Modularity: Lack of separation between presentation and business logic can make the application less modular and harder to maintain.
- Security: Security measures might be limited, as the client directly interacts with the server and could be susceptible to various attacks.
- Data Integrity: The lack of an intermediate tier might lead to data integrity issues if clients directly manipulate data without proper validation.

✒️3-Tier Architecture:

📍Features:
- Consists of three main tiers: presentation tier, application tier (middleware), and data tier (server).
- Presentation Tier (Client): Responsible for the user interface and capturing user input.
- Application Tier (Middleware): Acts as an intermediary between the client and the database server, handling business logic and processing requests.
- Data Tier (Server): Stores and manages the data, and the application tier communicates with it to retrieve or store information.
- Offers better scalability and modularity than 2-tier architecture.
📍Advantages:
- Scalability: The separation of concerns allows for distributing the workload between the application tier and the data tier, enhancing scalability.
- Modularity: Each tier can be developed independently, making it easier to maintain and update the application.
- Improved Security: The application tier can implement security measures independently, reducing potential vulnerabilities.
- Data Integrity: The data tier ensures data consistency and integrity, preventing direct manipulation by clients.
📍Disadvantages:
- Complexity: The additional tier (application tier) introduces more complexity, which can make development and debugging more challenging.
- Performance Overhead: The involvement of an additional tier may introduce some performance overhead due to increased communication between the tiers.
- Higher Costs: Implementing and managing a three-tier architecture can be more expensive than a two-tier one, especially for smaller applications with limited user bases.
- Maintenance Challenges: As the application becomes more complex, maintenance and troubleshooting might require more effort and expertise.

✒️N-Tier Architecture:

Apologies for any confusion earlier. Let me provide a clearer and more detailed explanation of N-Tier Architecture:

✒️N-Tier Architecture:

📍Features:

N-Tier Architecture is a software design pattern that organizes an application into multiple tiers or layers, with each tier responsible for specific functions and having a defined role in the overall system. Unlike the 3-Tier Architecture, which has three main tiers (presentation, application, and data), N-Tier Architecture can have more than three tiers, making it suitable for complex and large-scale applications.

The typical tiers in an N-Tier Architecture are as follows:

Presentation Tier (Client):
- The presentation tier is the user-facing part of the application, where users interact with the system.
- It handles the user interface and captures user input.
- The client can be a web browser, a mobile app, or any other user interface that communicates with the rest of the application.
Application Tier (Middleware):
- The application tier acts as an intermediary between the presentation tier and the data tier.
- It contains the core business logic and processes user requests and actions.
- The application tier handles application-specific functionalities, such as user authentication, session management, and business rules.
Data Tier (Server):
- The data tier is responsible for storing and managing the application's data.
- It handles data storage, retrieval, and manipulation.
- The data tier interacts with databases or other data storage systems to persist and retrieve data required by the application.
Additional Tiers (Optional):
- N-Tier Architecture allows for the inclusion of additional tiers as needed for specific functionalities or requirements.
- These tiers may include specialized components like caching servers, load balancers, search engines, or external APIs.

📍Advantages:

Scalability: The modular nature of N-Tier Architecture allows for horizontal scaling, where additional instances of each tier can be added to handle increased user traffic and demand for resources.
Flexibility: The architecture's separation of concerns enables developers to modify or add tiers based on the application's requirements, allowing for the integration of specialized components for improved performance and functionality.
High Security: By segregating sensitive functions and data into separate tiers, N-Tier Architecture enhances security, limiting access to critical components and reducing the attack surface.
Modularity and Reusability: Each tier can be developed independently and reused across multiple applications, promoting code maintainability, and reducing development time for future projects.

📍Disadvantages:

Complexity: The presence of multiple tiers and interactions between them can make the architecture more complex to design, implement, and debug, requiring skilled developers and careful planning.
Performance Overhead: The communication between tiers may introduce latency and performance overhead due to additional network requests and data transfers, potentially affecting response times.
Cost and Resource Consumption: Implementing and managing multiple tiers can increase development and infrastructure costs, especially for smaller projects with lower user loads.
Deployment Complexity: Deploying, monitoring, and maintaining multiple tiers require more sophisticated processes and tools, which can be challenging for less experienced teams.

📌Let's understand with example

Sure! Let's provide examples for both the 2-tier and 3-tier architectures:

📍2-Tier Architecture (Client-Server):

Example: A Simple Desktop Database Application💻

Imagine you are developing a basic desktop application that allows users to manage their personal contacts. Here's how the 2-tier architecture could be implemented:

Client (Presentation Tier):
- The client is the desktop application's user interface.
- It provides a simple graphical interface for users to add, edit, and view their contacts.
- Users directly interact with the application's forms and buttons to perform tasks.
Server (Business Logic and Data Tier):
- The server is responsible for processing the user's input and managing the contacts data.
- It handles the business logic, such as adding new contacts to the database, retrieving contacts, and updating existing entries.
- The server directly accesses the local database (e.g., SQLite) to store and retrieve contact information.

📍3-Tier Architecture:

Example: E-commerce Website👜

Imagine you are developing an e-commerce website where users can browse products, add items to their cart, and place orders. Here's how the 3-tier architecture could be implemented:

Client (Presentation Tier):
- The client is the user's web browser (e.g., Google Chrome, Mozilla Firefox).
- It communicates with the application server (middleware) to request web pages and display the user interface.
- Users interact with the website's interface to browse products and add items to their cart.
Application Server (Middleware):
- The application server acts as the intermediary between the client and the data tier.
- It handles the business logic, such as processing product searches, managing the shopping cart, and handling user authentication.
- The application server retrieves and sends data to the client as requested and processes user actions.
Data Tier (Server):
- The data tier is the backend server that stores and manages product information, user accounts, and orders.
- It uses a database management system (e.g., MySQL, PostgreSQL) to store and retrieve data.
- The application server communicates with the data tier to retrieve product details, user information, and order history.

In the 3-tier architecture example, the client (web browser) interacts with the application server to request product information and perform actions, and the application server communicates with the data tier to fetch the required data and update the database as necessary. This separation of concerns in the 3-tier architecture allows for better scalability and modularity, making it suitable for handling large-scale e-commerce websites with numerous users and complex interactions.

📍N-Tier Architecture:

Example: Social Media Platform📱

Let's consider the development of a social media platform like Facebook, where users can create posts, comment on them, and connect with others. Here's how the N-tier architecture could be implemented:

Client (Presentation Tier):
- The client is the user's web browser or mobile app, providing an interface for users to interact with the social media platform.
- Users can view their feed, create posts, comment on posts, and perform various other actions through the client.
Web Server (Application Tier):
- The web server acts as the first intermediary in the N-tier architecture.
- It handles the presentation logic for rendering web pages or processing API requests from the client.
- The web server communicates with the application server for complex operations and data retrieval.
Application Server (Middleware):
- The application server is responsible for the core business logic and application-specific functionalities.
- It handles user authentication, manages user connections, processes posts and comments, and implements privacy settings.
- The application server interacts with the database server for data retrieval and storage.
Database Server (Data Tier):
- The database server is where all the data for the social media platform is stored.
- It manages user profiles, posts, comments, friend connections, and other relevant information.
- The database server is accessed by the application server to perform read and write operations on the data.
Storage Tier (Optional):
- In some cases, a storage tier may be introduced to handle large-scale media storage, such as images and videos uploaded by users.
- This tier may use specialized distributed storage systems like Amazon S3 or a content delivery network (CDN) for media delivery.

In the N-tier architecture example, the client interacts with the web server to request web pages or API services. The web server processes simple requests and forwards more complex tasks to the application server. The application server handles business logic, user management, and interacts with the database server to store and retrieve data. Optionally, a storage tier can handle media storage, making the platform more scalable for large volumes of multimedia content.

Until next time😃. Happy learning.
If you liked the article, do like😊.

Modules📤📥 in Node.js : Beginner to Advance💻

tanishmohanta — Thu, 20 Jul 2023 19:16:51 +0000

Both Browser's javascript (ECMAScript Modules (ESM)) and Node.js's javascript support modules, but there is a difference in syntax. After reading and gaining insightful knowledge about modules in node.js, you can read difference between them.

So, let's get started😃.

✒️Modules : Definition

Modules enable you to structure and contain your code within distinct files and folders, enhancing its organization and reusability. By employing modules, you can break down your application into smaller units, each serving a specific purpose. These units can then be integrated to construct a comprehensive and functional application. They are, in Node.js are fundamental components that play a crucial role in this JavaScript runtime, utilizing Chrome's V8 engine.

In simple language, We can use functionality of one file into another file, and vise versa.

✒️Types of Modules in Node.js :

Core Modules: These are built-in modules provided by Node.js, which can be used without requiring any additional installation. Examples include fs (file system), http (HTTP server and client), os (operating system), and more.
Local Modules: These are modules you create within your application. They are usually organized into separate files and folders to keep the codebase clean and maintainable.
Third-party Modules: These are modules created by the Node.js community and available through the Node Package Manager (NPM). NPM is a package manager that allows developers to share and reuse code easily. You can use third-party modules in your projects by installing them using NPM.

📤Exporting from a Module:

To make functions, variables, or classes available from a module to other parts of your application, you need to export them. Node.js provides different ways to export items from a module:

Named Exports: Export individual items one by one using exports or module.exports.
Default Export: Export a single item (typically an object or a function) as the default export using module.exports.

Note : We will see named and default exports in later part of this tutorial.

📥Importing a Module:

To use functionality from other modules in your current module, you need to import them. Node.js provides the require() function to import modules:

Core Modules: Imported without any path (e.g., const fs = require('fs')).
Local Modules: Imported using relative paths (e.g., const myModule = require('./myModule')).
Third-party Modules: Imported just like local modules if they are installed using NPM.

Too much theory😅!!!!!, Let's understand with example😃.

Step 1: Create the module

Create a new file named mathCalOperations.js:

// mathCalOperations.js

//ARROW FUNCTION
const add = (a, b) => {
  return a + b;
};

//NORMAL FUNCTION
function subtract(a, b) {
  return a - b;
};
//BOTH STYLE ARE ACCEPTABLE

const multiply = (a, b) => {
  return a * b;
};

const divide = (a, b) => {
  if (b === 0) {
    throw new Error('Divide by zero error, Cannot divide by zero!');
  }
  return a / b;
};

const PI = 3.14159;

module.exports = {
  add,
  subtract,
  multiply,
  divide,
  PI,
};

In this module, we have separate functions add, subtract, multiply, and divide, along with a constant PI.

Step 2: Import and use the module

Create a new file named app.js:

// app.js
const cal = require('./mathCalOperations');

const num1 = 10;
const num2 = 5;

console.log(`Addition: ${cal.add(num1, num2)}`);
console.log(`Subtraction: ${cal.subtract(num1, num2)}`);
console.log(`Multiplication: ${cal.multiply(num1, num2)}`);

try {
  console.log(`Division: ${cal.divide(num1, num2)}`);
} catch (error) {
  console.error(error.message);
}

console.log(`Value of PI: ${cal.PI}`);

In this file, we use the require() function to import the mathCalOperations.js module. We call the functions add, subtract, multiply, and divide to perform arithmetic operations on the numbers num1 and num2, and we also access the constant PI.

Step 3: Run the application

Save both files in the same directory and run app.js using Node.js:

$ node app.js

Output :

Addition: 15
Subtraction: 5
Multiplication: 50
Division: 2
Value of PI: 3.14159

The mathCalOperations.js module is successfully imported into app.js, and we used its separate functions and the constant PI to perform mathematical operations and access the value of PI.
This example demonstrates how to create a module with separate functions and variables, export them using module.exports, and import and use them in another JavaScript file using require().

At the end, we are returning an object { }as there are many functions and variable, object is a best way to combine (you can also use class).

What if you write a object and return it.

So we can above program like this.

// mathCalOperations.js
const cal = {
    add: (a, b) => {
    return a + b;
  },
  subtract: (a, b) => {
    return a - b;
  },
  multiply: (a, b) => {
    return a * b;
  },
  divide: (a, b) => {
    if (b === 0) {
      throw new Error('Divide by zero error, Cannot divide by zero!');
    }
    return a / b;
  },
};

module.exports = cal;

Here, We are making object from start and returning it, while in previous one, We were making object{} at end.

📍Note : Module.exports is an object.
It is a special object used to define what a module exports, i.e., what functionalities or data it makes available to other parts of the application.
If you send just a function or a variable in Node.js using module.exports, it will work perfectly fine. In Node.js, module.exports can hold any value, not just objects.
So, module.exports is an object, and with it we can send any type.

So, Here we end😃.
In, 📤Exporting from a module section, We left Named and Default exports.
Let's continue that.

📌Named Exports:

Named exports allow you to export multiple items (functions, variables, or classes) from a module and import them individually by their names in other parts of your application. When you use named exports, you explicitly specify which items you want to make available for importing.

mathCalOperations.js:

// mathCalOperations.js
const add = (a, b) => {
  return a + b;
};

const subtract = (a, b) => {
  return a - b;
};

module.exports.add123 = add;
module.exports.subtract123 = subtract;

In this example, we have two functions add and subtract in the mathCalOperations.js module. We export them using the module.exports object with the property names add and subtract. This makes the functions individually accessible when importing the module in another file.

app.js:

// app.js
const cal = require('./mathCalOperations');

const num1 = 10;
const num2 = 5;

console.log(`Addition: ${cal.add123(num1, num2)}`);
console.log(`Subtraction: ${cal.subtract123(num1, num2)}`);

In app.js, we import the mathCalOperations.js module and store it in the cal variable. We can then access the exported functions add and subtract using cal.add123() and cal.subtract123() respectively.

📌Default Export:

A default export allows you to export a single item (usually an object, a function, or a class) as the main export of the module. When using a default export, you can import the item using any name you want, making it more flexible when importing.

greeting.js:

// greeting.js
const greet = (name) => {
  return `Hello, ${name}!`;
};

module.exports = greet;

app.js:

// app.js
const customGreeting = require('./greeting');

const name = 'John';
console.log(customGreeting(name));

In app.js, we import the greeting.js module and store the default exported function in the variable customGreeting. Since it is a default export, we can give it any name we want. We then call the function using customGreeting(name) to get the greeting message.

The first example of this tutorial, above at top is also an example of Default Export.

It's not the end, I will add few more about it, later in future😊.

Happy Learning!! , Until next time🫂.
If you liked the article, do hit like😃.

Security🔐 Concerns with Cookies🍪.

tanishmohanta — Wed, 19 Jul 2023 04:18:28 +0000

What actually cookie is Here
Cookies are small pieces of data stored in a user's browser by a website to remember certain information about the user or track their activities. Though cookies are generally secure when implemented correctly, there are some security concerns associated with them. Let's explore these security concerns in detail:

🔏Man-in-the-Middle (MitM) Attacks:

In a MitM attack, a malicious actor positions themselves between the user's browser (the client) and the web server. This allows the attacker to intercept and view the communication between the two parties. If the communication is not encrypted, the attacker can read sensitive data, including cookies, transmitted between the client and server.

Source: MITH

Mitigation:

To protect against MitM attacks, websites should enforce the use of HTTPS (HTTP Secure) for all data transmission. HTTPS encrypts the data exchanged between the client and server, making it extremely difficult for attackers to read or modify the information, including cookies.

So, developers should ensure that cookies containing sensitive information or authentication tokens have the Secure attribute set. When the Secure attribute is present, the browser will only send the cookie over an encrypted HTTPS connection, preventing its exposure over unsecured HTTP connections.

Example:

document.cookie = 'dark_mode=false; Secure';

🔏Cross-Site Scripting (XSS) Attacks:

XSS attacks occur when an attacker injects malicious scripts into a website that is viewed by other users. The injected scripts execute within the context of the victim's browser, allowing the attacker to steal cookies, session information, or perform unauthorized actions on the user's behalf.

Source: XSS

Mitigation:

Developers must adopt strict input validation and output encoding practices to prevent XSS vulnerabilities. Any user-provided data displayed on the website should be thoroughly sanitized to prevent malicious scripts from being executed.

To minimize the impact of XSS attacks on cookies, the HttpOnly attribute should be used. By adding HttpOnly, the cookie can only be accessed by the server-side code and not by JavaScript running in the user's browser. This prevents malicious scripts from stealing cookie data using the Document.cookie API.

Example:

document.cookie = 'dark_mode=false; Secure; HttpOnly';

🔏Cross-Site Request Forgery (CSRF) Attacks:

CSRF attacks involve tricking a user's browser into unknowingly making an unintended request to a different website where the user is authenticated. If the user is logged in to the targeted website, the request will be executed with their credentials, leading to potential account compromise or unauthorized actions.

Source: CSRF

Mitigation:

To defend against CSRF attacks, developers should implement CSRF tokens in their web applications. These tokens are unique for each user session and should be included in all requests that perform sensitive actions, such as changing account settings or making transactions. The server then validates the token to ensure that the request is legitimate and not an attempt to exploit CSRF vulnerabilities.

Moreover, the SameSite attribute can be used with cookies to mitigate CSRF risks. By setting SameSite=Strict, the browser ensures that cookies are only sent to the same site from which they originated, reducing the chances of unauthorized requests from other domains.

Example:

document.cookie = 'dark_mode=false; Secure; HttpOnly; SameSite=Strict';

Alternatives to Cookies:

While cookies have been widely used for storing user information, modern web development offers alternative approaches:

📌SessionStorage and LocalStorage: These are client-side storage mechanisms that allow developers to store data within the user's browser. Unlike cookies, these storages are limited to the current browser tab or window and are not sent to the server with each request. While useful for certain use cases, they lack server-side validation and are not suitable for managing user authentication.
📌Token-Based Authentication (e.g., JWT): Token-based authentication provides a more secure way to manage user sessions and authentication. When a user logs in, the server generates a unique token containing user information and signs it cryptographically. The token is then sent to the client and included in subsequent requests. This approach eliminates the need for cookies to manage user sessions and provides better security against various attacks.

Happy Learning!! , Until next time🫂.
If you liked the article, do hit like😃.

Cookie🍪 : Deep Dive in cookies💻

tanishmohanta — Tue, 18 Jul 2023 21:06:43 +0000

Let's start from beginning. You know browser has javascript engine, where we execute our javascript code, apart from this browser also have many things like Storage, fetch() Api, console.log(), DOM Api(all event listener, getElementById etc.), setTimeOut(), Locations and many more(Ya! you got it right, these things are not javascript, these are browsers things. These functionalities are browser features that are accessed through APIs).One of the feature which is provided by browser is Storage(Ya! browser has its own storage which we can use in javascript code using Api's).

Browser has many types of storage namely Local Storage, Session Storage, Cookies, IndexedDB, Web SQL Database (Deprecated), Cache API, Web Storage API (Deprecated) etc.

You can see here.

You can see here, for storing data there are many types of Storage and one of it is cookies.

✒️Let's see what Cookie🍪 Storage is 😃😁 ...

Definition : Cookies are small pieces of data stored by websites on a user's web browser. They are commonly used to store information about the user's preferences, session state, and other data related to their interactions with a website.

So, It's used to store small data.

✒️Which type of data 🤔???.

We can store anything, but everything has purpose in this world. This Cookie storage is used to store specifically browsing data, session data, user behavior etc.

✒️Let's see an example😊.

You went a Travelling website "X". At start it will ask you to sign in/sign up. You logged in( means at back, it will send request to browser and will get a response related to log in(success/not success)). The response which website X's server sent back to website for successful login will also contain a data(cookie) with it (in response's header), which will be stored in Cookie Storage in yours browser.

This session cookie enables the website to maintain you the logged-in state throughout the Travelling booking process.
Means as you navigates through features in website or different pages in website, it will not ask every time Log in/Sign up.
It will use the cookie here, to identify that its the same user(you).

So, Here you saw how cookie helps in user to stay logged-in across different pages in a website..

There are many more things like User Tracking ,personalization, Advertisement(how you see Ads specific to your interest) etc, We will see in later part.
Let's first see cookie's features.

✒️How cookie looks 🤔🤔🤔...

Let's Zoom in🔍.

Ya! you saw right😁. cookie are stored name=value pair.

🍪Structure

A cookie is represented as a key-value pair, where the key is the name of the cookie, and the value is the data associated with it. Cookies also have attributes such as expiration date, domain, and path, which provide additional control over how the cookies are used and accessed.

Zoom in 🔍the above to above image...

These are the attributes of cookies.

✒️Let's see one by one😃.

expires: Specifies the expiration date of the cookie. Once the expiration date is reached, the cookie will be automatically deleted by the browser.
domain: Specifies the domain for which the cookie is valid. By default, cookies are valid for the domain that set them. You can set any domain to which you want to keep the cookies.
path: Specifies the URL path for which the cookie is valid. By default, cookies are valid for the entire domain.
secure: If set to true, the cookie will only be sent over secure HTTPS connections.
httponly: If set to true, the cookie will be inaccessible to JavaScript, reducing the risk of certain types of attacks like XSS.

OH!! Lot's of theory. Let's implement 💻and create a cookie🍪.

NOTE: There are many other ways to add cookies and many other library with which we can set cookie. This is simplest way to add cookie.

🍪Setting a Cookie:

document.cookie = 'username=John; expires=Thu, 17 Jul 2025 12:00:00 UTC; path=/';

First we write a cookie name and value, then after semicolon attributes. If want to add more attributes give semcolon then add.
Yo, cookie is set.

Zoomed in🔍.

Add one more cookie.

document.cookie = 'product=dairy';

It will not replace the previous one, it will add next cookie (no need of +=).

Ok, So you learned how to add a cookie. In second example, you just added a cookie, no attributes. In this case, in expires section it will set to session which means that as soon as you close the browser(click on red cross button), the second cookie will expire because it is for this session only.

🍪Getting Cookies:

const allCookies = document.cookie;
console.log(allCookies);

Above code illustrates, If all cookies are get printed.

function getCookie(cookieName) {
  const cookies = document.cookie.split(';');
  for (let i = 0; i < cookies.length; i++) {
    const cookie = cookies[i].trim();
    if (cookie.startsWith(cookieName + '=')) {
      return cookie.substring(cookieName.length + 1);
    }
  }
  return null; // Return null if the cookie is not found
}

Pass cookie name in function.

const myCookieValue = getCookie('your_cookie_name');
if (myCookieValue) {
  console.log('Value of "your_cookie_name":', myCookieValue);
} else {
  console.log('Cookie not found.');
}

Above code illustrates, If you want a specific cookie value.

🍪Removing a Cookie:

The basic way to remove a cookie is to set to previous date which has passed.

document.cookie = 'username=; expires=Thu, 01 Jan 1970 00:00:00 UTC; path=/;';

✒️Some important points to note.

Cookies can have an expiration date, after which they will be automatically deleted by the browser.

Cookies without an expiration date are called session cookies and are deleted when the user closes the browser.

Cookies are specific to a domain. Each domain can set and access its own cookies, and one website cannot access cookies set by another website due to the same-origin policy, which enhances security.

Cookies are accessed through the document.cookie property in JavaScript. This property contains a string representation of all the cookies associated with the current domain.

Let's conclude by writing a complete code.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
  <div id="box">
    Here data will be there.
  </div>
  <button id="btn">click</button>

  <script>
    // Function to set the cookie with all the options
    function setCookie(name, value, domain, path, expiration, secure, httpOnly, sameSite) {
      let cookieOptions = `${name}=${encodeURIComponent(value)}`;

      if (domain) {
        cookieOptions += `; Domain=${domain}`;
      }

      if (path) {
        cookieOptions += `; Path=${path}`;
      }

      if (expiration) {
        const expirationDate = new Date(expiration * 1000).toUTCString();
        cookieOptions += `; Expires=${expirationDate}`;
      }

      if (secure) {
        cookieOptions += `; Secure`;
      }

      //if (httpOnly) {
        //cookieOptions += `; HttpOnly`;
      //}

      if (sameSite) {
        cookieOptions += `; SameSite=${sameSite}`;
      }

      document.cookie = cookieOptions;
      console.log(document.cookie);
    }

    // Example usage
    const userPreferences = { theme: "dark", language: "en", showNotifications: true };
    const encodedPreferences = JSON.stringify(userPreferences);

    // Set the cookie for localhost (Empty string for domain)
    setCookie(
      "user_preferences_cookie",
      encodedPreferences,
      "",
      "/",
      1697171200,//till 13/10/2023 9:56:40 AM
      true,     // Set to true for "Secure" attribute
      true,     // Set to true for "HttpOnly" attribute
      "Strict"
    );
  </script>
</body>
</html>

Output :

Zoom in🔍

In console :

This example demonstrates how to create a cookie with multiple options for localhost http://127.0.0.1/ => "" website ". The cookie named "user_preferences_cookie" stores user preferences in JSON format and is set to expire on 13/10/2023. Additionally, the SameSite attribute is set to "Strict", ensuring that the cookie is sent only in first-party contexts.

✒️Advantages

Persistence: Cookies persist across different browser sessions and can be used to remember user preferences and maintain session state.
Client-Side Storage: Cookies are stored on the client-side, reducing the need for frequent server-side communication for certain types of data.
Simple API: The document.cookie property provides a simple way to interact with cookies, making them accessible to developers of all skill levels.

✒️Disadvantages

Size Limit: Cookies are limited in size (usually 4 KB per cookie and a total limit of around 300 cookies per domain), which can be a limitation for storing larger amounts of data.
Sent with Every Request: Cookies are sent with every HTTP request to the domain they belong to, which can add some overhead, especially if a website has many cookies.
Security Concerns: As cookies are accessible by JavaScript on the client-side, they can be susceptible to certain security risks, such as Cross-Site Scripting (XSS) attacks or Cross-Site Request Forgery (CSRF) attacks if not used and secured properly.
Limited to String Data: Cookies can only store data in string format. Complex data types like objects and arrays need to be serialized into strings before storage, which can add complexity to the code.

✒️Who actually sets Cookies??🤔🤔

Cookies are typically set by web servers and sent to the user's web browser during HTTP responses. When a user visits a website, the web server can include a "Set-Cookie" header in the HTTP response to instruct the browser to create and store a cookie on the user's device.

The "Set-Cookie" header contains the necessary information to create the cookie, including its name, value, attributes (e.g., expiration date, domain, path, etc.), and other optional settings like security attributes (Secure and HttpOnly). Once the browser receives the "Set-Cookie" header, it creates the cookie and stores it locally on the user's device as instructed by the server.

For example, when a user logs into a website, the server may respond with the following "Set-Cookie" header to create a session cookie:
Set-Cookie: session_id=abc123; path=/; HttpOnly
In this example, the server instructs the browser to create a session cookie named "session_id" with the value "abc123." The cookie is set to be accessible only via HTTP (HttpOnly) and is valid for all paths on the website (path=/).

Once the cookie is set, the browser will automatically include the cookie in subsequent HTTP requests to the same domain. This allows the server to identify the user and maintain session state, personalization, and other relevant information.

It's important to note that certain types of cookies, such as HttpOnly cookies, can only be set by the server and cannot be accessed or modified by client-side JavaScript. This enhances security by preventing certain types of attacks, like Cross-Site Scripting (XSS), from accessing sensitive cookie data.

So concluding, Web servers set cookies to provide a way to store information on the user's browser, enabling stateful interactions between the user and the website and enhancing the overall user experience.

✒️What happens after a Cookie🍪 is set, and How it saves data and tracks user interactions🤔🤔

After a cookie is set and stored on the user's browser, it becomes part of the user's browsing experience, and its data and behavior depend on the attributes and settings defined when the cookie was created.

Here's what happens after a cookie is set, and how it saves data and tracks user interactions:

📍Subsequent Requests:
As the user continues to interact with the website or moves to different pages within the same domain, the browser automatically includes the cookie in the headers of all subsequent HTTP requests to that domain.

For example, if the website has a navigation menu or loads additional resources, like images or scripts, the browser sends the cookie information along with each request to the server.

📍Retrieving Data:
When the browser includes the cookie in an HTTP request, the server can access the cookie data and use it to identify the user and maintain session state.

For example, if the server set a session cookie with a user's unique session ID, it can retrieve the session ID from the cookie in subsequent requests to identify the user and provide personalized content or access to restricted areas of the website.

📍Session Management:
Session cookies are often used to manage user sessions. When the user logs into a website, the server sets a session cookie, and subsequent requests include the session cookie to maintain the user's login status.

The server can use the session cookie data to determine if the user is logged in and provide access to authenticated features.

📍User Tracking and Personalization:
Persistent cookies are commonly used to track user preferences and behaviors across different visits to the website. This tracking helps websites offer personalized content and recommendations to users based on their previous interactions.

For example, if a user visits an online store and adds items to their cart without making a purchase, the website might use a persistent cookie to remember the user's cart contents when they return later.

📍Expiry and Deletion:
If a cookie has an expiration date, the browser will automatically delete the cookie after that date is reached. This allows for time-limited functionality or data storage.

For example, a website might use a persistent cookie to remember a user's language preference for a year, while a session cookie might only be valid for the duration of the browsing session.

📍Security Considerations:
Secure and HttpOnly attributes in cookies enhance security. Secure cookies are only sent over HTTPS connections, ensuring that sensitive data is encrypted during transmission. HttpOnly cookies are inaccessible to client-side JavaScript, protecting against certain types of attacks like XSS.

✒️Types of Cookies🍪

📌Session Cookies:

Session cookies are temporary cookies that are stored in the browser's memory and are only active during a browsing session. They are typically used to remember user preferences or track the user's activities within a single session. Once the user closes the browser, session cookies are deleted.

Example: Shopping Cart
When a user adds items to their shopping cart on an online store, session cookies can be used to keep track of the items during their browsing session. Once the user completes their purchase or leaves the website, the session cookies are deleted, clearing the shopping cart.

📌Persistent Cookies:

Persistent cookies, also known as permanent cookies, are stored on the user's device even after the browser is closed. They have an expiration date set by the website and remain on the user's device until that date or until the user manually deletes them. Persistent cookies are used for long-term data storage, such as remembering login information or user preferences across multiple sessions.

Example: "Remember Me" Option
On a website's login page, users may have the option to check a "Remember Me" box. If they select this option, a persistent cookie is set with their login credentials. This allows them to stay logged in even after they close the browser or revisit the website at a later time.

📌First-party Cookies:

First-party cookies are set by the website domain that the user is directly visiting. These cookies are used to improve the user experience on that specific website, remember user preferences, and store session-related information.

Example: User Preferences
A website may use first-party cookies to remember a user's preferred theme (e.g., light or dark mode), font size, or language selection, providing a personalized experience for the user during their visit.

📌Third-party Cookies:

Third-party cookies are set by domains other than the one the user is directly visiting. These cookies are usually created by third-party services (such as advertising or analytics providers) that are embedded in the website the user is browsing. Third-party cookies are often used to track users across multiple websites and gather data for advertising and analytics purposes.

Example: Advertising Tracking
When a user visits a website that displays ads from an advertising network, the website may use third-party cookies to track the user's browsing behavior across different websites. This data is used to serve targeted ads based on the user's interests and activities.

📌Secure Cookies:

Secure cookies are cookies that are transmitted over HTTPS instead of HTTP. They are encrypted and provide an extra layer of security, ensuring that the data stored in the cookie is less susceptible to interception by malicious entities.

Example: Secure Login
For websites that handle sensitive information like online banking or personal data, secure cookies are used to store session identifiers securely. These cookies are transmitted over HTTPS, making it difficult for attackers to intercept and tamper with the cookie data.

📌HttpOnly Cookies:

HttpOnly cookies are designed to be inaccessible through client-side scripts (e.g., JavaScript). They can only be accessed and modified by the server, which helps mitigate the risk of cross-site scripting (XSS) attacks.

Example: Authentication Tokens
HttpOnly cookies are commonly used for storing authentication tokens. When a user logs in to a website, the server sets an HttpOnly cookie containing the authentication token. This prevents malicious scripts from accessing the token and helps protect against cross-site scripting (XSS) attacks.

📌SameSite Cookies:

SameSite cookies define whether a cookie should be sent with cross-origin requests. This attribute helps prevent certain types of CSRF (Cross-Site Request Forgery) attacks. SameSite cookies can have three possible values: "Strict," "Lax," or "None."

Example: CSRF Prevention
Websites often use SameSite cookies to prevent Cross-Site Request Forgery (CSRF) attacks. By setting SameSite attributes to "Strict" or "Lax," the website ensures that the cookie is not sent in cross-origin requests, making it harder for attackers to initiate unauthorized actions on behalf of the user.

📌Flash Cookies (Local Shared Objects):

Flash cookies are not related to traditional web browser cookies but serve a similar purpose in Flash applications. These cookies are stored by Adobe Flash Player and can track user preferences and data across different Flash-based websites.

Example: Flash Game Progress
In Flash-based games or applications, Flash cookies can be used to store game progress, user preferences, and other data locally. This allows users to resume their game from where they left off, even if they close the browser or visit the website on a different device.

Happy Learning!! , Until next time🫂.
If you liked the article, do hit like😃.

Security concerns with Cookies. Here
How you see Ads personalized to you on a website ?🤔How cookies Help Google Ads to make view you your personalized Ads ?Here

DEV Community: tanishmohanta

Joins in SQL

TCP/IP Network Model💻 : Deep Dive with an example

Let's understand with an example😃.

Journey Through the Digital Highway🗺️: How Data Travels From Your Laptop💻 to Your Friend's Laptop🙋‍♂️: Deep Dive.

📌Here's the explaination of the data transfer🗺️:

Client-Server Architecture🤝 : Deep Dive

📌Types of Client-Server Architecture

📌Deep Dive into 2-Tier and 3-Tier Architecture🛠️

📌Let's understand with example

Modules📤📥 in Node.js : Beginner to Advance💻

✒️Modules : Definition

✒️Types of Modules in Node.js :

📤Exporting from a Module:

📥Importing a Module:

📌Named Exports:

📌Default Export:

Security🔐 Concerns with Cookies🍪.

🔏Man-in-the-Middle (MitM) Attacks:

🔏Cross-Site Scripting (XSS) Attacks:

🔏Cross-Site Request Forgery (CSRF) Attacks:

Alternatives to Cookies:

Cookie🍪 : Deep Dive in cookies💻

✒️Let's see what Cookie🍪 Storage is 😃😁 ...

✒️How cookie looks 🤔🤔🤔...

🍪Structure

🍪Setting a Cookie:

🍪Getting Cookies:

🍪Removing a Cookie:

✒️Advantages

✒️Disadvantages

✒️Who actually sets Cookies??🤔🤔

✒️What happens after a Cookie🍪 is set, and How it saves data and tracks user interactions🤔🤔

✒️Types of Cookies🍪

Security concerns with Cookies. Here

How you see Ads personalized to you on a website ?🤔How cookies Help Google Ads to make view you your personalized Ads ?Here