I'm fairly fluent in Ruby and have been recently looking for a cross-platform graphical environment for Ruby which is how I found out about ruby-processing. I downloaded the samples, got them running under Ubuntu and it looks very nice indeed.

However, I'm having a bit of a hard time understanding how Ruby, JRuby, Java and Processing all related to each other when I run one of the samples.  For instance, as I didn't install JRuby on my Ubuntu system, does this mean that ruby-processing is using the native Ruby interpreter on my system?  If so, how is Ruby calling the Java classes that compress Processing?  I'm assuming the Processing API is essentially implemented in Java, but I'm not sure of this.

I checked the ruby-processing Wiki, but I didn't see much to describe what's happening behind the scenes.  Could someone provide a link to some on-line resources that describe how Ruby, JRuby, Java and Processing all related to each other?  Or, perhaps provide a brief description here.

I obviously have a bit of learning to do about JRuby and Processing, but I thought by posting here I could accelerate some of my learning.

Thanks,

Mike Thompson

Hi Mike.

I'll try to add a page sometime soon on the wiki about Ruby-Processing internals, and I'll update this post when that happens, but for now here's a quick overview:

When you run the rp5 command, it starts out in regular ruby, ensuring that your sketch exists, figuring out the command you want to run and generating any applets or applications if that's what you asked for...

If rp5 determines that you want to run a sketch (either run, watch, or live), it replaces itself with a Java process that loads JRuby, and JRuby proceeds to load the Ruby-Processing codebase and start the sketch.

Things get interesting inside of JRuby, though, because you're running a processing sketch inside of a class hierarchy that looks like this:

processing.core.PApplet  (Java Space)
Processing::App                 (JRuby Space)
YourSketch                          (JRuby Space)

When you call methods inside of your sketch, JRuby may be calling methods in either JRuby or Java space, depending on whether the method is defined in the Processing::App or the processing.core.PApplet. For most methods defined in the Processing API, that means calling into Java, with JRuby taking care of converting all the arguments. However, some useful methods (like load_library and render_mode) are defined in Ruby.

Hope that clears things up a bit. It's really just a thin skin between Processing and JRuby, and relies heavily on the fact that JRuby classes are able to subclass Java-defined classes.

-- omygawshkenas

I've posted a page that talks about some of the details on the wiki:

http://wiki.github.com/jashkenas/ruby-processing/ruby-processing-internals-and-jruby-tricks

Hope it's useful.

The vanilla Processing IDE might be doing some behind-the-scenes resizing that I'm not aware of, but your image isn't quite the right size. You can print out the dimensions of the image both before and after you resize it, like so:

@starfield  = load_image "space.jpg"  
puts "before width: #{starfield.width}, height: #{starfield.height}"
starfield.resize width, height
puts "after width: #{starfield.width}, height: #{starfield.height}"

and you'll get this output:

before width: 819, height: 501
after width: 800, height: 500