event-loop | ReactPHP 's core reactor event loop that libraries can use | Reactive Programming library

I figured out with xbbg blp.bdp function which does similar thing. This is a good substitute if you have a massive bbg function pulling RT price. PyXLL allows you to input an array of tickers which saves a lot of time. I hope this could save someone some time :)

I'd like to know by what criteria implementors run? How do they evaluate the "important-ness" of queues?

That's basically their call, a design choice made from years of experience looking at how their tool is being used and what should be prioritized (and also probably a good part of common sense).

The WHATWG indeed doesn't define at all how this task prioritization should be implemented. All they do is to define various task-sources (not even task-queues), to ensure that two tasks queued in the same source will get executed in the correct order.

The closest we have of defining some sort of prioritization is the incoming Prioritized Task Scheduling API which will give us, web-authors, the mean to post prioritized tasks, with three priority levels: "user-blocking", "user-visible" and "background".

To check what browsers actually implement, you'd have to go through their source-code and inspect it thoroughly.
I myself already spent a couple hours in there and all I can tell you about it is that you better be motivated if you want to get the full picture.
A few points that may interest you:

• All browsers don't expose the same behavior at all.
• In Chrome, setTimeout() still has a minimum delay of 1ms (https://crbug.com/402694)
• In Firefox, because Chrome's 1ms delay was producing different results on some web-pages, they create a special very-low-priority task-queue only for the timers scheduled before the page load, the ones scheduled after are queued in a normal priority task-queue. (https://bugzil.la/1270059)
• At least in Chrome, each task-queue has a "starvation" protection, which prevents said queue to flood the event-loop with its own task, by letting the queues with lower priority also execute some of their tasks, after some time (not sure how much).

And in the end I'd like to see an example that shows the order of these queues, if it is possible.

As hinted before, that's quite complicated, since there is no "one" order.

Your own example though is quite a good test, which in my Chrome browser does show correctly that the UI task-queue has an higher priority than the timer one (the while loop takes care of the 1ms minimum delay I talked about). But for the DOMContentLoaded though, I must admit I'm not entirely sure it shows anything significant: The HTML parser is also blocked by the while loop and thus the task to fire the event will only get posted after the whole script is executed.

But given this task is posted on the DOM Manipulation task source, we can check it's priority by forcing a other task that uses this task source, e.g script.onerror.
So here is an update to your snippet, with a few more task sources, called in reverse order of what my Chrome's prioritization seems to be:

There is no need to use timers or sleep for this, because the status-bar sends a messageChanged signal every time a temporary message changes (including when it's removed). This can be used to create a simple call-back loop that does what you want:

This is safe, because what's inside this function:

I think what you search is asyncio.Future if I understand you correctly.

In cases like this, it's ususally a good idea to go to the project's GitHub and search for the error message in issues:

https://github.com/gera2ld/async_dns/issues?q=is%3Aissue+Event+loop+is+closed

It gives us one result and the solution is in the last comment:

https://github.com/gera2ld/async_dns/issues/26#issuecomment-844850252

The final code:

QObject::deleteLater in this case is essentially just erring on the side of caution. There's no reason you couldn't simply delete the objects if you're absolutely certain there's no chance the object will be accessed.

In practice though you'll save way more time simply using QObject::deleteLater and letting Qt take care of it for you, compared to the hassle of debugging some random-seeming crash during runtime or on exit because there happens to be an access to an object you manually deleted.

To answer your question, number of CPU might leverage in forked child process, but child process is more of a memory consuming process.

Redis background saving schema relies on the copy-on-write semantic of fork in modern operating systems: Redis forks (creates a child process) that is an exact copy of the parent. The child process dumps the DB on disk and finally exits.

In theory the child should use as much memory as the parent being a copy, but actually thanks to the copy-on-write semantic implemented by most modern operating systems the parent and child process will share the common memory pages.

However, to maximize CPU usage you can start multiple instances of Redis in the same box and treat them as different servers. At some point a single box may not be enough anyway, so if you want to use multiple CPUs you can start thinking of some way to shard earlier.

It's not very frequent that CPU becomes your bottleneck with Redis, as usually Redis is either memory or network bound.

You also might want to check out Redis hardware requirements link, Redis already listed the recommended hardware set up per function.

The difference is in the scope of var and let variables.

With var you have a function scope and therefore only one shared binding. With let you have a block scope and you get for each iteration a new binding.

Because of the closure, the function you declare inside the loop has access to all the variables in its scope and parents scopes until the garbage collector is on.

More details can be found on this answered question.