Javascript frameworks 2020

February 8, 2020 ~ nutcrackerzadmin ~ Leave a comment

Java script is one of the most essential object orient programming language designed to make web development. It makes things easier, more engaging, responsive, interactive, which helps in enhancing user experience.

With the advancement of technology, a various JavaScript framework has also emerged in the market. It is a tool that makes working with Java script easier and smoother, which is one of the reasons for its popularity in present times. It’s helpful for developers that don’t have enough experience to understand how the web platform works. With the help of this application framework written in JavaScript, programmers can manipulate the functions and use them for their convenience.

When it comes to deciding which JavaScript framework is perfect for your work, it can turn into a mind-boggling task. To make things easier, we help you out with our research work.

Angular

The most popular, powerful, efficient, and adaptable JavaScript frameworks for technological advancements. Angular is operated by Google and perfect for large UI applications. From routing templates to testing utilities in its package, it’s quick to develop robust web applications. Top Angular apps are PayPal, The Guardian, Upwork, JetBlue, etc. Angular 9.0.0 will soon be launched in 2020 without further delay.

React

It gives developers the ability to work with a virtual browser that is friendlier than the real browser. React JS is mostly preferred to build enterprise applications that are powerful and high performing. Instagram and Facebook are proof of its popularity due to a fast and efficient user interface. React 16.9 has several new features, bug fixes, and new deprecation, but 2020 all are waiting for React 17.

Vue

At present, 36,000 websites are using Vue; companies like StackOverflow, PlayStation, etc. are a few of the examples. They are relying on Vue for their websites UI, which conveys its efficiency. The documentation with Vue is in detailed format, which is helpful for users who know a little about JavaScript and HTML can develop his own application or web page.

Ember

Ember is an excellent choice in building large or complex client-side apps and in developing flexible web applications. It has quality support, unmatched admin control, and proves a better option for the client-side JavaScript framework. Popular websites like LinkedIn, Netflix, Nest store, Apple music are a few of the examples.

Node

Node is impactful in building light-weight applications that are unparalleled in performance. It is built on Google Chrome’s JavaScript Engine V8, due to which it provides faster services. Node built applications can be used on operating systems like Microsoft Windows, Linux, and macOS. Node 13.0.1 is the latest launched version. Few of the companies making use of Node are GoDaddy, Groupon, IBM, Yahoo, etc.

At Nutcrackerz India, we specialize in javascript based developments and you can explore your development options in any related projects by dropping us a contact request.

How to use npm Chalk package to style terminal string?

March 14, 2019 ~ nutcrackerzadmin ~ Leave a comment

Chalk is a public npm package which can be used to style terminal string.

How to include local modules in Node.js application?

March 10, 2019 ~ nutcrackerzadmin ~ Leave a comment

We can export the modules that we create locally in other files and folders. This can be done by using module.exports . We have to import the specific file in which the local module is located by using require keyword.

//Importing local module

Example: add.js 

const add = (a,b) => { a + b }
module.exports = add

Example: app.js

const addition = require('./add.js')
const result = addition(3,4)
console.log(result)

//Importing local module

Example: add.js

const add = (a,b) => { a + b }

module.exports = add

Example: app.js

const addition = require('./add.js')

const result = addition(3,4)

console.log(result)

How to include core modules in you Node.js application ?

March 10, 2019March 10, 2019 ~ nutcrackerzadmin ~ Leave a comment

Node.js core modules such as fs(file system) , http, url etc… has to be imported into the program file using the require key word.

//How to import core modules in node.js

const fileSystemModule = require('fs')

//How to import core modules in node.js

const fileSystemModule = require('fs')

SetInterval ref and unref in NodeJS

February 13, 2018 ~ Vivek ~ Leave a comment

A NodeJS process is alive as along as it has some events and callbacks that are to be processed. So if we have a simple setInterval function in a file, it means the node processor has always some events to be processed periodically.

//runs forever
var id = setInterval(function() { /* ... */ }, 1000);

1 2	//runs forever var id = setInterval(function() { /* ... */ }, 1000);

Simply adding this line will make the node run this script file forever!

There are mostly cases when execution flow has logically stopped, the setIntervals that have been created no longer make sense and its sensible for the node to terminate the process.

The ref and unref does exactly that operation over the setInterval id objects.

unref – so in the above example id.unref() means we inform nodejs that it can terminate the process if the id referenced interval call is the only event loop hogging to be processed.

//quits immediately
var id = setInterval(function() { /* ... */ }, 1000);
id.unref()

//quits immediately

var id = setInterval(function() { /* ... */ }, 1000);

id.unref()

ref – ref does the opposite of unref. according to some condition if id referenced interval call is meaningful and is going to affect the process outcome even if all other logics have completed execution we can do a id.ref() (if we have called id.unref() before on some condition) to make it actively hogging event processing loop for nodejs. So nodejs wont quit if that id referenced interval call is still active.

//runs forever
var id = setInterval(function() { /* ... */ }, 1000);
id.unref()
id.ref()

//runs forever

var id = setInterval(function() { /* ... */ }, 1000);

id.unref()

id.ref()

Difference between process.nextTick and setImmediate in NodeJS

February 13, 2018 ~ Vivek ~ Leave a comment

In a funny deviation from what the name suggests, setImmediate is a callback that will be made after the nextTick() calls! The setImmediate by definition happens after current execution and after timer & I/O events, while the process.nextTick calls will be called after current script execution and before other timer & I/O Events!

So an Disk I/O event handler set in setImmediate has a flimsy chance that it might not be called, while the one set in process.nextTick is sure to be called!

What is process.nextTick in NodeJS?

February 13, 2018 ~ Vivek ~ Leave a comment

The process.nextTick serves for the design logic where for one, events that are generated by while initialising or creating an object is not generated before the caller has registered listeners for those.

//diskreader.js
var events = require('events');
function diskreader() {
  var emitter = new events.EventEmitter();
  //... read operations...
  //...
     emitter.emit('readcomplete', data);
  //...
  return emitter;
}
var dataReader = diskReader();
dataReader.on("readcomplete", function(data) {
  console.log("Data is ", data);
});

//diskreader.js

var events = require('events');

function diskreader() {

var emitter = new events.EventEmitter();

//... read operations...

//...

emitter.emit('readcomplete', data);

//...

return emitter;

}

var dataReader = diskReader();

dataReader.on("readcomplete", function(data) {

console.log("Data is ", data);

});

Now considering the above case, there is a possible that the disk reader is just for a specific case reading from cache and the inner logics of callbacks happen immediately as soon as the object is created via diskReader() call.

But the actual object does not have the proper handler registered for this event yet. So though the “readcomplete” is fired, its gone amiss and still the dataReader might still be in a state assuming read is not complete yet.

So if we use this as

  //...
    process.nextTick(function() {
      emitter.emit('readcomplete', data);
    });
  //...

//...

process.nextTick(function() {

emitter.emit('readcomplete', data);

});

//...

this means the execution flow of current script is done only then (on the next tick) these code are executed. So emitter.emit(‘readcomplete’) is just put in a queue and current script is complete executed till dataReader.on(“readcomplete”) line is executed. Then the queue of the nextTick calls are executed in sequence. The queue of nextTick Calls is limited by process.maxTickDepth.

Fork() & Messaging between parent child processes in NodeJS

February 13, 2018 ~ Vivek ~ Leave a comment

NodeJS, in very likeness to C/C++ offers to fork multiple processes from a parent process. Each of these fork() process can essentially run a separate flow of execution written in a different js file altogether. So we can have two files parent.js and child.js each running as separate processes. We are dealing with multiple processes and not multiple threads!, so it makes sense to think that OS is going to assign them to different cores for processing and so its absolutely parallel execution of logic in terms of an execution architecture.

Communicating between parent and child

There is a “message” event available for each process object and send() function available for sending. The use of these together will let us communicate between processes. A simple example is given below with output:

//parent.js
var childProcess = require('child_process');
var child = childProcess.fork('child.js');
child.on('message', function(msg) {
 console.log('Message from Child: ', msg);
});
child.send("I am parent!");

//parent.js

var childProcess = require('child_process');

var child = childProcess.fork('child.js');

child.on('message', function(msg) {

console.log('Message from Child: ', msg);

});

child.send("I am parent!");

//child.js
process.on('message', function(msg) {
 console.log('Message from Parent: ', msg);
 process.send("I am a child!");
});

//child.js

process.on('message', function(msg) {

console.log('Message from Parent: ', msg);

process.send("I am a child!");

});

#####Terminal
➜ node parent.js
Message from Parent: I am parent!
Message from Child: I am a child!

#####Terminal

➜ node parent.js

Message from Parent: I am parent!

Message from Child: I am a child!

Handling POSIX SIGNALS in NodeJS (Javascript!)

February 13, 2018 ~ Vivek ~ Leave a comment

NodeJS, built over the v8 Engine, which is essentially C/C++ application, exposes much if not all of the POSIX signals to the Javascript layer. Hence we can have multiple options coming out of design of architecture using these SIGNALing and SIGNAL Handling possibilities. A few noteworthy things that we can think of from the top of our mind are:

SIGINT Capture – A cleaner and more proper way to have a CTRL-C Handling in NodeJS Server modules/applications.
Say , a simple code like below can do a proper clean up and exit on CTRL-C or SIGINT passed from command line / other application to the nodejs app’s ProcessID.

Swift

process.on('SIGINT', function() { console.log('SIGINT'); cleanup() process.exit(1); })

1
2
3
4
5

   process.on('SIGINT', function() {
       console.log('SIGINT');
       cleanup()
       process.exit(1);
   })

SIGUSR1 and other custom User defined SIGNALS that can be used for any custom feature implementation, say using IPC!

process.on('SIGUSR1', function() {
       //Configuration Reload Signal Received!
       pauseCurrentTask();
       reloadConfigurationFiles();
       resumeTask();
   });

process.on('SIGUSR1', function() {

//Configuration Reload Signal Received!

pauseCurrentTask();

reloadConfigurationFiles();

resumeTask();

});

So if we just keep track of a worked task’s PID we can have other application send SIGUSR1 signal (or we can do from command line using ➜kill -s SIGUSR1 pID). The worker task will interpret this signal as configuration reload indicator and can do the relevant logics for that!

Difference between console.log and process.stdout.write in NodeJS

February 11, 2018 ~ Vivek ~ Leave a comment

NodeJS can print a string to terminal using two ways. The well known console.log as in chrome and the lesser-known process.stdout.write way. Both have the same usage params. While you find console.log ends the line thats printed, the other does not.

So which is good to use?

The console.log is implemented in the NodeJS Core as nothing but a wrapper over process.stdout.write. So you may find something like this in the nodejs core lib:

console.log = function (text) {
     process.stdout.write(text + '\n');
};

console.log = function (text) {

process.stdout.write(text + '\n');

};

Having said that, usage of both are equivalently efficient and you might actually prefer which one to use based on your personal comfort with which one you wanna type!