The Why Node.js is based on single-threaded architecture?

Single-threaded architecture has been supporting Node.js perform amazing things. This fact also makes Node.js to become unique one than other popular server-side technology such as ASP.NET, PHY, or Ruby & Java Servers which apply Multi-threaded architecture, whereas every single request that comes from the client will result in the instantiation of a novel thread or even a mechanism. Thus, Node.js has this simple and awesome mechanism where all the requests will run on a single thread together with all the resources, as well as the shared ones. On the other hand, another thing to be noted here is, even though the central event loop of Node.js is single-threaded, but, nearly all of the I/O mechanisms will run on different and separate threads. The reason is due to the I/O APIs inside Node.js are appeared to be asynchronous/non-blocking by architecture, with a purpose to provide complete accommodations for the event loop.  

The event loop helps Node.js to conduct the non-blocking I/O performance, and here is a detail for the functions of event loop on a single thread concept on Node.js below.

Firstly, the clients deliver Request to the Web Server

Then, the Web Server of Node.js will internally preserve a Limited pool of Thread to the ‘request

Next, Node.js Web Server will receive the Request and locate them into an ‘Event Queue’

Then, Event Loop will process all the requests by checking two main different things:

It will process the whole thing if the Request does not require any mechanism of Blocking I/O 

If there is a requirement for the process of Blocking I/O, then the Event Loop will perform different methods:

Check out the availability of Threads on the Internal Thread Pool

Selects one Thread and allocate this Request toward the Thread, if the Thread is responsible for any request, then Event Loop will process, conduct the mechanism of Blocking I/O, then send the response

React has the capability to leverage the Virtual DOM. Inside React, each UP part is a module, and every single module acquires its own state. React will trail the visible pattern and also attend for the changings on state. At the time the state of a module gets changes, then React will modify the Virtual DOM tree. Then, React will compare the recent version of the updated Virtual DOM along with its last version. The entire processes named ‘diffing.’

At the time React acknowledges which modules of Virtual DOM have been modified, then React will only update those parts within the real DOM. This would lead the far better performance if compare with the direct manipulating of the real DOM. To make it easier for you to comprehend, in brief, the user will inform React which states that they want for their UI, and assures that the state will match with DOM. 

Every single website on the Internet surely always want to appear in the search engines. Thus, this is where the Server Side Rendering or also more known as SSR will be really valuable and useful especially for the websites that consist of heavy content. In order to understand properly how to do basic Server Side Rendering in React, now we will use npx to begin a new React app by using Create React App newest version. Now let’s name this with my-ssr-app:

$ npx create-react-app my-ssr-app

Then, we can continue cd into the novel directory and begin to start the new client-side application:

$ cd my-ssr-app

$ yarn start

Now, create a basic Home module

import React from ‘react’;

export default props => {

return <h1>Hello {props.name}!</h1>;

};

Then, render the Home within the App module:

import React from ‘react’ ;

import Home from ‘./Home’ ;

return <Home name=”Alligator” />;

};

There are two types of methods in the world of Server Side Rendering which are Dynamic SSR and also Static Pre-rendering. Here we will explain more on how to do both SSR methods in Angular.

Dynamic SSR 

Dynamic SSR is actually the idea that there would be a live Node server rolled up that every time a Route will be hit, it would dynamically produce and serialize the application – sending that String back to the browser. To make it simple for you, you can use the script below:

// Dynamic SSR

npm run build: ssr && npm run serve: ssr

The script above will accumulate your application and then spin up a Node Express Server, in order to serve your Angular Universal application.

Static Pre-rendering

Static Pre-rendering is a concept when we aim to pre-render a series of Routes, and then generate certain static files such as HTML, index, etc., and finally will use our chosen server to serve up all of those files. To make it simple for you, you can use the script below:

// Static Pre-Rendering

npm run build: prerender && npm run serve: prerender

Angular is actually a structural outline designed for dynamic website applications. This framework allows you to utilize HTML as your pattern language. In addition to this, Angular also allows you to extend the HTML’s syntax, with a purpose to express your components of an application in detail. Angular JS’s data binding along with the reliance injection would remove as much as code you would need to write. 

Angular JS attempts to minimize the impedance misalliance between the file centric HTML and what are the requirements for an application by producing new HTML formations. Angular JS imparts the browser new syntax via a formation that we named with ‘directives.’ Some examples are included:

Data binding, as in {{}}

Control systems of DOM designed for presenting, repeating, and also hiding the fragments of DOM 

Assigning new manner toward the DOM components, such as event handling

Gathering of HTML into recyclable modules

Both Promises.then() and also async/await could be used interchangeably. The only differentiation derived from them, if we take a look at from the perspective of end-developers is that, async/await is not broadly supported. However, this is not a big deal since you could use Babel to transpile async/await into Promise.then(). Async/await makes simpler to the code, as well as improving the readability of the code which is required for collaboration and also debugging. 

In addition to this, the essential difference between Promises.then() and await is that, await hangs up the accomplishment of the recent function. On the other hand, Promise.then() will continue the accomplishment of the recent function right after including the call to the chain of callback. 

One thing to be noted, async/await is not a replacement of Promises.then(), since all of the functions in await will return a promise, and thus, you could utilize Promise.all() along with await to solve the promises in comparable.