4. Why JRuby?
• Dynamic Languages are hot and cool :-)
• To leverage the lovely Ruby language on the JVM
• To make all the nice, proven libraries of the Java platform
available to Ruby code
• The best of both worlds?
• To ease the transition from Java into dynamic languages
• To fight M$ and the DLR?
5. JRuby: The Project
• Ruby on the Java VM
• Partly sponsored by Sun
– Charles Oliver Nutter (Sun employee now)
– Thomas Enebo (Sun employee now)
– Ola Bini (ThoughtWorker)
– Nick Sieger (Digital River, Inc)
• Goal
– Provide a platform to execute Ruby code on the JVM
6. JRuby: The Platform
Ruby source Ruby std. Libs (in ruby)
Ruby native code
JIT compiled
libs rewritten in JIT rubycode
Java Interpreter Compiler (bytecode)
(bytecode)
JRuby Runtime
The JVM
7. Example: The IRB Console
• Download the zip and unzip
• Set JRUBY_HOME=path to unzip place
• Set PATH=%JRUBY_HOME%bin;%PATH%
• Type: jirb <enter>
• Take a tour in the unzipped dirs
• Live example.....
8. Java Integration: (J)Ruby into Java
• With JSE6, you can use JSR-223 APIs
– Needs: https://scripting.dev.java.net/
• Or else, there is BSF integration
• Or, simply code it
– Ruby runtime = Ruby.getDefaultInstance()
– runtime.evalScript(”...”)
• Live example....
9. Java Integration: Java into (J)Ruby
• Low-level API
– Wrapping in JavaObject, JavaMethod, JavaField
– java_method.invoke(java_object, java_field, ...)
• High-level API
– Wrapping low-level API in a JavaProxy
– A JavaProxy has all the methods of the Java object
wrapped
– Calls the actual Java object methods using low-level
API
– Output from a proxy is automatically wrapped
• Live example....
10. Performance Tips
• Turn on -server VM (JVM setting)
• Turn on JIT (JRuby setting)
• Turning off ObjectSpace
– Breaks ability to look into the heap from app. code
• Turn on thread-pooling
– Ruby uses green-threads (yuk!)
– Some Ruby libs spawns a lot of threads
– Expensive with native threads
12. Why Rails Integration?
• Rails deployment can be complex
– Rails is not thread-safe
– Multi-process deployment
– Needs load-balancing front-end
– Harder to monitor
– Not everything in one deployment unit
• Rails deployment for a Java-shop
– A completely new platform to learn
– Not what Joe-systems-management likes
– Existing (Java appserver) setup not leveraged
13. Parts of Rails Integration
• ActiveRecord-JDBC
– Actually separate, but important part of rails
• RailsIntegration
– A plugin for rails to do war building
– Some session handling code
– A dispatcher servlet into JRuby runtime
14. Installing Rails Integration
• First, you need a rails project
– Gem install rails -y
– Rails helloworld
• Then, install rails plugin
script/plugin install
svn://rubyforge.org/var/svn/jruby-extras/trunk/railsintegration/plugins/goldspike
15. Installing ActiveRecord-JDBC
• Gem install activerecord-jdbc -y
• configenvironment.rb
– After the ”require File.join(...'boot')” line, add this:
if RUBY_PLATFORM =~ /java/
require 'rubygems'
require 'active_record'
require 'active_record/connection_adapters/jdbc_adapter'
RAILS_CONNECTION_ADAPTERS = %w(jdbc)
end
16. Using Rails Integration
• See the new tasks with: ”rake --tasks”
• Using war packaging
– Rake war:standalone:create
– Rake war:standalone:run
17. Using ActiveRecord-JDBC
• Generate model and controller
– scriptgenerate model post ...
– scriptgenerate controller Post
– Add ”scaffold :post”
• Edit configdatabase.yml
– Adapter: mysql
– Url: jdbc:mysql://...
• Migrate
• Add jdbc driver jar dependency in ”configwar.rb”:
– maven_library 'mysql', 'mysql-connector-java', '3.1.12'
18. Deployment in a war
• Why?
– One deployment unit
– Leverage JEE appservers multi-threading
• RailsServlet
– Instantiates a pool of Ruby runtimes
– Pooling overcomes threading issues
– Rails is initialized in each runtime
– Dispatches incoming requests into rails
20. Why is this hard? (part 1)
• No RubySpec (yet)
– There is a wiki working on this
• Large parts of the Ruby platform is in native code
– Must be rewritten in Ruby or Java
– Rubinius might help out here
– Lots of 3. part libs will not be rewritten
(as part of the JRuby project)
• Parts of the Ruby platform are un-doable on JSE platform
– Green threading
– File operations
– Fine grained timing
21. Why is this hard? (part 2)
• Dynamic languages are different!
– You can do things that are not possible in statically
typed languages
• The JVM is not a good fit for dynamic languages (yet)
• JVM fixes for dynamic languages
– Invokedynamic
– Code hotswapping
– JSR-292
22. Performance on the JVM
• Today
– Significantly slower on JRuby
– But, not many optimizations done (yet)
– Faster on some places where hotspot kicks in
• Future
– Invokedynamic, hotswapping, etc...
– Might enable better performance
– The hotspot compiler might kick-ass then
• What is ”performance enough”?
– How much do you really need if you can scale out?
– Ease of Development is important
23. Ruby 1.9
• Current Ruby 1.8 mostly run on MRI
• Ruby 1.9
– The upcoming implementation to measure against
– Will be a true bytecode-based VM
• VM bytecode targeted ruby language
– Will give better ability to tailor performance to the
language
24. Other X-platform Ruby Projects
• XRuby
– Ruby to Java Bytecode Compiler
• Rubinius
– A Ruby implementation in Ruby
– Based on Smalltalk-80 (Squeak)
– Rewriting the complete Ruby standard lib. in Ruby
– Others can use the rewrite on their implementations
• Ruby on .Net compiler
– Gardens Point Ruby.NET compiler (MSIL based)
– M$ IronRuby (DLR based)
25. M$: Dynamic Language Runtime
• A Dynamic Runtime on top of the CLR
• Type System
– A unified type-system for dynamic languages and the
.Net platform
– Passing objects between IronRuby, IronPython and
.Net platform
• Part of IronPython sources now (I think)
• SilverLight will utilize this (I think)
26. Who are doing the JRuby Dance?
• ThoughtWorks
– Mingle
– CruiseControl.rb (simply ruby)
– A lot of Ruby projects
• Others, I guess!?
– This is new stuff
– Promising and steaming hot, but new stuff!
