lua-channels

> 2. Python's runtime is completely and utterly incapable of threading. Threading being almost essential to any decent user interface, this whole idea falls flat. While you're AFAIK correct about running Python on mobile devices, and I think anyone will admit that Python's performance has never been great, one can have a great UI without threads: use coroutines and channels instead. Fortunately, Python does have coroutines, and a channel library can be built in the fashion of Lua's channel library (https://github.com/majek/lua-channels). I don't know if anyone has done it yet, I'll grant, but a cursory look suggests that it's possible. The basic idea is that one would spawn a coroutine to handle each UI element, and the coroutines would send messages to one another on channels. I've no idea how fast it would be (at a guess: terrible), b

I've submitted a pull request for your review: https://github.com/majek/lua-channels/pull/3

Fancy giving me a hand? https://github.com/majek/lua-channels/issues/1

I'll do my best, but it's a bit hard to explain. Basically channels are yet-another synchronization paradigm like locking or shared memory, some people like it some don't. Channels are an implementation of Hoare's CSP [0]. Channels can be passed around, the same could be said about Lua coroutines. But with channels you get more flexibility: - you can "block" on many channels at once using the "chanalt" statement. You can "resume" only one lua coroutine at a time. - channels they can buffer messages (ie: channels can queue several values) - many coroutines may "send" a value to a channel at the same time, many coroutines may try to "listen" (receive) a value at the same time. - finally you can pass a channel over a channel I find channels, as opposed to many other synchronization paradigms, to be composable and generally nice in use. It's

Author here. Here's some context [1]: Lua supports cooperative coroutines out of the box, which is great. Unfortunately Lua lacks built-in communication primitives. To fill the void I've implemented Go style channels in pure Lua. Of course abstract channels without any concurrent IO aren't terribly useful, but fortunately the code is pretty straightforward and adapting it to your event loop shouldn't be a problem. The code is ~400 lines of code + ~200 of tests. For example, here's [2] Eratosthenes sieve following Russ Cox explanation [3]. [1] http://lua-users.org/lists/lua-l/2013-08/msg00546.html [2] https://github.com/majek/lua-channels/blob/master/sieve.lua [3] http://swtch.com/~rsc/thread/