Explore topic-wise InterviewSolutions in .

Stubs are used in writing tests which are an important part of development. It replaces the whole function which is getting tested.  

This helps in scenarios where we need to test:

• External calls which make tests slow and difficult to write (e.g HTTP calls/ DB calls)
• Triggering different outcomes for a piece of code (e.g. what happens if an error is thrown/ if it passes)

For example, this is the function:

Exit codes give us an idea of how a process got terminated/the REASON behind termination. 

A few of them are:

• Uncaught fatal exception - (code - 1) - There has been an exception that is not handled
• Unused - (code - 2) - This is reserved by bash
• Fatal Error - (code - 5) - There has been an error in V8 with stderr output of the description
• Internal Exception handler Run-time failure - (code - 7) - There has been an exception when BOOTSTRAPPING function was called
• Internal JavaScript Evaluation Failure - (code - 4) - There has been an exception when the bootstrapping process FAILED to return function value when evaluated.

WELL, are there any other options available? Yes, of course, we have Spidermonkey from Firefox, Chakra from Edge but Google’s v8 is the most evolved(since it’s open-source so there’s a huge COMMUNITY helping in developing features and fixing BUGS) and fastest(since it’s written in c++) we got till now as a JavaScript and WebAssembly engine. And it is PORTABLE to almost every machine known.

The server is responsible for initializing the routes, MIDDLEWARE, and other application LOGIC WHEREAS the app has all the business logic which will be served by the routes INITIATED by the server. This ensures that the business logic is encapsulated and decoupled from the application logic which makes the project more readable and MAINTAINABLE.

REACTOR pattern again a pattern for nonblocking I/O OPERATIONS. But in GENERAL, this is used in any event-driven architecture. 

There are two components in this: 1. Reactor 2. Handler.

Reactor: Its JOB is to dispatch the I/O event to APPROPRIATE handlers
Handler: Its job is to actually work on those events

Middleware comes in between your request and business logic. It is MAINLY used to CAPTURE logs and ENABLE rate limit, routing, authentication, basically whatever that is not a PART of business logic. There are third-party middleware ALSO such as body-parser and you can write your own middleware for a specific use case.

In general, buffers is a temporary memory that is mainly used by STREAM to hold on to some data until consumed. Buffers are introduced with additional use CASES than JavaScript’s Unit8Array and are mainly used to represent a fixed-length sequence of bytes. This also supports LEGACY encodings LIKE ASCII, utf-8, etc. It is a fixed(non-resizable) allocated memory outside the v8.

Streams are instances of EventEmitter which can be used to work with STREAMING data in Node.js. They can be used for handling and manipulating streaming large FILES(videos, mp3, etc) over the network. They use buffers as their temporary storage.

There are mainly FOUR types of the STREAM:

• Writable: streams to which data can be written (for example, fs.createWriteStream()).
• Readable: streams from which data can be read (for example, fs.createReadStream()).
• DUPLEX: streams that are both Readable and Writable (for example, net.Socket).
• Transform: Duplex streams that can modify or transform the data as it is written and read (for example, zlib.createDeflate()).

Here is an EXAMPLE of using async-await PATTERN:

Since the node has an event loop that can be used to handle all the I/O operations in an ASYNCHRONOUS manner without blocking the main function. 

So for example, if some network call needs to happen it will be SCHEDULED in the event loop INSTEAD of the main thread(single thread). And if there are multiple such I/O calls each one will be queued accordingly to be executed separately(other than the main thread). 

THUS even though we have single-threaded JS, I/O ops are handled in a nonblocking way.

Both can be used to switch to an asynchronous mode of OPERATION by listener FUNCTIONS. 

process.nextTick() sets the callback to execute but setImmediate pushes the callback in the queue to be executed. So the event loop runs in the following manner

timers–>pending callbacks–>idle,prepare–>connections(poll,data,ETC)–>CHECK–>close callbacks

In this process.nextTick() method adds the callback function to the START of the next event queue and setImmediate() method to place the function in the check phase of the next event queue.

The main loop is single-threaded and all async calls are managed by libuv library.

For example:

This gives the output:

This is because libuv sets up a thread pool to HANDLE such concurrency. How MANY threads will be there in the thread pool depends upon the number of cores but you can override this.

Whatever that is async is managed by event-loop using a queue and listener.  We can GET the idea using the following diagram:

So when an async function needs to be executed(or I/O) the main THREAD SENDS it to a different thread allowing v8 to keep executing the main code. Event loop involves different phases with specific tasks such as timers, pending callbacks, idle or prepare, poll, check, close callbacks with different FIFO QUEUES. ALSO in between iterations it checks for async I/O or timers and shuts down cleanly if there aren't any.

async_A(function(){ async_B(function(){ async_C(function(){ async_D(function(){ .... }); }); });});

For the above example, we are passing CALLBACK functions and it makes the code UNREADABLE and not maintainable, THUS we should change the async logic to avoid this.