From: Chuck Messenger <cmessengeratinamedotcom@...>
Date: 2001-04-25T02:40:08+09:00
Subject: [ruby-talk:14166] Re: Stripped-down Ruby?


"Yukihiro Matsumoto" <matz@zetabits.com> wrote in message
news:988128334.442155.3210.nullmailer@ev.netlab.zetabits.com...
> Hi,
>
> In message "[ruby-talk:14104] Re: Stripped-down Ruby?"
>     on 01/04/24, "Chuck Messenger"
<cmessengeratinamedotcom@spamfooler.com> writes:
>
> |Just for reference (for any Deja News hunters out there), I found pretty
> |much exactly what I was looking for, courtesy of Donavon Keithley: Lua.
> |See http://www.lua.org
>
> Lua has far better embedding API, despite it has far less features
> (OO, for example) than Ruby.  I think I will work on embedding API in
> the future though.
>
> matz.

That would be excellent!  If I were able to choose between Ruby and Lua for
my app (that is, if Ruby was as embeddable as Lua), I'd probably choose
Ruby,
since the language appears to be more powerful/expressive.  (I've only read
the
manuals so far -- haven't tried developing apps in either language yet).

Some food for thought:

What makes for a very nice embeddable language is to have layers.  For
example,
Lua separates out the "core" library from the "I/O" library, etc.  So, if
you don't
want to have any OS hooks (whether for security reasons or code size), you
can
use just the lowest layer.  It needs to be easy to inspect the set of core
files to
see that they are clean.  This is how Lua is, which is nice.  It's been easy
for me to
clean out all "dangerous" OS hooks from the core libraries (there weren't
many, but
now there are none, in my version).

The Lua embedding API is quite nice, too.  It's fully reentrant, with a
lua_State
structure holding everything related to one Lua environment.  Something Lua
lacks, which I'd find useful, would be to control where the memory comes
from
(rather than just calling malloc()).  I'd rather if my app could provide Lua
whatever
memory it needs, since I have my own memory management regimen.  It isn't
too hard to put this into Lua -- the malloc/realloc/free routines are only
called in
a handful of places.  But still, it would be nicer if this were encapulated
in the
API.  As it is, I'll have to merge my mods into each release of Lua.

Also nice would be the ability to put a maximum on the rough number of
"program
steps" taken.  This is to prevent malicious code from hogging resources.
Each
Ruby VM could then be fully controlled -- no OS access, a ceiling on the
amount
of RAM, and a limit to the CPU usage.

An easily/nicely embeddable Ruby would make a very powerful "competitor" in
the extension languages arena, which currently consists of (to my knowledge)
the Lisp-based languages (e.g. Guile), the Forth-based languages (e.g.
Ficl),
the string-centric language Tcl, the C-like hash-table-centric language Lua,
and
the vaguely C-like SimKin (which I don't understand well).  I'm sure there
are
others.  But Ruby, with its very clean object-oriented design, would rival
the
expressive power of the Lisp languages, while avoiding their unfriendly
syntax.
It would probably have a larger footprint than Lua, so the two might be
complementary.

I think I'll design my app so I can plug in other scripting languages in the
future,
in the hope that you do make an embeddable Ruby some day (he said
dreamily, staring out into space...)


    - Chuck