concretemarble

The whole point of ECS is cache-friendliness, so it's kind of the same. Besides there is nothing novel in their implementation. Putting frequently accessed component together is quite an old technique.

Your logic is flawed in that you didn't clarify the definition of "small". How small are we talking about? This is a simple statistical question.

Calculate the number of sexual harassment reports of all US companies normalized by employee counts, and check if the number of sexual harassments at Blizzard is statically significantly higher. If so, then it is plain reasonable to suspect Blizzard has certain issues that cause this.

Whether the females are broadly and uniformly harassed is not a good indicator. As long as the rate is significantly higher than other company, it could indicate some problem and is worth investigation, even if the total number of harassment cases are small compared to the total female employees.

What if they say "Only a small portion of the females were harassed in our company! They are not broadly and uniformly harassed! How dare you say we have a constant sexual harassment problem!"

I don't think this logic makes sense. For things that shouldn't happen in the first place, just a few cases speak a lot.

If anyone is interested in what Roblox is capable of, check out the following games:

Roblox Hellreaver https://www.youtube.com/watch?v=3tMpXnRG19U&ab_channel=Popta...

and

Waterloo https://www.youtube.com/watch?v=WS4KBNTocQY&ab_channel=Pixel...

One of the benefits of Roblox is it's extremely unopinionated in aesthetics and gameplay mechanics, which is quite different from Minecraft. Combined with zero upfront cost developing/publishing/operating and large platform user base, it opens up lots of possibilities for developers.

When tasks are unrelated, you also likely don't need them all at the same time for the next stage of pipeline. You can simply await it when you need it.

  var p_t = GetUserPermission(username);
  var c_t = GetServerConfig();
  var m_t = GetMessageOfTheDay();
  function_to_call1(await p_t, await c_t);
  function_to_call2(await m_t);

This does not look any more complicated than a non-async function. Not sure how this example justifies your claims.

Besides, even if your example is valid, the usage of Task.WhenAll has nothing to do with your claims either. The use of async/await is majorly for scalability. Being able to make several network calls concurrently is not the major concern. Even if you await at each async call, you still achieve better scalability because threads won't be blocked for async calls and can work on something else.