PyS60

Both of these are instances of the same fundamental problem, of doing too
much in callbacks.

An important thing to realize is how callbacks from active objects are
handled. Callbacks are not executed in a new thread or in any kind of
separate execution context. Whenever Python waits for a long-running
operation to complete, it starts an active scheduler loop. If requests from
some active objects complete during this wait, the corresponding callbacks
that were triggered will _run to completion_ before processing can continue
after the scheduler loop.

In your code you have callbacks that run for a very long time (for example
in sleepbug.py the use method) and your callbacks contain long-running
operations that start their own schedulers (for example in sleepbug.py you
have ao_sleep and select calls). When a callback is triggered during this
time, you will every time get yet another level of scheduler nesting, and
you will never get out of these loops.

There is really no solution to this other than a coding convention that
keeps the complexity of callbacks at a minimum. In the future we may
consider taking into use some checks that would enforce this simplicity, if
we can only figure out how to do it without crippling legitimate uses of
nested schedulers.

It's unfortunate that the syntax misleads people into thinking the system
is more powerful than it really is.

Working as designed, unfortunately.