Disable the no-await-in-loop rule

[leroykorterink]

There is a proposal to disable the no-await-in-loop rule.

Sometimes we want/need do to things sequentially (like loading things in a specific order) and can leverage a for loop to do so. This rule introduces unnecessary verbosity.
- @edgardz

[leroykorterink]

The no-await-in-loop rule is important because it helps prevent potential performance issues and unintended behavior in asynchronous code. When await is used inside a loop, it can cause each iteration to wait for the previous one to complete, leading to slower execution. This can be particularly problematic when dealing with large datasets or time-sensitive operations. It's fine to disable the rule if you must perform an async operation synchronously.

By enforcing the no-await-in-loop rule, developers are encouraged to find alternative approaches, such as using Promise.all or restructuring the code to perform asynchronous operations in parallel. This can significantly improve the efficiency and responsiveness of the application.

Code example where eslint will warn the developer about a potential performance issue:

async function processItems(items) {
  for (const item of items) {
    await doSomethingAsync(item);
  }
}

For more details see the documentation

[ThaNarie]

Sometimes we want/need do to things sequentially

How often is that actually the case, versus preferring parallel execution?

I would argue that the limited amount of requiring sequential execution and adding an eslint-disable are nothing compared to the amount of times parallel is preferred.

Adding the risk of accidentally doing it wrong, I very much like this rule.

As an added benefit, the eslint-didsable is self-documenting, as it indicates to everyone that you intentionally require sequential execution. Without the rule it's ambiguous, and others that see the code might want to change it to parallel to improve performance.

[edgardz]

Well, adding eslint-disable pretty much "fixes" all the linting issues. And this is pretty much what devs do dozens of times on each project, to the point that the rules are not helpful anymore but an obstacle to overcome. The whole point of loosening the linting rules is to find a middle ground where devs rely on them, instead of fighting them.

[ThaNarie]

The whole point of loosening the linting rules is to find a middle ground where devs rely on them, instead of fighting them.

I'm not disagreeing with that at all.

And this is pretty much what devs do dozens of times on each project

Hence my question about how often that's the case for this specific rule :) Gathering feedback.

Are you using sequential that often compared to parallel execution?