Node

Question 1

process

Answer 1

Node’s global object containing information about the current process and some methods.

Question 2

pocesss.env

Answer 2

Information about the environment in which the process is currently running.

Question 3

process.argv

Answer 3

An array of command line values provided when the current process was initiated.

process. argv[0] - the absolute path to Node which ran the process
process. argv[1] - the path to the file that’s running
process. argv[2 -> …] - command line arguments provided when the process was initiated.

Question 4

req, res

Answer 4

Objects with properties and methods that we can use to customise our HTTP requests.

req

• the object which contains information about the client HTTP request
• an instance of IncomingMessage

res

• provides methods for sending back the server HTTP response
• an instance of ServerResponse, which is a writeable stream

Question 5

Main response time cost

Answer 5

Usually the SUM of time it takes to execute ALL db queries.

In Node, you can execute all the db queries IN PARALLEL, reducing the response time to that of the slowest db query.

Question 6

What is Node?

Answer 6

1. an synchronous event driven runtime, or environment, that allows for execution of JS outside of the browser
2. a library (comes with a lot of moudles)

Question 7

package.json

Answer 7

Project’s control file

Question 8

Are expensive operations OK in Node?

Answer 8

Yes, al long as you make sure not to block the Node.js process with them.

You could spawn a child process (child_process.fork()) and take advantage of multiple cores in your environment.

Question 9

How can you use multiple threads in Node?

Answer 9

You could spawn a child process (child process.fork()) and take advantage of multiple cores in your environment, even though Node was designed without threads.

If you need more instances of the event loop, you can create while them making sure that global data in each instance isn’t shared. If your instances need to collaborate, your need some communication mechanism.

Question 10

Event loop as a runtime construct

Answer 10

Node presents an event loop as a RUNTIME CONSTRUCT instead of as a LIBRARY.

There is no start-the-event loop call:

• Node simply enters it after executing the input script, and
• Exits it when there are no tasks callbacks left to perform

This behaviour is like the browser JS where the event loop is hidden from the user.

Question 11

Blocking vs. Non-blocking calls

Answer 11

BLOCKING

• execute synchronously
• extremely cheap synchronous operations (e.g., console.log) don’t cause problems, but they can still stall the Node’s event loop, given that there are enough of them within one loop iteration.

NON-BLOCKING
- execute asynchronously

Question 12

The most important rule for writing Node apps

Answer 12

Don’t block the event loop:

• handle I/O intensive operations asynchronously
• keep your code (everything that happens synchronously within one loop iteration) lean

Question 13

How does Node work?

Answer 13

Node

1. Starts
2. Loads our app (into the event loop, it is already there)
3. Loops until there’s nothing left to do
4. Then our app terminates

In the case of an HTTP server, we create a background process that CONTINUOUSLY WAITS for requests from clients, so the app doesn’t terminate when there are no callbacks left to process.

Question 14

What is performed within one loop iteration?

Answer 14

All the synchronous operations given. Async operations are left for future loop iterations.

Question 15

Why are slow blocking operations a global problem in Node.

Answer 15

Because there is only one process, running on a single CPU core.

A slow DB query in Python would result in a slow page load for one particular user, while in Node that would be a global problem affecting all users.

Question 16

Parallelism in Node

Answer 16

Everything runs in parallel, except your code.

Your code is the king, while Node is its army of servants which perform their tasks in parallel, but only report to king one at a time.

There can be only one callback firing at the same time. All the other callbacks have to wait for the first one to finish executing.

One benefit of such single-threaded/event loop design is that it eliminates the worry that different pieces of code will access the same data structure at the same time.

Question 17

What is the execution/parallelism model of Node?

Answer 17

The single-threaded event loop.

Question 18

What does Node do when you call an async function?

Answer 18

It starts an operation outside the event loop.

Conceptually, Node starts an async operation and makes a mental note that when this operations triggers an event, the callback that was passed to the operation needs to be called.

Question 19

How does a Node server work

Answer 19

1. Node runs a single-threaded event loop registered with the system to handle connections.
2. Each new connection causes a system callback to fire
3. The callbacks handle requests with non-blocking I/O calls
   - If necessary, callbacks spawn threads from a pool to execute blocking or CPU intensive operations, and to load-balance across CPU cores

Question 20

Benefits of the Node’s single-threaded event loop execution model

Answer 20

1. Node’s approach to scaling with callbacks requires less memory to handle more connections than most architectures that scale with threads.
2. The single-threaded/event loop design eliminates the worry that different pieces of code will access the same data structure at the same time.

Question 21

fs

Answer 21

Provides simple wrappers around standard POSIX file I/O functions.

Question 22

The Event Emitter Pattern

Answer 22

Useful in situations when more than one callback event must be handled.

It’s a function that returns an Evt Emitter object which is a writable stream.

Using this object’s .on method we can attach callbacks to different events.

Question 23

The Event Emitter object

Answer 23

A writable stream that can be used to attach callbacks to different types of events.

Question 24

EvtEmitter.on(‘error’, …)

Answer 24

Will raise an exception if not handled by a callback.

Question 25

EvtEmitter.on(‘end’, …)

Answer 25

Fired once, and from then onward no other events will be fired from the evt emitter.

Question 26

EvtEmitter.once(‘evtName’, cbName)

Answer 26

Like the ‘.on’ method, but its event callbacks fire only once, on the first occurrence of the event of the type, and then are removed from the list of event listeners.

Question 27

Detach callbacks from EE’s listeners

Answer 27

ee. removeListener(‘evtName’, cbName)

ee. removeAllEventListeners(‘evtName’)

Question 28

When should you execute async operations in parallel in Node

Answer 28

When they don’t inherently depend on each other (one does not itself need the result of another operation), even when you need the results of both operations.

If you wait for each operation to finish before proceeding with the next one, main response time cost would be the sum of all times it took to perform each given operation. If you execute them in parallel, the main response time cost is that of the slowest of the operation.

Question 29

How to perform async operations in parallel

Answer 29

async.parallel

Question 30

How to perform async operations in series

Answer 30

async.series

Question 31

How to perform async operations in series, so that the subsequent operations get results of the ones preceding them

Answer 31

async.waterfall

Question 32

Core Node.js modules

Answer 32

fs
http
path
url
querystring
util