Node Js Backend Developer

Node.js is lightweight and efficient because it is built on an event-driven design with asynchronous I/O. It uses uses JavaScript as its scripting language and runs Chrome’s V8 JavaScript engine. It's used in desktop programs and with a popular framework called electron because it has APIs for accessing OS-level functionality like file systems, networks, and so on.

Middleware are basically just functions that have full access to both request and response objects.

var app = express();

app.use(cookieParser());
app.use(bodyParser());
app.use(logger());
app.use(authentication());

app.get('/', function (req, res) {
// ...
});

app.listen(3000);

Whether you wish to design your own middleware or use the framework's built-in middlewares, an Express application is simply Node.js with a host of middleware functions, Express made the process natural and intuitive.

EventEmitter is a Node.js class that includes all the objects that are basically capable of emitting events. This can be done by attaching named events that are emitted by the object using an eventEmitter.on() function. Thus whenever this object throws an even the attached functions are invoked synchronously.
Example:
const EventEmitter = require('events');
class MyEmitter extends EventEmitter {}
const myEmitter = new MyEmitter();
myEmitter.on('event', () => {
console.log('an event occurred!');
});
myEmitter.emit('event');

1. Concurrency Value
2. Task Function

Promises allows you to link handlers to the final success value or failure reason of an asynchronous activity. This allows asynchronous methods to return values in the same way that synchronous methods do: instead of returning the final value, the asynchronous method provides a promise for the value at a later time.The great thing about promises is that they can be used to create dependency chains (do Promise C only when Promise A and Promise B complete).
Promises are based on the premise that they represent the outcome of an asynchronous process. A promise can be in one of three states:
pending - A promise's initial state. 
fulfilled - A promise's final state.
rejected - The state of a promise representing a failed operation. Once a promise is fulfilled or rejected, it is immutable (i.e. it can never change again).