“What is this article going to be exactly?”

This article is going to explore the inner workings of Node.js, including its event-driven, non-blocking I/O model and its use of the V8 JavaScript engine. We will also dive into topics such as the event loop, libuv, and the Node.js runtime environment to give readers a comprehensive understanding of what happens under the hood when Node.js runs their code.

“Why is it important to understand what happens under the hood?”

Understanding what happens under the hood of Node.js can help developers write more efficient and performant code. It can also help them diagnose and fix issues that may arise in their applications. Additionally, having a deeper understanding of Node.js can enable developers to better utilize its capabilities and build more robust applications.

Plus, for those who don't really care too much but are still curious, stay tuned!

“Alright, let’s get started then! I hope this will finally make me a 10x Dev (maybe)”

"What is Node.js exactly?"

Node.js is a JavaScript runtime environment that allows developers to run JavaScript code outside of a web browser. Node.js is built on top of the V8 JavaScript engine, which is the same engine that powers Google Chrome and other Chromium-based browsers. V8 is responsible for compiling and executing JavaScript code, as well as providing access to some low-level features such as memory management and garbage collection. Node.js is also known for its event-driven, non-blocking I/O model, which enables high scalability and performance for applications that handle a large number of concurrent requests. Node.js uses a single-threaded event loop to handle asynchronous operations, such as reading from a file, querying a database, or making an HTTP request. The event loop delegates these operations to the libuv library, which provides cross-platform support for I/O, networking, threading, and other features. Libuv uses a thread pool to execute these operations in parallel, and then returns the results to the event loop, which in turn invokes the corresponding callback functions.

"Now what is Node.js runtime environment?"

The Node.js runtime environment is the set of features and modules that Node.js provides on top of the V8 engine and the libuv library. The Node.js runtime environment enables developers to build various types of applications using JavaScript, such as web servers, command-line tools, desktop applications, and more.

The Node.js runtime environment consists of:

• Global objects: Node.js provides some global objects that are available in all modules, such as global, process, console, Buffer, and require. These objects provide access to some basic features and functions, such as the global namespace, the current process information, the standard input and output streams, the binary data manipulation, and the module loading system.
• Core modules: Node.js provides some core modules that are built into the binary and can be loaded using the require function, such as fs, http, crypto, os, and path. These modules provide access to some common and essential features and functions, such as the file system operations, the HTTP server and client, the encryption and decryption algorithms, the operating system information, and the path manipulation.
• Native modules: Node.js also provides some native modules that are written in C or C++ and can be loaded using the require function, such as zlib, buffer, util, and events. These modules provide access to some low-level and advanced features and functions, such as the compression and decompression algorithms, the buffer manipulation, the utility functions, and the event emitter pattern.
• External modules: Node.js also supports external modules that are written in JavaScript or other languages and can be installed using a package manager, such as npm or yarn. These modules provide access to a wide range of features and functions, such as web frameworks, database drivers, testing tools, and more. Some popular external modules are express, mongoose, jest, and lodash.

The Node.js runtime environment is what makes Node.js a versatile and powerful platform for building applications. However, it also requires a good understanding of how Node.js works internally and how to use its features and modules effectively.

"What about the V8 JavaScript engine?"

The V8 JavaScript engine is a high-performance and open-source engine that compiles and executes JavaScript code. V8 was originally developed by Google for its Chrome browser, but it is also used by Node.js and other applications that need to run JavaScript.

V8 has several features that make it fast and efficient, such as:

• Just-in-time (JIT) compilation: V8 does not interpret JavaScript code, but instead compiles it into native machine code at runtime. This allows V8 to optimize the code based on the current execution context and the available hardware resources.
• Adaptive optimization: V8 uses various techniques to improve the performance of the compiled code, such as inline caching, which reduces the overhead of property access, hidden classes, which enable fast object creation and modification, and on-stack replacement, which allows switching between optimized and unoptimized code without losing the execution state.
• Garbage collection: V8 manages the memory allocation and deallocation of JavaScript objects automatically, using a generational and incremental garbage collector. This means that V8 divides the memory into two regions: the young generation and the old generation. The young generation contains newly created objects, while the old generation contains long-lived objects. V8 performs frequent and fast garbage collection in the young generation, and less frequent but more thorough garbage collection in the old generation. V8 also performs garbage collection in small chunks, to avoid blocking the main thread for too long.

V8 provides Node.js with a powerful and fast JavaScript engine, but it also imposes some limitations, such as:

• Single-threaded execution: V8 runs JavaScript code in a single thread, which means that only one task can be executed at a time. This can lead to performance issues if the code contains long-running or blocking operations, such as CPU-intensive calculations or synchronous I/O. To overcome this limitation, Node.js uses the event loop and libuv to handle asynchronous operations in a non-blocking way.
• Memory constraints: V8 has a fixed memory limit for each instance of the engine, which is determined by the architecture of the system (64-bit or 32-bit). For example, on a 64-bit system, V8 can allocate up to 1.4 GB of memory for each instance. This can limit the amount of data that Node.js can process in memory, especially for applications that deal with large files or buffers. To overcome this limitation, Node.js provides streams and buffers to handle data in chunks, rather than loading it all into memory at once.

"What is the event loop?"

The event loop is the core mechanism that enables Node.js to handle asynchronous operations in a single-threaded way. The event loop is responsible for managing the execution of JavaScript code, as well as coordinating the communication between the V8 engine and the libuv library.

The event loop runs in an infinite loop, constantly checking for new events to process. An event can be anything that triggers a callback function, such as an I/O operation, a timer, a signal, or a user interaction. The event loop maintains a queue of events, which are added by libuv whenever an asynchronous operation is completed or a new event occurs. The event loop also maintains a stack of JavaScript functions, which are executed one by one in a sequential order.

The event loop works as follows:

• The event loop starts by executing the main module of the Node.js application, which is usually the entry point of the program. The main module may contain some synchronous code, such as variable declarations, function definitions, or console logs. The main module may also contain some asynchronous code, such as calling an I/O function, setting a timer, or registering an event listener. These asynchronous operations are delegated to libuv, which handles them in the background using its thread pool and other features. The main module then returns control to the event loop.
• The event loop then checks if there are any pending timers that have expired, such as those created by setTimeout or setInterval. If there are any, the event loop executes the corresponding callback functions and removes them from the queue.
• The event loop then checks if there are any pending I/O callbacks, such as those created by fs.readFile, http.request, or process.nextTick. If there are any, the event loop executes the corresponding callback functions and removes them from the queue.
• The event loop then checks if there are any pending idle or prepare callbacks, which are used internally by Node.js for performance optimization. If there are any, the event loop executes the corresponding callback functions and removes them from the queue.
• The event loop then checks if there are any pending poll events, which are events that are ready to be processed by the application, such as data coming from a socket, a file descriptor becoming available, or a signal being received. If there are any, the event loop executes the corresponding callback functions and removes them from the queue.
• The event loop then checks if there are any pending check callbacks, which are used to execute callbacks that were deferred to the next iteration of the event loop, such as those created by setImmediate. If there are any, the event loop executes the corresponding callback functions and removes them from the queue.
• The event loop then checks if there are any pending close callbacks, which are used to execute callbacks that were registered when an I/O stream or a socket was closed, such as those created by socket.on('close', ...). If there are any, the event loop executes the corresponding callback functions and removes them from the queue.

The event loop then repeats this process until either:

• There are no more events in the queue
• The Node.js process is terminated by calling process.exit or receiving a SIGINT or SIGTERM signal

The event loop is what makes Node.js fast and scalable, as it allows it to handle many concurrent requests without blocking or waiting for I/O operations. However, it also requires careful coding practices, as any long-running or blocking operation in the JavaScript code can prevent the event loop from processing other events and cause performance issues. Therefore, it is recommended to use asynchronous code whenever possible and avoid CPU-intensive tasks in Node.js.

"What is libuv? Ugh, is that yet another JS framework?"

libuv is a cross-platform library that provides Node.js with access to various low-level features, such as I/O, networking, threading, and other system functions. libuv was originally developed for Node.js, but it is also used by other projects that need to perform asynchronous I/O operations in a platform-independent way.

libuv has several features that make it useful for Node.js, such as:

• Event loop: libuv implements its own event loop, which is integrated with the V8 event loop. libuv handles the communication between the V8 engine and the operating system, and notifies the V8 event loop when an asynchronous operation is completed or a new event occurs. libuv also provides various utilities for managing the event loop, such as timers, signals, and idle handlers.
• Thread pool: libuv uses a fixed-size thread pool to execute some operations that are not supported by the operating system in a non-blocking way, such as file system operations, DNS lookups, or user-defined tasks. The thread pool allows libuv to offload these operations from the main thread and run them in parallel, without blocking the event loop. The thread pool size can be configured by setting the UV_THREADPOOL_SIZE environment variable.
• Handle and request abstractions: libuv provides two main abstractions for working with I/O and other system resources: handles and requests. A handle represents an active or passive I/O object, such as a socket, a file descriptor, a timer, or a signal. A request represents an operation that is performed on or by a handle, such as reading from a socket, writing to a file, or closing a handle. libuv manages the lifecycle of handles and requests, and invokes callback functions when they are ready or completed.
• Stream and buffer abstractions: libuv provides two additional abstractions for working with data streams and buffers: streams and buffers. A stream is a type of handle that represents a duplex (readable and writable) data stream, such as a TCP socket, a pipe, or a TTY. A buffer is a memory region that is used to store or transfer data between streams and other handles. libuv provides various functions for creating, reading, writing, and manipulating streams and buffers.

libuv provides Node.js with a consistent and efficient way to perform I/O and other system operations across different platforms. However, it also introduces some complexity and overhead, as Node.js developers need to understand how libuv works and how it interacts with the V8 engine and the JavaScript code.

Conclusion:

In this article, we have explored the inner workings of Node.js, a JavaScript runtime environment that allows developers to run JavaScript code outside of a web browser. We have learned how Node.js uses the V8 JavaScript engine to compile and execute JavaScript code, how Node.js uses the event loop to handle asynchronous operations in a single-threaded way, how Node.js uses libuv to provide cross-platform support for I/O and other features, and how Node.js uses the runtime environment to provide additional features and modules for building applications. You can also try to write some Node.js code yourself and see how it works. Node.js is a fascinating and powerful platform for building applications using JavaScript.

Thank you for reading this article and happy coding!