

Win a signed copy of Programming in Lua 3rd Edition - aDevilInMe
http://thread.gmane.org/gmane.comp.lang.lua.general/96963

======
chubot
This is one of the best plain _programming_ books out there. Even if you don't
have a particular interest in Lua, you'll learn something.

I've heard it compared it to "The Unix Programming Environment" in terms of
being a classic, and I agree.

I find myself coming back to this book again and again, even though I haven't
been able to justify Lua on any projects really. Just now the treatment of
coroutines really helped with using Python coroutines (not generators).

~~~
ufo
What coroutines are you talking about? I was under the impression that Python
coroutines were when you use the `yield from` and `.send` features nest
generators and to communicate values between them...

~~~
chubot
Yeah exactly... it escaped me for an embarassingly long time that this is
exactly the same scheme used in Lua. In Python you can create a coroutine,
then use yield and send(). In Lua you have coroutine.create/yield/resume. They
work in exactly the same way.

It was my understanding that implementing "trampolining" as explained by
<http://dabeaz.com/coroutines/> in Python 2.5 is basically what "yield from"
does in Python 3.3. Maybe "yield from" is more efficient. If anyone has any
comments on that I'd be interested.

The PIL book has a few interesting examples of things that you can do with
coroutines that are not possible with generators (plain yield). Also there is
a paper by the Lua authors called "revisiting coroutines" -- although that was
published in 2009, they don't acknowledge that Python has coroutines! They
talk about Python's "limited" generators.

EDIT: Sorry, "yield from" is for generators. So coroutines are yield/send().
Generators are yield/yield from.

"yield from" is indeed the equivalent of coroutine trampolines, but for
generators.

The right way to think about it is that coroutines are a push-based model
while generators are a pull-based model. They don't mix, despite using the
same keyword! If you want to mix them you would have to introduce a buffer
between them or something. This is somewhat explained in Beazley's material.

And coroutines are more powerful than generators, as explained by the
"revisiting coroutines" paper (and which should be obvious if you try to
transcribe some coroutine patterns into generators.) Even after adding "yield
from", which removed one restriction of generators, coroutines are still more
powerful.

~~~
ufo
You can also use coroutines for a pull-based model. In the end it just depends
on whether you read or write data when you yield and both Lua and Python can
do that.

IIRC, the biggest difference between the languages is that Lua coroutines are
"stackless" so you can have "non-generator" functions calling "generator"
functions. In Python you need to use something like `yield from` and that
turns the calling functions into generator functions as well.

~~~
chubot
I don't think that's the case. "yield from" is apparently for generators,
which allows yielding from "subgenerators" (i.e. a generator can invoke
another generator which is part of its stream).

But you can already the equivalent with Python coroutines (and Lua), using the
trampolining technique in Beazley's material (and PEP 342).

Python coroutines aren't any less powerful than Lua coroutines. If you still
believe they are I would be very interested in an example.

~~~
ufo
Its not about power its about expressiveness. For example, in Python you can't
pass a generator function as an argument to `map`, since map doesn't use
yields when calling its argument. On the other hand, in Lua the "generator-
ness" is a runtime concept instead of a syntactic one so you can pass a
generator to `map` and it will still work fine.

I won't bother asking what model is the better one. The Python version is more
rigid but its also more explicit...

~~~
chubot
No, Python has BOTH generators and coroutines. Lua has only coroutines. You're
thinking of them as alternatives, whereas Python has a superset of what Lua
has.

Builtin map() is for generators only. You can write map for coroutines as
well:

    
    
        def mapcoro(func, target):
          while True:
            value = (yield)
            target.send(func(value))
      

(untested, I think you need to catch StopIteration around the yield line)

You can do everything with Python coroutines that you can do with Lua
coroutines. You could say that Python doesn't need generators, but that's a
different argument. I agree it is confusing... I was confused for a long time.

------
daenz
I use Lua for the scripting front end of my interactive dance software
<https://www.facebook.com/FormConstantDance>

I considered using Python, since I'm very familiar with the language, but in
the end, the ease of embedding Lua in c/c++ sold it for me.

------
nightski
You know what might really get people talking about Lua? Making the primary
resource for learning it available for free following the lead of countless
other languages.

~~~
tedunangst
You mean like this? <http://www.lua.org/manual/5.2/>

~~~
dottrap
And this one too: <http://www.lua.org/pil/> (prior Lua versions are free
online)

------
tomjen3
Is there a good reason to use Lua? Javascript is pretty much the same and
Guile is not only lisp, it is also designed to be used as a scripted language.

~~~
ConstantineXVI
Besides the easier embedability (it's plain C with no dependencies and MIT
licensed), it's (subjectively) a nicer language than JS and more accessible to
the general public than Scheme/Guile, while being just as powerful as both.

And for some reason I can't pin down, it's just fun to hack with.

------
speeder
I tend to get invited to talk about Lua ( including why I am using it ) at
universities and conferences ( like, CONISLI, FLISOL, LATINOWARE ) does that
counts?

~~~
aDevilInMe
Sure, although if there is an output which can be enjoyed by other people such
as a paper, video/audio of the talk etc. then more people I would imagine
would vote for it.

~~~
speeder
Good idea! I will see if any of the archives has a copy...

But they are in portuguese :p

