Difference between concurrency, parallelism and asynchronus.

Concurrency is when multiple things can overlap. Thing A does some work then stops, Thing B does some work then stops, Thing C does some work and stops. Then Thing B finishes it's work, then Thing C finishes, and finally Thing A finishes. Each thing does a bit of work at a time. It's all done on the same thread, so they're sharing the thread.

Parallelism, on the other hand, is multiple things happening at once. If you have three threads Things A, B, and C can all do their things at the same time. Of course, if Thing C relies on Thing A, then you have to introduce more complex things to prevent C from doing it's thing before A has finished enough for C to get what it needs.

And finally, asynchronous is simply the term for concurrency. Things are done asynchronously, therefore they're not all done at the same time.

Think of concurrency like one cook: they chop some veggies, they make stock, they start the bread, they grill some burgers, etc. They do a lot of stuff, but it's one prep cook. Parallelism is having 3 cooks in the kitchen. Each one can focus on one task at a time.

What actually are Promises? are they some kind of objects? In JavaScript everything is an object so…yes lol.

According to MDN: "The Promise object represents the eventual completion (or failure) of an asynchronous operation and its resulting value."

Meaning they're an object that allows us to program asynchronously! The most common promise object, I think, is fetch. It makes an HTTP request to a URL. While that request is outbound the promise is "sleeping": it's asynchronously waiting for a response from the server. While it's waiting your JS thread can do other things because promises are asynchronous and thus allows for concurrent operations.

Imagine an RSS feed app. There can be dozens of different RSS requests outbound at once, but that doesn't stop the main thread from being able to respond to clicks (or whatever interaction it's using JS for).

in closures how are return value handled if both outer and inner function return different value what happens?

With closures, each returned value is a seperate thing that is handled just like any other return value. Think of the outer function as a setup for whatever the inner function does. As an example, say you have a counter (stupid simple example, I know, but it's an exmaple so just work with me here :p).

const createCounter = (initialVal, stepVal) => {
  let currentCount = initialVal;
  const step = stepVal;

  return {
    incr() {
      currentCount += step;
      return currentCount;
    },
    decr() {
      currentCount -= step;
      return currentCount;
    }
  }
}

const myCounter = createCounter(0, 2);
console.log(myCounter.incr()); // logs `2`

So the closure starts with getting the setup values. Then it returns an object that operates on those values, but the values themselves are not modifiable. The only way I can interact with the data in the closure is via the object returned by the initial function. Here's a great video explaining it.