Node JS characteristics

Functional programming

Asynchronous programming

Tasks can be executed asynchronously only if NO dependency.

With dependency, there will be a producer and a consumer. Consumer need to process result provided by producer. There are several ways to achieve this from history.

callbacks : producer is defined with a function on what to do after
Promise : producer returns an object with what to do after
async/await :

Callbacks : pyramid of doom, top-level step functions

producer logic defined with a callback for consumer to hook in
consumer logic defined in callback and passed to producer

# producer
function producer( args, callback ) {
    try {
        result = take_time_to_get_result()
        callback(null, result)
    } catch (err) {
        callback(err)
    }
}

# consumer
function consumer(producer) {
  producer(args, function(err, result) {
      if (err) {
          handle_error(err)
      } else {
          consume(result)
      }
  })
}

Promise : 1-to-n producer/consumer handling

producer logic is encapsulated in Promise and executed upon creation
consumer logic is defined and passed to Promise object, not as callback to producer
consumers can be added in dynamically

# producer
function producer(args) {
  function executor(resolve, reject) {
    try {
      value = take_time_to_get_result()
      resolve(value)
    } catch (err) {
      reject(err)
    }
  }
  return new Promise( executor );
};

# consumer
function consumer() {
  let promise = producer(args)
  promise.then(result_handler(result), error_handler(error));
}

state	result
pending	undefined
fulfilled	value
rejected	error

async/await

async function always returns a promise
await (must inside async function) makes the script wait until promise settles and returns