What is nodeJS ?

According to the nodeJS docs, It is an open-source and cross-platform JavaScript runtime environment 🤔.

To understand this, let’s see what a javaScript runtime environment is.

Basically, it refers to the environment in which JavaScript code is executed, meaning that it includes everything needed to run a JavaScript program, such as the JavaScript engine, libraries, and other components that facilitate the execution of JavaScript code.

NodeJS runs the V8 JavaScript engine, the core of Google Chrome, outside of the browser. This allows nodeJS to be very performant.

In other words, NodeJS brings the capabilities of JavaScript, traditionally associated with the client-side (browser), to the server-side, enabling developers to use a single programming language (JavaScript) for both front-end and back-end development.

The V8 engine (read more at https://v8.dev/ ), which is optimized for high-performance execution, plays a crucial role in making nodeJS efficient and powerful for server-side applications.

A node app is single threaded but non-blocking, meaning that it runs multiple concurrent processes, without creating a new thread for every process. So you may ask how is that possible?

Well, the answer is simple. NodeJs ships in with a set of asynchronous I/O primitives in its standard library that prevent JavaScript code from blocking, in fact, libraries in nodeJS are written using non-blocking paradigms by default, making blocking behavior the exception rather than the norm.

In other words, nodeJS is asynchronous by default. It’s up to the developer to opt for synchronous behavior.

Single-threaded vs Multithreaded Processes

Single thread processes execute all instructions in a single sequence. In other words, only one command is processed at a time.

The opposite of single-threaded processes are multithreaded processes. These processes allow the execution of multiple parts of a program at the same time.

Node js is single-threaded, but there are some libraries in Node js that are not single-threaded.

NodeJS uses its libuv library to handle tasks related to the operating system, such as asynchronous I/O-based tasks of operating systems, networks, concurrency, etc...

When Node requests simultaneous process execution, the Libuv library configures a set of threads to perform the operations, using the power of all CPU cores.

Since modern machines have multiple cores, each thread in the pool is assigned to each core.

This results in one thread per core. With this configuration, all threads will run their process on each core in parallel.

In nodeJS, I/O operations like networking, accessing a database or reading from the filesystem, are all asynchronous, so the thread isn't blocked and CPU cycles aren’t wasted.

Instead, nodeJS simply runs them on the side, and only resumes the operations when they complete or fail.

This allows nodeJS to handle thousands of concurrent connections with a single server without introducing the burden of managing thread concurrency, which could be a significant source of bugs.

A simple example of NodeJs in action

Lets setup a simple nodeJS web server that response with a hello-world message.

const http = require('http');

const hostname = '127.0.0.1';
const port = 3000;

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello World\n');
});

server.listen(port, hostname, () => {
  console.log(`Server running at http://${hostname}:${port}/`);
});

Save the snippet above in a server.js file and in your terminal, run `node server.js`
NB: We will discuss nodeJS installation is discussed in the

Lets break it down:

First, we include the http module

Node.js has a fantastic standard library , including first-class support for I/O processes included networking.

The `createServer()` method of the http module, creates a new HTTP server and returns it.

The server is set to listen on the specified port and host name(which are declared as constants). When the server is ready, the callback function is called, in this case informing us that the server is running.

As discussed above, listen operation is asynchronous, so the node handles that as a subprocess and only returns to it when it is ready or throws an error.

When a new request is received, the request event  is called, providing two objects:

1. 1.a request (an http.IncomingMessage object) which provide details about the request. We didn’t use that in our example.
2. 2.a response (an http.ServerResponse object) used to return data to the caller.

In our case:

res.statusCode = 200;

we set the statusCode property to 200, to indicate a successful response. (read more 👉 http codes)

We set the Content-Type header:

res.setHeader('Content-Type', 'text/plain');

We end the response and append a message to the body

res.end('Hello World\n');

In this series part, we covered some definitions and terminologies associated with nodeJS. We also saw how simple it is to setup a web server and start receiving and responding to http requests.

In the next part, we will focus on installing and setting up nodeJS.