Understand the what, why and how of Promises in Javascript

What are Promises? Why to use them?

Say you are a celebrity blogger and people are waiting for your next blog. You promise to notify them once the blog is ready. You take their emails and once your blog is done notify them via email.

A promise in Javascript works similarly. If you have an asynchronous operation you can use a promise to let the consumer know about its outcome.

It’s a placeholder for an asynchronous operation outcome. It’s an object which has a state and a value.

let promise = new Promise(function (resolve, reject) {
  // DB call
  if(call was success) {

Promise has an executor function with two parameters – resolve and reject. These parameters are predefined by the javascript engine.

Promise object has a state and a result. State can be pending, fulfilled or rejected. Value can be undefined, value or error.

Problem with Promises – a chain of promises makes the code complex.

Gentle introduction to Callbacks in Javascript

What are callbacks and what is a callback hell. In this short video I provide a simple explanation to callbacks.

A Callback is a function that is passed to another function.

Callbacks in Javascript
Three ways to work with asynchronous operations in Javascript
1. Callbacks
2. Promises
3. async / await

Callback is a function that is passed to another function

setTimeout(function () {
}, 3000)

function myFunction(param1, callback) {
  // some operations

function myCallbackFunction() {

myFunction(123, myCallbackFunction)

Gentle Introduction to Prototypes and Prototypal Inheritance in Javascript

In this short video tutorial I will explain in simple terms what are prototypes in Javascript and how Inheritance works.

Key points to keep in mind

  • In Javascript if an object wants to inherit from another object then it can do so using prototypal inheritance.
  • The parent object is referred to as Prototype.
  • __proto__ is deprecated, we can use Object.create()
let fourWheelerObj = {tyres: 4} // Prototype

let carObjectOne = {engine: 'v6', __proto__: fourWheelerObj}

console.log(carObjectOne.tyres) // 4

let carObjectTwo = Object.create(fourWheelerObj)
console.log(carObjectTwo.tyres) // 4

Use NPTEL Portal as one stop place to prepare for GATE Exam

Students preparing for GATE have challenge finding quality resources and lectures. And many of them opt for coaching. Now a much more economical online option is available. Thanks to NPTEL initiative.

As you may be knowing NPTEL has been offering quality courses and lectures for a long time. Based on the feedbacks from the Students it has now launched a portal where GATE Aspirants can find video lectures to build their concepts and practice tests. Along with that there will be video solutions to previous years GATE questions.

You can access the portal using this link

For Computer Science lectures you can visit this link

We believe that this portal will help GATE aspirants to learn fundamentals and prepare for their upcoming GATE Exams.

The Portal will provide

A comprehensive one stop platform from concepts to tricks for cracking GATE exam.

Enables access to high quality lecture content covering the entire GATE syllabus.

Provides detailed video solutions of previous years GATE exams.

A platform for online assessment via a comprehensive question bank and provide feedback highlighting strengths and weaknesses.

What is ‘this’ in Javascript world?

In this short video tutorial I explain the basics of this keyword in Javascript. It’s a confusing concept for those starting out with Javascript.


-- If a function has a this reference in it, it points to an object. The object it points to depends on how the function was invoked.
-- It does not refer to the function itself.

function simpleFn() {
  console.log(this) // this points to an object

simpleFn() // -- window

let myObject = {
  myFunctionTwo: simpleFn,
  name: 'Ankur',
  age: 36


// strict KEYWORD
// .call(obj2)

What is Lexical Scoping in Javascript

In this short video tutorial I explain what is meant by Lexical Scoping.

Sample code snippet used for explaining.

// Lexical Scope
// Code in one scope can access variables in same scope or any scope outside // of it.

// Global variables
let x = 2

// function with an inner function
function outerFn() {
let y = 9
// can access x, y

function innerFn () {
let z = 44
// can access x,y,z
console.log(x, y, z)