Why are my promises (running in parallel and running in serial) completing at the same time - node.js

Question

I am trying to see the difference in processing time between running promises in parallel and in serial order. But in the below code, I get the output from both functions at the same time. Ideally, the parallel function result should come up much quicker. Is there anything wrong I am doing here.
const timeout = 10000
const function1 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve("hello1")
}, timeout);
})
const function2 = new Promise((resolve, reject) => {
setTimeout(() => {
resolve("hello2")
}, timeout);
})
const parallel = async () => {
const result1 = function1
const result2 = function2
const result = await Promise.all([result1, result2])
console.log(result)
}
const serial = async () => {
const result1 = await function1
const result2 = await function2
console.log("result", result1 + " : "+result2)
}
parallel()
serial()

Answer 1

There are two key things here:
Promises don't "run" at all. A promise is a way of observing the completion of something that's running, they don't run anything. You aren't the only one who's confused by this. :-) It's a very common misunderstanding.
Your function1 and function2 aren't functions, they're constants containing promises. As soon as you call new Promise, your code in the promise executor runs, which starts your timer. The promise executor is called synchronously by the Promise constructor to start whatever async operation the promise is going to report the completion of.
This is why you're seeing the result you're seeing: You're starting all of your timers at the same time, so they all fire at the same time. It doesn't matter whether you're observing those completions in parallel or in series.
If you want to see the difference, wait to start your operation:
const timeout = 1000; // <== Changed to 1s
const function1 = () => new Promise((resolve, reject) => {
// Note the −−−−−−^^^^^−−− change, I've made `function1` actually a function
setTimeout(() => {
resolve("hello1");
}, timeout);
});
// Note the change, I've made `function2` actually a function
const function2 = () => new Promise((resolve, reject) => {
// Note the −−−−−−^^^^^−−− change, I've made `function2` actually a function
setTimeout(() => {
resolve("hello2");
}, timeout);
});
const parallel = async () => {
const result1 = function1(); // <== Calling the function starts the timer
const result2 = function2(); // <== Calling the function starts the timer
const result = await Promise.all([result1, result2]);
console.log(result);
};
const serial = async () => {
const result1 = await function1(); // <== Calling the function starts the timer
const result2 = await function2(); // <== Calling the function starts the timer
console.log("result", result1 + " : " + result2);
};
parallel();
serial();