BBS, Lua, Coroutines, Mongrel2: Part 1 (opens in new tab)

Yeah I love BBSes. Seems a lot of other folks like them too so I'm going to continue hacking on this as the official "something more than chat" demo.

You don't need coroutines to do this - you can use tail calls, if the language provides tail-call optimization. (Python doesn't, but Lua does.) I might post a code sample translating your FSM example later, but I need to go run errands.

I don't have a blog to plug. So, I'll shameless plug my Reddit post regarding coroutines vs. FSMs instead:

http://www.reddit.com/r/programming/comments/9fcna/coroutine...

While I'm not current on the newest version of Python (I switched to Lua around py 2.5), Python generators had some functional limitations - most notably, they could only yield from their main body, not from within function calls, IIRC. Those issues struck me as kind of arbitrary, but were due to how Python interacts with the C stack.

Lua's coroutines don't have those restrictions. I think Stackless Python doesn't have them either (though I haven't used it). Lua is also "stackless" in that sense. Also, Lua's coroutine.yield is a library function, not a keyword.

I'm not convinced coroutines/continuations are a good fit for managing web state, but they do make a lot of other control flow situations easier to manage - "who has the main loop" problems are a non-issue, since they can have an independent main loop.

There's actually a theory of what makes a complete coroutine, similar to what makes a complete closure. I don't remember all of it off the top of my head, but it's basically:

1. coroutines act as pipes that can send (yield) and receive values.

2. coroutines are first class citizens like closures so they can be passed around as values, referenced, garbage collected, etc.

3. they can yield from any point in the stack, so you can use them inside functions deeply nested without any caller N frames up from knowing about it.

4. one side of a coroutine doesn't have to know about the other side, just like functions.

5. you can inspect them to find out if they are running, suspended, etc.

I'm probably missing some things, but the gist is there's very few languages that do all of this. Lua's the only one that really gets them right and makes it easy, with probably Lisp continuations being next. I'm sure there's other languages but I know Python, Ruby, and Java really get these wrong.

I'd also say that Erlang adds one very very sexy addendum to this in that you can take any process and send it over the wire, store it, recover it, etc.

Python has coroutines if you install greenlet:

http://pypi.python.org/pypi/greenlet

It leads to some really slick networking code.

With Stackless Python you can pickle (serialize) tasklets (coroutines). I built a Seaside-style web app in Stackless where each response would get pickled and saved to disk. When a new request with that id comes in you just unpickle it back into a tasklet and resume where you left off. You can do this between processes and machines. I don't see why you couldn't put them in a db but I was just using shared disk. What you're looking for are serializable continuations which some languages can handle.

You can build a FSM using tail calls. (Lua has TCO.) It's really common to do this in Erlang, too.

It's also possible to stream Lua functions, though it's a bit tricky to do with closures.

You can send functions to Erlang processes for execution, so it shouldn't be that hard to do.

The only problem you end up with then is that Erlang is one extreemly ugly little language.

Thanks, that also has a bug but people who try it should know how to fix it. Basically if it bombs because you don't have json then delete the line of code as it does it correctly further down.