Re: co-routines [was Re: Unicode]

[Jean-Claude Wippler <jcw@...>]

Roberto Ierusalimschy <roberto@inf.puc-rio.br> wrote:

[co-routines and stackless]
>We had three goals in mind: restricted co-rotines (only Lua), generic 
>co-routines, and multi-thread. Lua stackless would demand lots of work, and 
>would solve only the first goal; it would be useless for the other two. 
>Multiple stacks solves the other two goals (with a small external help), it 
>is quite simple to implement, and has no impact in performance. 

Please forgive me for addressing you directly, and for a somewhat off-
topic response.

I have been going through all the archived Lua messages and all html
documents, in an attempt to get up to speed with Lua as quick and in
depth as possible (my background is Tcl/Python/C++/Forth).  Having been
involved in open source for some time now (much of my own work is public
domain nowadays), I would like to contribute to Lua if possible, to help
it evolve in issues which matter to me.

After yesterday's "Son of Lua" post on lua-l, I am very concerned about
the direction and future of Lua.  As a smaller language, it seems that
the risk of people taking it in different directions is more acute than
with larger bodies of code.  This would be very unfortunate, since it
would prevent consolidation and growth of a common core and user base. 
Edgar Toernig's work is important IMO, because some changes appear to be
very valuable (though a source code reformatting I could have done without).

Before starting some serious work based on Lua, if have a few questions:
 - is there a page describing the short/mid-term plans with Lua?
 - do you accept patches with feature changes (if deemed useful)?
 - is lua-l a suitable place to start feature/language discussions?

Let me close off by describing my situation: I'm from the Netherlands,
but currently in Canada for a sabbatical year, to work on some new ideas
(self-employed, not in an academic setting).  I wrote a database/
persistence library called MetaKit, with bindings for Tcl and Python (and
C++).  This library is used in a growing number of projects, but the
deployment issues of C and especially C++ are stifling.  My interest in
Lua is as a "scripting in scripting" language: I have started turning Lua
into an extension for Tcl and plan to make bindings for Python and
several other contexts (e.g. Perl, Ruby, Java, Squeak, COM).  This gives
me the ability to write *my* code in Lua (+ C where needed), and deploy
the results in a range of languages without compile/build problems.  In
the past I have considered Forth for this role (as explored in my
Minotaur project), but this is somewhat low level.  My most recent
experiment is a vectorized/type-safe variant of Forth called Thrive, but
now it looks like much work could be avoided by adopting Lua instead.

The projects mentioned above are listed at http://www.equi4.com/jericho/

Again, my apologies for taking your time in this way.  Thank you and your
team for creating such an innovative language, with all the "right"
trade-offs.

Regards,
Jean-Claude Wippler