Inner Platform Effect

- real time games involving multiple characters (which run some sort of logic to appear human/intelligent, often running some priority queue/stack machine)

- simulations involving multiple agents/actors which should (appear to) run simultaneously (e.g. network simulation of multiple routers/computers communicating, running some routing protocol/network program)

- other systems where users are inputting their own programs (like programming challenges) or where combining multiple effects may potentially cause infinite loops (like in some card games)

- systems where a user receives a potentially untrusted program which, even if sandboxed from accesssing external data resources, may exhaust cpu time and memory (like the web)

These most often lead devs to create their own domain specific language and interpreter (or embedding another language like Lua), to be able to step through programs in order to simulate simultaneity (by running each, say, simulated router for a few steps each in turn) and/or prevent one component from using all the resources (by counting cycles/instruction steps).

But this always because the popular languages we use don't allow one to run another interpreter of that language recursively, for a limited number of steps. This disappoints me, because this is less expressive power/flexibility than what a CPU provides at the base level (with timer interrupts or breakpoints).

I love to link to this page: https://stackless.readthedocs.io/en/2.7-slp/library/stackles... because Stackless Python is one language that can do this. On the other hand, security-wise, Python is awful because unlike with WebAssembly for example, there aren't any isolated processes/containers, and there likely never will be this level of secure containment.

Hmm..yes.