Node.js Architecture | Backend Mastery with Node.js 🚀 | In Hindi | Death Code

Node.js Architecture

Node.js is built on a non-blocking, event-driven architecture that makes it lightweight and efficient. It is designed to build scalable network applications. The architecture of Node.js can be broken down into several key components:

1. Event Loop

The event loop is the core of Node.js architecture. It allows Node.js to perform non-blocking I/O operations by offloading operations to the system kernel whenever possible. The event loop continuously checks for events and executes the corresponding callback functions.

2. Single Threaded

Node.js operates on a single-threaded model, which means it uses a single thread to handle multiple connections. This is achieved through the event loop, which allows Node.js to handle many connections simultaneously without creating a new thread for each connection.

3. Non-Blocking I/O

Node.js uses non-blocking I/O operations, which means that operations like reading files, querying databases, or making network requests do not block the execution of the program. Instead, Node.js continues executing other code while waiting for the I/O operation to complete.

4. Callbacks

Callbacks are functions that are passed as arguments to other functions and are executed after a certain event occurs. In Node.js, callbacks are commonly used to handle asynchronous operations.

5. Event Emitters

Node.js has a built-in module called EventEmitter that allows objects to emit events and listen for those events. This is a key part of the event-driven architecture.

6. Modules

Node.js uses a module system that allows developers to break their code into reusable components. Each module can export its functionality and import other modules as needed.

Blocking vs Non-Blocking Code

In Node.js, understanding the difference between blocking and non-blocking code is crucial for writing efficient applications.

Blocking Code

Blocking code is code that stops the execution of further code until the current operation is completed. This can lead to performance issues, especially in a web server context where multiple requests need to be handled simultaneously.

Example of Blocking Code:

// Blocking Code
console.log("start"); // Output: start
let date = Date.now();
while (Date.now() - date < 3000) {
    // Simulating a blocking operation
    // console.log("wait..."); // Uncomment to see the wait message
}
console.log("process completed"); // Output: process completed

In this example, the program will log "start", then enter a blocking loop for 3 seconds, and finally log "process completed". During this time, no other code can execute.

Non-Blocking Code

Non-blocking code allows the program to continue executing while waiting for an operation to complete. This is essential for building responsive applications.

Example of Non-Blocking Code:

// Non-Blocking Code
console.log("start non blocking"); // Output: start non blocking
setTimeout(() => {
    console.log("Process Completed"); // Output: Process Completed (after 3 seconds)
}, 3000);
console.log("hello js"); // Output: hello js

In this example, the program logs "start non blocking", then sets a timer for 3 seconds. While waiting for the timer, it immediately logs "hello js". After 3 seconds, it logs "Process Completed". This demonstrates how non-blocking code allows other operations to continue executing while waiting for a time-consuming task to finish.

Conclusion

Understanding the architecture of Node.js and the difference between blocking and non-blocking code is essential for developing efficient applications. By leveraging the event-driven, non-blocking nature of Node.js, developers can create scalable and high-performance applications that handle multiple requests simultaneously.

Thank you for following along with this Node.js tutorial series! Stay tuned for more advanced topics and practical examples.