DEV Community: Tofail Ahmed Sayem

Node.js Asynchronous Architecture

Tofail Ahmed Sayem — Sun, 30 Jun 2024 08:48:05 +0000

Node.js is single threaded and operates asynchronously using the "Single Threaded Event Loop" architecture and handles multiple concurrent clients efficiently without multithreading. Node.js is actually designed to build distributed applications with many nodes and that's the reason why it's called Node. Actually, the main event loop is single threaded but Node.js uses multiple threads in the background to execute asynchronous code.

Node.js is non-blocking which means that all the callbacks or functions are delegated to the event loop and are executed by different threads. This means that when other processes are executing in a concurrent manner, the event loop continues to run as non-JavaScript operations. This way the tasks are executed asynchronously.

Needless to say that Node.js is extremely good at handling multiple requests concurrently using a single thread model. This is called "asynchronous cooperative multitasking".

Management of asynchronous code in Node.js:
A lot of times we have dealt with multithreading and preemptive multitasking scenarios but the first time we encountered cooperative multitasking using Node.js was when creating a User Module at the earlier stage of our product creation.

This module deals with managing different user roles and permissions and consolidates the respective entitlement of users of different levels (like Admin and User). We understood that asynchronous code in Node.js can be handled in 3 possible ways:

1.Callbacks: Callback is an executable code that is passed as an argument to another code and is expected to execute (or call back) at a specific time. Callbacks make sure that certain code doesn't execute until another code is finished its execution.

2.Using Async/Await with Promises: The async/await pattern structures an asynchronous, non-blocking function similar to a synchronous function. It provides opportunities to the program to execute other code while waiting for a long-running asynchronous task to complete. The await keyword within the async function returns a promise value that ensures the current function is completed before calling the subsequent function.

3.Using Promises: Promises are abstractions provided that give us a way to express ourselves synchronously when writing asynchronous code. A promise returns a value that is either resolved or the reason why that's not resolved (for example, when a network error occurs).

A promise can be in any one of the following states:
States of a Promise
Pending: async operation is incomplete and promise does not have a value yet.

Fullfilled: async operation is completed and promise has a value.

Rejected: async operation has failed and promise will never get fulfilled.

Typescript over JavaScript

Tofail Ahmed Sayem — Sun, 30 Jun 2024 03:36:55 +0000

Typescript is new javascript with some advanced and useful features added to javascript. Typescript, which is the superset of javascript and becoming a go to language in the web development sector for every large application. The feature of detecting bugs while typing the code makes it unique. As per research, 60% of javascript developers started using typescript.

Providing syntax for types is the key feature of Typescript with its name implemented as ‘TYPESCRIPT". Even tech giants companies like Microsoft are migrating to typescript for its functionalities and features. Communicating tools like Slack and Asana use typescript for their implementation. Developers who work on Angular, React, or Vue use Typescript. For better productivity, Typescript is better for its better collaboration. So, when there is so much about typescript, we should know why we should pick typescript over javascript.

*Points to be noted: *

A .ts extension is used to save a Typescript file.
A javascript file saved with a .ts extension works perfectly as a typescript file.
Typescript is preferred as a server side programming language.
Typescript is preferable for building large scale applications.
It is statically typed i.e. unless you give the type of the variable, the code will not run which makes error detection easy.

Why should we pick typescript over javascript? Let's discuss some points.

1) Best for creating large scale application:
Typescript is considered as the best programming language for developing large scale or enterprise level applications;. Due to its ‘type’ feature it's easy to understand for developers to read, which is not the case of Javascript. Also its feature of detecting bugs while typing makes it less time consuming. For large projects, typescript helps by catching mistakes with its type system which eventually helps to handly develop and maintain projects with less bugs.

2) Classes behave same as C++ , python:
If someone has an idea of C++, Python, then he/she should know that Typescript behaves the same way. Unlike Javascript, Typescript behaves the same, especially ‘this’ keyword and defining method. Typescript supports the OOPS concept and also helps in server-side development.

3) Framework encourages Typescript:
These days various frameworks like React, Angular, NestJS, VueJS support Typescript. Even Angular has its primary language as Typescript. Typescript is javascript with extra features and supports ECMAScript. All javascript frameworks are configurable in working with typescript because of its statically typed and auto bug detecting while coding or development. Implementing the OOPS concept becomes easy with typescript which gives the reason for using typescript over javascript.

4) Type Hinting/TypeCasting:
Typescript follows TypeCasting which brings the reason to use it over Javascript. To resolve the query in no time , it shows the error while coding. With TypeCasting it's easy to convert one variable type to another. TypeCasting allows variable type as per as requirement then and there. Using the ‘as’ keyword or <> operator is suitable for TypeCasting. At the time of development, Typescript displays the compilation error.

5) Promotes a Better Development Experience:
Typescript is very easy to understand and re-write, it becomes easy for developers to work even after gaps. Every line has a comment feature where coders can type comments while coding, for future use. It happens that more than one developer is working together on one application, that can make a mess but with the type feature it can be easy to debug. This also brings better opportunities for collaboration because any developer can easi;y understand the codebases and start making changes as requirements. This, in return, promotes a better development experience and also could return efficient output.

6) Targets multiple browsers:
It’s better to choose a language that is compatible with all browsers, rather than checking the application on browsers one by one. Once code writing is done and Typescript takes care about which browser should be targeted. It follows the process of compiling the Typescript to Javascript and then runs on browsers. So eventually it supports all browsers which support javascript. This is the biggest reason why anyone should choose Typescript over Javascript.

How to make interfaces optional in typescript

Tofail Ahmed Sayem — Sat, 29 Jun 2024 17:45:13 +0000

First of all let us look at some random example,



interface personMale{
      gender:"male";
      salary:number;
}
interface personFemale{
      gender:"female";
      weight:number
}
type person={
      name:string;
      age:number;


}&(personMale|personFemale)


const person1:person={
      name:"Sayem",
      age:27,
      gender:"male",
      salary:0
}
const person2:person={
      name:"Setara",
      age:24,
      gender:"female",
      weight:55
}

Here we should use "male" and "salary" together and "female" and " "weight" together. If we want to use "male" and "weight" or "female" and "salary" together, it will through error.

In Typescript, we can define optional properties in an interface by adding a question mark (?) to the property name. This tells Typescript that this property may or may not exist on the object.

As mentioned earlier, the basic way to make a property optional is by appending a question mark(?) to the property name. Here is an simple example,

interface User {
  id: number;
  name?: string;
  email?: string;
}


let user: User = { id: 1 };

In the above example, name and email are optional. If we create an object named ‘user’ with only ‘id’ property Typescript will not complain.

Using utility type:
Typescript provides several utility types to manipulate types, another being Partial, which makes all properties in a type T optional. Here’s how we can use it,

interface User {
  id: number;
  name: string;
  email: string;
}


type OptionalUser = Partial<User>;


let user: OptionalUser = { id: 1 };

In the above example, OptionalUser is a new type where all properties of User are optional. Hence, we can assign an object with only the id property to the user.

Typescript Generics

Tofail Ahmed Sayem — Sat, 29 Jun 2024 16:12:24 +0000

Generics in Typescript are a feature that allows you to create components that can work with any data type while preserving type safety. They provide a way to define functions, classes and interfaces without specifying the exact data types they will operate on in advance. Instead, you use type variables, usually represented by letters like , to create a placeholder that will be replaced with a specific type when the component is used.

function identity<T>(arg: T): T {
    return arg;
}


let numberIdentity = identity<number>(42); // Works with numbers
let stringIdentity = identity<string>("Hello"); // Works with strings

Let's consider an example,

function printData(data: number) {
    console.log("data: ", data);
}


printData(2);

In this example, we can not assign any string or object or boolean or array as the value of ‘data’. Instead of previous example, we can rewrite the example as below,

function printData(data: number | string | boolean) {
    console.log("data: ", data);
}


printData(2);
printData("hello");
printData(true);

This example is a better approach than the previous one. In this example we can assign an argument value either number or string or boolean. But incase of complex argument or multiple argument it will be a little awkward looking and complicated. Instead of last example we can try another approach,

function printData<T>(data: T) {
    console.log("data: ", data);
}


printData(2);
printData("hello");
printData(true);

In this example we can pass any type of data as the value of argument ‘data’. We can pass string, boolean, number, obj, array without mentioning data type.

How Generics work is TS:
Generics are like variables - to be precise , type variables - that store the type(for example number, string, boolean) as a value.

So, we can discuss generics as below:

function printData<T>(data: T) {
    console.log("data: ", data);
}


printData(2);
printData("hello");
printData(true);

In above example,
1) We can use type variable inside angular brackets after the fn name
2) Then assign the type variable to the parameter data:T

Let explore bit more-
To use generics , we need to use angular brackets and then specify a type variable inside them. Developers generally use T, X, Y, V etc etc. But it can be anything depending upon preferences.
Even if we can pass an array of something or an object of something as an argument of data value, everything will be displayed without TS complaining.

function printData<T>(data: T) {
    console.log("data: ", data);
}


printData(2);
printData("hello");
printData(true);
printData([1, 2, 3, 4, 5, 6]);
printData([1, 2, 3, "hi"]);
printData({ name: "Ram", rollNo: 1 });

Let see another example:

function printData<X,Y>(data1: X, data2: Y) {
    console.log("Output is: ", data1, data2);
}


printData("Hello", "World");
printData(123, ["Hi", 123]);

In the above example we passed two arguments to fn and used X and Y as type denotion for both parameters. X refers to the first value of the argument and Y refers to the second value of the arguments.
Here as well, the type of data1 and data2 are not specified explicitly because TS handles the type inference with the help of generics.

Event loop in Node.js

Tofail Ahmed Sayem — Tue, 25 Jun 2024 06:26:45 +0000

The Node.js event loop is a critical concept for understanding how Node.js manages asynchronous operations and ensures efficient handling of concurrent tasks without blocking. Here's a breakdown of its main components and how it functions:

Event Loop: The event loop is the central mechanism that manages all asynchronous operations in Node.js. It continuously checks for events in the event queue and processes them in a loop.

Event Queue: The event queue holds various types of events such as callbacks, timers, and I/O events. These events are queued up when asynchronous operations are initiated and are processed sequentially by the event loop.

Callbacks: Callbacks are functions passed as arguments to be executed later, typically after a specific operation or event completes. They are essential for handling asynchronous results.

Timers: Node.js provides timers like setTimeout() and setInterval() to schedule callbacks to execute after a specified delay or at regular intervals. These timers are managed by the event loop to trigger their associated callbacks at the appropriate times.

I/O Operations: When Node.js performs I/O operations (e.g., file system operations, network requests), it delegates these tasks to the operating system and registers callbacks. Once the operations are completed, their respective callbacks are queued in the event loop for execution.

Process Overview:

Event Check: The event loop continuously checks the event queue for pending events.
Event Execution: If events are found in the queue, the event loop dequeues and executes their associated callbacks.
Microtasks: After executing regular callbacks, the event loop processes any microtasks queued in the microtask queue. Microtasks typically include promises and other high-priority tasks.
I/O and Timers: The event loop handles ready I/O operations and checks if any scheduled timers have expired, executing their callbacks as necessary.
Repeat: The process repeats itself, ensuring continuous handling of asynchronous events without blocking the application.
Concurrency and Blocking:

The event loop enables Node.js to manage multiple tasks concurrently within a single thread, making it highly efficient for I/O-bound operations.
CPU-bound operations can potentially block the event loop and should be handled separately using worker threads or other processes to maintain application responsiveness.
Understanding the event loop is fundamental for developing efficient Node.js applications, ensuring optimal performance under varying workloads.