I tossed this message off to the Ruby-core list about a month ago, and
sent a follow-up email today. The basic idea is that if there were a
Kernel#run_script method or similar, all Ruby apps that want to launch
external scripts could do so in a platform and
implementation-independent way. In future versions of Ruby and in
JRuby today, that could mean launching the additional script within
the current process, but even now it would provide a simpler way to
launch external scripts.

Does anyone have an opinion on this?

---------- Forwarded message ----------
From: Charles O Nutter <headius / gmail.com>
Date: Jan 25, 2006 8:50 AM
Subject: Launching Ruby scripts and the future of MVM
To: ruby-core / ruby-lang.org


Hello again from the JRuby project!

It has come to our attention that there may need to be a standard way
to tell Ruby to launch a given script in a new interpreter engine.
Currently, it appears that many different approaches are used, ranging
from launching a separate process to forking and eval'ing a given
script. With the possibility of Ruby running in a multi-vm scenario
not far off (already possible today with JRuby and perhaps possible
soon in YARV) I believe it would be beneficial to have a way of
telling Ruby to "run this script in a new interpreter" and allow the
underlying ruby implementation to decide whether to launch a new
process or not. A potential method might be Kernel#run_script.

The issue we have with JRuby is that certain applications, Rake for
one, tend to want to launch subscripts in new Ruby interpreters. While
this is straightforward and relatively low-cost in the C Ruby world,
it incurs a severe performance and memory penalty in the JRuby world.
Launching a new "JRuby process" incurs the added pain of starting up a
new JVM process, not a trivial bit of work. This currently works as
expected, but is very slow and resource-intensive.

Perhaps it would be ideal if applications could call something like
Kernel#run_script, allowing the underlying Ruby implementation to
decide how to run that script. In today's 1.8 Ruby implementation,
that may simply mean running an external process, either by using
popen or system. In implementations like JRuby or YARV, the run_script
call could be handled by launching a new Ruby VM within the same
process, avoiding the process-startup penalty. It would allow us to
run some of the most complicated Rake scripts all in a single JVM
process with JRuby, utilizing our MVM capability very effectively.

What thoughts do you have? I know 1.8 is supposed to be pretty well
settled, but it sure would help us if this idea were implemented
sooner rather than later, so third-party apps could start using a
platform and implementation-independent mechanism for launching Ruby
scripts.

- Charlie



--
Charles Oliver Nutter @ headius.blogspot.com
JRuby Developer @ jruby.sourceforge.net
Application Architect @ www.ventera.com