Help Us Set Priorities for JRuby 1.3

With JRuby 1.2 almost out the door, I want to talk a bit about where we should go with JRuby 1.3. There's always more work to do, but in this case there's a few different directions we could probably go.

Some obvious items will continue to see work:

• 1.9 libraries, interp, compiler, parser
• 1.8.6 bugs
• "Pure ruby" application support, like Rails deployment stuff (Warbler, AR-JDBC)

But there's other areas that we may want to prioritize:

• 1.8.7 support
• Ruby execution performance (how fast do you want it?)
• Specific library performance (YAML, IO, Java)
• More Java integration improvement/refactoring (esp. subclassing)
• "Compiler #2" to produce normal Java classes from Ruby
• Improvements to AOT compilation (all-at-once, eliminate runtime codegen)
• Expand support for embedded/mobile platforms

And there's a number of internal chores to work on too:

• Start generating most of the call path, to reduce duplicate code
• Specific-arity optimizations for block yield (could be big)
• Compiler cleanup and refactoring
• Modularization of core classes that aren't valid on applet, Android, secured envs, etc; also may allow shipping smaller runtimes
• More startup perf work; I have a few ideas

As always, there's way more tasks than the few of us committing to JRuby can work on, so I think we need to hear from users what's important. Any of these? Other items?

JRuby on Java ME

A number of folks have asked us over the years whether JRuby could run on a Java ME-enabled device. I've always said I believed it would be possible with enough trimming. Strip out all the libraries that ME doesn't support, and you should be left with a runnable "core" of JRuby. Roy Ben Hayun, formerly of Symbian and (I believe) now working at Sun, actually proved it possible but difficult back in 2006 with his JRubyME project, a stripped down JRuby 0.9.8. But that didn't have compiler support, and we were still dog slow in 2006. Has JRuby, with two years of work behind it, grown too complex to run on an embedded device? Is the Rhodes project right when they say JRuby is too large for this to work?

Tony Arcieri, of Revactor fame, put a bug in my ear about Java ME again this week. He's interested in running Ruby on a device hosting the Connected Device Configuration (CDC) level of Java ME. Specifically, the device in question supports CDC plus the APIs included in the Personal Basis Profile (PBP). CDC is probably about the smallest ME profile JRuby could reasonably run in, since anything lower (like CLDC, the Connected Limited Device Configuration) and you're reduced to the most basic collections, IO, and utility APIs.

So, I'm happy to announce that the JRuby CDC Project has spawned out of the JRuby codebase.

Here's what it looks like running, using Sun's reference implementation of CDC+PBP:

~/cdc/Optimized_nosym$ bin/cvm -classpath ../jruby.jar org.jruby.Main -X-C -e "[1,2,3].each {|i| puts i}"
1
2
3

The "cvm" is Sun's reference implementation of an embedded JVM, and this particular package includes the PBP level APIs as well. The jruby.jar here is the one I've stripped in the jruby-cdc project, but with the additional step of retroweaving it back to Java 1.3-compatible bytecode.

My intention with this is to get it running with a base set of Ruby classes but with Java integration still functional. That will allow most basic Ruby scripts to work while providing access to the rest of the Java APIs for bits I had to rip out (like IO APIs)

It's only running interpreted right now, just like the Android version of JRuby, but as in that case I expect most people will want to precompile Ruby code and ship it all as one unit.

Why bother? Well, there are still a lot of Java ME devices out there. And while the device you carry in your pocket may be growing beyond Java ME, the set-top box or Blu-Ray player in your living room is just starting to reach that level. The technology is still sound, if perhaps less obvious than an iPhone or Android. And hey, we want "Ruby everywhere," don't we?

Where do we go from here? I think this and Ruboto are proof that damn near anything is possible with JRuby. It really only took me a couple days of trimming to get this far. Fully supporting Android in Ruboto will not take long, and other "mini ruby" profiles are possible for other platforms and use cases as well. It just takes a little imagination, and maybe a few late-night hacking sessions.

Now...for my next trick...

Ruboto Is Your Friend

Ok, so I intentionally made my last post a bit of a "tease". You can't fault me for trying to drum up a little buzz, yeah? And hey, I spent almost as long fiddling with that logo as I did hacking JRuby to run on Android. Here it is again, just for good measure:


On Monday night, the local Ruby group (Ruby Users of Minnesota, or RUM...great buncha guys) hosted three talks: one on Android development, one on iPhone development, and one on migrating from Struts to JRuby a bit at a time. The Android talk kinda hooked me, even though I was working on last-minute JRuby 1.2RC1 issues and not really paying much attention (sorry, Justin).

I'd considered getting JRuby working on Android before, since it's compatible with most Java 1.5 language features, has a much more extensive library than any of the Java ME profiles (which hopefully will be remedied in future ME profiles), and represented the best chance for "mobile JRuby" to date. I had tweeted about it, scammed for a free G1 phone, and briefly browsed the online docs. I had even downloaded it back in early January...but I'd never bothered to try.

So late Monday night, I tried. And about an hour later it was running.

What I Did

There's really two sides to the Android SDK. There's the drag-and-drop fluffy-stuffy GUI in the form of a plugin for Eclipse. That was my first stop; I got it installed, created a sample project, and ran it in the emulator. It worked as expected, and I'll admit it made me want an Android phone a bit more. I'll be the first to admit I've been skeptical of Android, but at this point it's hard to argue with a totally open platform, especially since it has a shipping device now. So yeah, SDK plus sample app was easy and appetite-whetting.

Then I tried to pull in JRuby's main jar file. Nothing seemed to work right. I got errors about not having defined an "application" in some XML file, even though it was there. There was no obvious information on how to add third-party libraries to my app, and I certainly may have done it the wrong way. And of course my lack of knowledge about the structure of an Android app probably didn't help. But ultimately, since I didn't really need a full-on application, I started to dig around in the SDK for "another way".

Not one for reading documentation, I immediately started running the executables under "tools" with --help and guessing at combinations of arguments. Immediately I saw "emulator" and started that. Yay, an emulator! Then I saw dx, which looked intriguing. A-ha! It's the tool for converting an existing class or jar into Dalvik bytecode. A bit more fidding with flags, and I finally found the right incantation:

dx -JXmx1024M --dex --output=ruboto.jar jruby.jar

For the newbs: that's -JXmx1024M to allow dx to use up to a gig of memory, --dex to convert to Dalvik bytecode, and --output to specify an output file.

So, suddenly I had what I assumed was a Dalvik-ready ruboto.jar file. A quick jar -t confirmed that everything appeared to be there, along with a "classes.dex" file.

...
builtin/yaml.rb
builtin/yaml/store.rb
builtin/yaml/syck.rb
classes.dex
com/sun/jna/darwin/libjnidispatch.jnilib
com/sun/jna/freebsd-amd64/libjnidispatch.so
com/sun/jna/freebsd-i386/libjnidispatch.so
...

There were also a bunch of warnings about "Ignoring InnerClasses attribute for an anonymous inner class that doesn't come with an associated EnclosingMethod attribute." but warnings don't stop a true adventurer. I pressed on!

So, the next step was getting it into the emulator, eh? Hmm. Well there's no "upload" option in the emulator's OS X menu, and nothing obvious in the Android UI. There must be a tool. Like maybe a debugging tool of some kind... like a "jdb" but for Android. Hmm.....this "adb" executable looks promising...

$ ~/android-sdk-mac_x86-1.0_r2/tools/adb --help
Android Debug Bridge version 1.0.20
...

Ahh, bingo. And one of the adb subcommands was "push" for pushing files to the device. A few minutes and experiments later, I figured out incantation #2:

$ ~/android-sdk-mac_x86-1.0_r2/tools/adb push ruboto.jar ruboto.jar
failed to copy 'ruboto.jar' to 'ruboto.jar': Read-only file system

Or at least, I almost had it. Obviously the device was being closed-minded about the whole thing. So back to adb to run another subcommand and have a look around:

$ ~/android-sdk-mac_x86-1.0_r2/tools/adb shell
# ls
sqlite_stmt_journals
cache
sdcard
etc
system
sys
sbin
proc
init.rc
init.goldfish.rc
init
default.prop
data
root
dev

Hmm. "data". That looks promising. I mean, a "data" directory couldn't possibly be read-only, right? So let's give that a try.

$ ~/android-sdk-mac_x86-1.0_r2/tools/adb push ruboto.jar data/ruboto.jar
1702 KB/s (3249363 bytes in 1.863s)

BING! We have liftoff!

Ok, so we've "dexed" the jar, uploaded it to the emulator, and now we want to run it. Back into the shell we go!

There's obviously an sbin above, but it's pretty slim:

# ls sbin
adbd

Another debugging thingy I suppose. Maybe I'll have a look at that later. What about under "system"? I've gotten used to the bulk of my system living under something called "system" from running OS X. And as in that case, "system" was much more populous, with a bin directory containing all sorts of goodies. However one of them jumped out at me immediately:

# ls system/bin
am
app_process
cat
chmod
cmp
dalvikvm
date
dbus-daemon
dd
...

Oh, goodie, "dalvikvm". Could it possibly be the equivalent of the "java" command on a desktop? Could it really be that easy?

# dalvikvm -help

dalvikvm: [options] class [argument ...]
dalvikvm: [options] -jar file.jar [argument ...]

The following standard options are recognized:
-classpath classpath
...

It could! My hands began to tremble. My heart began to pound. Could I simply do

dalvikvm -jar ruboto.jar -e "puts 'hello'"

And expect it to work?

# dalvikvm -jar data/ruboto.jar -e "puts 'hello'"
-jar not yet handled
Dalvik VM unable to locate class 'data/ruboto/jar'
java.lang.NoClassDefFoundError: data.ruboto.jar
...

Curses! Ignoring for the moment how strange it seemed to have a -jar flag that simply doesn't work, I tried specifying -classpath and org.jruby.Main.

Aaaaaaaand...

It blew up with my first official JRuby-on-Android exception!

# dalvikvm -classpath ruboto.jar org.jruby.Main -e "puts 'hello'"
HugeEnumSet.java:102:in `next': java.lang.ArrayIndexOutOfBoundsException
from HugeEnumSet.java:52:in `next'
from Ruby.java:1237:in `initErrno'
...

Hmm. The code in question simply iterated over an EnumSet. After thinking through a few scenarios, I concluded this was not JRuby's fault. It seemed that I had discovered my first Android bug, the first time I tried to run anything on it. And that made me sad.

But only for a moment! The code in question turned out to be unimportant for a normal application; it was simply iterating over a set of Errno enums we use to report errors. Commented it out, and I was on to my next issue:

(I've lost the original error, but it was a VerifyError loading org.jruby.Ruby since it referenced BeanManager which referenced JMX classes. There is no JMX on Android.

Ok, VerifyError because of missing JMX stuff...that's no problem, I can just disable it for now. So, one more attempt, and if it fails I'm going to start doing iPhone development I SWEAR.

# dalvikvm -classpath data/ruboto.jar org.jruby.Main -e "puts 'hello'"
Error, could not compile; pass -d or -J-Djruby.jit.logging.verbose=true for more details
hello

SUCCESS!

More Details

Ok, so we all agree Android dodged a bullet there. But what's the real status of JRuby on Android?

It turns out there were very few changes necessary. I fixed the EnumSet stuff by just iterating over an Errno[] (EnumSet was not actually needed). I fixed the JMX stuff by creating a BeanManagerFactory (yay GOF) that loaded the JMX version via reflection, falling back on a dummy if that failed. And I fixed some warnings Dalvik was spouting about default BufferedReader and BufferedInputStream constructors by hardcoding specific buffer sizes (I think Dalvik is wrong here, and I'm arguing my case on the android-platform ML). And that's really all there was to it. JRuby pretty much "just worked".

Of course you see the "could not compile" error up there. What's up with that?

JRuby normally runs mixed-mode, interpreting Ruby code for a while and eventually compiling it down to Java bytecode if it's used enough. But we do try to immediately compile the target script, since it doesn't cost much and gives you better cold-start performance for simple scripts. The error above was simply JRuby reporting that it could not compile my little -e script. Why couldn't it? Because the JRuby compiler is generating JVM bytecode, not Dalvik bytecode. Dalvik does not run JVM bytecode. Here's the actual error you get:

# dalvikvm -classpath data/ruboto.jar org.jruby.Main -d -e "puts 'hello'"
could not compile: -e because of: "can't load this type of class file"
java.lang.UnsupportedOperationException: can't load this type of class file
at java.lang.VMClassLoader.defineClass(Native Method)
at java.lang.ClassLoader.defineClass(ClassLoader.java:261)
at org.jruby.util.JRubyClassLoader.defineClass(JRubyClassLoader.java:22)
 ...

So that's caveat #1: this is currently only running in interpreted mode. To avoid the compiler warning, you can pass -X-C to JRuby to disable compilation entirely.

Unfortunately, interpretation means JRuby is none too fast at the moment. That may not matter if you're scripting a "real" app, but we'll definitely find ways to improve performance soon. That may mean providing an all-at-once compilation tool for Ruby code (we have an ahead-of-time (AOT) compiler right now, but it's per-file, and still expects to generate some code at runtime), or it may mean a second compiler that generates Dalvik bytecode. Either way...it's coming.

Caveat #2 is that a large number of libraries aren't working, especially any that depend on native code:

# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'readline'"
-e:1:in `require': library `readline' could not be loaded: java.lang.VerifyError: org.jruby.ext.Readline (LoadError)
from -e:1
# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'ffi'"
-e:1:in `require': library `ffi' could not be loaded: java.lang.ExceptionInInitializerError (LoadError)
from -e:1

And so on. There's nothing to say these libraries can't be made to work, but they're not working yet. And thankfully, our most important library seems to work fine:

# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'java'; puts java.lang.System.get_property('java.vendor')"
The Android Project

And that leads me to caveat #3, better demonstrated than explained:

# dalvikvm -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'java'; import 'android.content.Context'"
Class.java:-2:in `getDeclaredMethods': java.lang.NoSuchMethodException
from ClassCache.java:137:in `getDeclaredMethods'
from Class.java:666:in `getDeclaredMethods'
from JavaClass.java:1738:in `getMethods'
 ...

Bummer, dude. There seems to be some feature (i.e. a bug) preventing some Android core classes from reflecting properly, which means that for the moment you may not be able to access them in JRuby.

Next Steps

Overall, I think it was a great success. We obviously weren't doing anything in critical JRuby code that Android could not handle. Kudos to the Android team for that, and kudos to us for still supporting Java 1.5. But success in software only leads to more opportunities:

• All the changes necessary to run JRuby on Android have already been shipped in JRuby 1.2RC1. So you can grab those files and dex them yourself, or wait for me to add Android-related build targets.
• Android's default stack size is incredibly small, 8kb. So for all but the most trivial Ruby code you're going to want to bump it up with -Xss. See the final snippit at the bottom of this post for an example. And of course you all know about using -Xmx to increase the max heap; it applies to Android as well.
  
• I need to report the bugs I've found in Android's bug tracker and provide some steps to reproduce them. I'll probably get to this in the next couple days. Hopefully they can be fixed quickly, and hopefully patched Android doesn't take too long to filter out to users.
• Meanwhile, I'll probably start poking at an all-at-once compilation mode, since I think that's simpler initially than emitting Dalvik bytecode. It's already done in my head. You'll run a command to "fully compile" a target script or scripts, and it will create the .class file it does now along with all the method binding .class files it normally generates at runtime. I've been planning this feature for a while anyway. With the "completely compiled" Ruby code you should be able to just "dex" it and upload to the device.
• Given that most people will probably want to ship precompiled code, and given the fact that many libraries will never work, we need to modularize JRuby a bit more so we can rip out unsupported libraries, parser guts, interpreter guts, and compiler guts. That should shrink the total size of the binary substantially. And I have other ideas for shrinking it too.
• We in the JRuby community also need to start brainstorming how to use this newfound power. Assuming the above items are all completed soon, what will we want to do with JRuby on Android? Build apps entirely in Ruby? Script existing ones? What Ruby features would we be willing to drop in order to boost Android-based performance a bit more? Hopefully this discussion can start in the comments and continue on the JRuby mailing lists.

The Bottom Line

JRuby works on Android, that much is certain. The remaining issues will get worked out. And I dare say this is probably the best way to get Ruby on any embedded device yet; after dexing, it's literally just "upload and run". So there's a great opportunity here. I'm excited.

And just one more example to show that not just JRuby itself, but also Ruby libraries that ship with it work (using the "complete" JRuby jar in this case):

# dalvikvm -Xss128k -classpath data/ruboto.jar org.jruby.Main -X-C -e "require 'irb'; IRB.start"
trap not supported or not allowed by this VM
irb(main):001:0> puts "Hello, JRuby on Android!"
Hello, JRuby on Android!
=> nil
irb(main):002:0>

Domo Arigato, Mr. Ruboto

# cat test.rb
require 'java'
import java.lang.System

class Ruboto
def greet(who)
  puts "Hello, #{who}!"
end
end

name = System.get_property('java.runtime.name')
Ruboto.new.greet(name)

# dalvikvm -classpath ruboto.jar org.jruby.Main -X-C test.rb
Hello, Android Runtime!

Portions of this page are modifications based on work created and shared by Google and used according to terms described in the Creative Commons 2.5 Attribution License.

JRuby 1.2: Coping With Bugs

We get a lot of bug reports on the JRuby project. No, it's not because JRuby's a buggy POS. It's because we're implementing the core of an entire platform. It's hard.

Over the past year or so we kinda let the bug tracker go a little wild. We've never had more than two full-time people on the project, and community contributions wax and wane with the seasons, so we've had to choose our battles. For some amount of time, we would focus on performance, since without a reasonably-performing implementation, nobody would choose to use JRuby. Then we'd cycle back to fixing bugs, usually in the last couple weeks before a release. So the flow of bug fixes waxed and waned with our release cycles.

The problem with this approach was that we really couldn't keep up with all the reports coming in and continue to work on the "unreported issues" of JRuby like performance. So something had to give, and it was sometimes the bugs.

Roughly around September, we crossed an important threshold: 500 open bugs. They dated as far back as 2006 (we moved to Codehaus in 2006), and across the entire release sequence of JRuby; there were even some bug reports against pre-1.0 versions. From September until about mid-January, we worked to keep the number of open bugs below 500. Sometimes it would peek above, but we were generally successful.

About mid-January, I figured it was time to really bite the bullet, and I started walking from the oldest bug forward. It has been a long slog, but I'm making great progress.

So far, I've managed to whittle the total number of bugs down from 506 to 326, and that's with a couple dozen more filed in the past two weeks. The majority of these were either already fixed or invalid/incomplete bugs, but I've also made a concentrated effort to focus on and fix as many as possible. At the very least, I've made an attempt on every single one.

During that process, I learned a bit about how my brain works. During the past year, if I didn't know immediately how to fix a bug I often walked away from it and worked on something fun like compiler optimization. But during this latest bug hunt, because I did not want to just punt all those bugs one more time, I did something a little different.

Whenever I encountered a bug that seemed difficult or that I simply didn't want to fix, I would do one of two things:

• Take a break. Often this meant I had reached my limit and needed a breather. A little Wii, a glass of scotch, a movie...anything to take my mind of it for a bit.
• Count to ten. Sometimes, after reading through the bug, all I really needed was a moment for my brain to start "wondering" about the solution. Once the wheels started turning, I was almost compelled to dig deeper.

As a result, many long-standing bugs--including bugs I thought we would never fix--are now resolved and ready for the 1.2 release. I'm going on three weeks now of 12-hour days trying to fix what seems like an endless stream of bugs, but the end is in sight. And I want to stress that this level of effort has never happened in a single release. There's as much work in JRuby 1.2 as in multiple 1.1.x releases combined. I'll be blogging more of these posts over the next couple weeks.

For your amusement, here is the complete list of bugs we have resolved during the past nine weeks, since shortly after the 1.1.6 release. These aren't all fixes, but even the "already fixed", "won't fix", "not a bug", or "incomplete" ones were reviewed, tested, and considered. A couple of these I just applied patches or marked resolved based on someone else's work. And of course we're not done with JRuby 1.2 yet. Just you wait and see :)

Bugs Resolved (Fixed, Won't Fix, Not A Bug, or Incomplete Information), Past Nine Weeks:

(in the order they were resolved)

JRUBY-2538	File#chmod always returns -1, fails rubyspec
JRUBY-1505	Solidify public APIs separate from those that might change
JRUBY-3208	ant task api-docs runs out of memory, patch included
JRUBY-3221	Rubinius -bad instanceof tests in RubiniusMachine for attempt at fast path evaluation
JRUBY-3232	Zlib::GzipReader.each_line yields compressed data
JRUBY-3244	[PATCH] Support atime updates via utime
JRUBY-3249	Testing errors in test_java_mime.rb
JRUBY-3250	test_java_pkcs7.rb - Problem coercing Bignum into class java.math.BigInteger
JRUBY-2992	Bad cast in jruby-openssl X509Utils
JRUBY-3204	IO.read and IO.readlines do not take a block
JRUBY-3251	ConcurrencyError bug when installing Merb on JRuby
JRUBY-3248	jruby can't load file produced with jrubyc
JRUBY-3257	RaiseException#printStrackTrace doesn't deal well with nil messages
JRUBY-3259	sqlite db file on MRI is put in db dir. We put it in CWD.
JRUBY-3260	:date is stored as integer (not date) in sqlite3
JRUBY-2425	NPE at Connection Shutdown
JRUBY-2329	java.lang.NullPointerException when trying to connect to a Oracle XE database
JRUBY-3023	Renaming indexed columns fails
JRUBY-2384	Rails migrations fail with: undefined method `create_database' for class `#'
JRUBY-2400	ActiveRecord/JRuby Memory leak in update_attributes!()
JRUBY-2040	new samples/jnlp dir: includes both unsigned and signed examples that work in Java 1.5 and 1.6
JRUBY-3270	using activerecord 'to_xml' method crashes JRuby (and debugger)
JRUBY-3277	Constant lookup should omit topmost lexical scope; not bail out on first Object-hosting lexical scope
JRUBY-3278	Array#reduce is undefined
JRUBY-3187	JRuby command line scripts do not work with spaces in the path
JRUBY-3267	patch attached to update eclipse .classpath to refer to bytelist-1.0.1.jar
JRUBY-3280	patch attached to update eclipse .classpath to add new jars in build_lib/
JRUBY-3276	New IO#readpartial and IO#seek spec failures
JRUBY-3256	jruby -S script/console fails in Rails application
JRUBY-3199	IllegalArgumentException in X509V3CertificateGenerator when executing Hoe's rake gem running on SoyLatte JDK
JRUBY-3275	New ARGF spec failures
JRUBY-3287	Add public RubyInstanceConfig#setCompatVersion
JRUBY-3171	loading rake breaks import
JRUBY-3290	Float range to restrictive in FFI code
JRUBY-2826	Array#pack('w') is broken (exceptions and wrong results)
JRUBY-3116	ArrayIndexOutOfBoundsException in tmail
JRUBY-2522	Can not execute JRuby 1.1.1 "ant test" with IBM JDK
JRUBY-2426	JRuby trunk does not build with IBM JVM 1.5
JRUBY-3042	undefined method `quote' for Regexp:Class (NoMethodError) when runs gem list on AIX with IBM JAVA 1.5
JRUBY-1950	'-i flag not supported
JRUBY-3302	Doesn't biuld on windows for ffi problem
JRUBY-3303	[1.9] splat of array at front of assignment broken (same for other grammatical constructs)
JRUBY-3307	tempfile.rb sucks in JRuby
JRUBY-3305	Fixnums & Floats should be coerced to the narrowest java.lang.Number when passed to a java method that expects Object
JRUBY-2768	jdbc_mysql.rb should not enforce the utf8_bin collation on table creation
JRUBY-2115	Error doing add_column with Derby and jdbc-adapter-0.7.2
JRUBY-2967	[PATCH] Derby handling of binary/date/time fields. hsqldb handling of binary fields.
JRUBY-2647	[activerecord-jdbcsqlite3 adapter] Date/Datetime/Time fields simplification to INTEGER sqlite storage type is not correctly handled
JRUBY-3073	JRuby script engine does not load on IBM JDK
JRUBY-3109	Update stdlib to an appropriate 1.8.6 patchlevel
JRUBY-2541	Time assumes UTC timezone
JRUBY-3254	Make JRuby's Time#local behave more like MRI
JRUBY-2740	BigDecimal#precs fails two new rubyspec tests
JRUBY-3298	Kernel.srand calls #to_i on number
JRUBY-2987	Kernel#system does not work correctly
JRUBY-3242	Performance degradation on write operations
JRUBY-2128	error accessing JRuby DRb server from MRI DRb client
JRUBY-3268	JRuby DRb client cannot connect to MRI DRb server
JRUBY-3274	Many new Array#pack failures in updated RubySpecs
JRUBY-3147	Time#_load RubySpec failures
JRUBY-3146	Time#_dump RubySpec failures
JRUBY-3148	Array#fill spec failures
JRUBY-3142	Dir.pwd correctly displays dirs with unicode characters in them
JRUBY-2609	spec --line does not work with JRuby
JRUBY-3317	require "tempfile"; Dir.tmpdir fails
JRUBY-2364	The private keyword doesn't change visiblity of previously called methods with same send/call site
JRUBY-2796	Missing constant in Process::Constants on Mac OS X (darwin)
JRUBY-3226	Including more than one java interface stops Test::Unit execution
JRUBY-3035	Get Rails tests running in a CI server somewhere before 1.1.6 release, to ensure no future breakages
JRUBY-3318	If 'jruby' executable is a relative symlink, JRuby won't start
JRUBY-3328	Incorrect behavior for case/when when true or false are the first conditions
JRUBY-3269	SystemStackError with YAML.dump
JRUBY-3229	Javasand does not compile with JRuby 1.1.5
JRUBY-3333	idea
JRUBY-3332	ConcurrentModificationException In Application Startup
JRUBY-3329	Major divergence in threading behaviour between Ruby 1.8.6 and JRuby 1.1.6
JRUBY-3308	Deadlock between RubyModule.includeModule() and RubyClass.invalidateCacheDescendants()
JRUBY-3324	Error in string encoding conversion
JRUBY-3340	String#unpack('m') fails with ArrayIndexOutOfBoundsException
JRUBY-3341	The body of POST requests is not passing through jruby-rack
JRUBY-3312	JRuby can double slash ("//") the directory given by __FILE__ when "everything" suits this thing to happen. :-)
JRUBY-2884	jdbc_postgre.rb issue handling nil booleans
JRUBY-2208	Memory Leak in ActiveRecord-jdbc or JRubyEngine used with BeanScriptingFramework
JRUBY-2897	jdbc_postgre.rb needs microsecond support
JRUBY-2995	activerecord jdbc derby adapter should quote columns called "year"
JRUBY-2949	jdbcderby adapter should ignore :limit for INTEGER
JRUBY-2718	jdbcsqlite3 at JRuby on Rails do not work properly
JRUBY-3344	Update H2 to a later version
JRUBY-3342	Wrabler escapes config.ru twice
JRUBY-3282	Upgrade to derby 10.4.2.0 to allow unique constraints with nullable columns
JRUBY-2767	Mistake in selecting identity with H2/HSQLDB
JRUBY-2433	java.lang.IllegalArgumentException in debug mode when using CLOB
JRUBY-3310	Race condition in JRuby when Active Support is overriding Kernel.require
JRUBY-3127	Inconsistent DynamicScope instances in evalScriptlet
JRUBY-3339	java.lang.ArrayIndexOutOfBoundsException in RubyArray.java
JRUBY-3351	Tempfile defaults to a directory that does not exist on Windows
JRUBY-3353	String#unpack invalid output
JRUBY-3361	Compiled case/when blows up with arrays as when clauses
JRUBY-3362	attr_accessor, attr_reader, attr_writer, and attr not obeying visibility
JRUBY-1034	Post parse processing of the result comment placing as example
JRUBY-48	Ability to write JUnit4+ tests in JRuby
JRUBY-1572	Allow visible fields from inherited Java classes show up as instance variables (@foo)
JRUBY-2108	IOWaitLibrary ready? returns nil when ready
JRUBY-1895	JRUBY-1890 IO.popen does not support "-"
JRUBY-852	jirb exits on ESC followed by any arrow key followed by return
JRUBY-2015	"RAILS_ROOT" cannot be put on a place different from "Context root" in Goldspike.
JRUBY-2139	jruby.compile.frameless=true cause "Superclass method 'initialize' disabled."
JRUBY-2174	Method#to_proc.call invocations much slower than normal Method#call invocations
JRUBY-2170	Very unverbose message when problem with native library exists
JRUBY-3338	jIRB cannot get any input with Polish characters (utf-8) on Mac OSX
JRUBY-2252	Kernel#exec should not raise SystemExit
JRUBY-1855	EOF handling in case of reading program from standard input
JRUBY-1997	System.gc() is extremely expensive when calling Java code from JRuby
JRUBY-821	getting in $SAFE level 4 freezes
JRUBY-1770	weakref-based singleton class "attached" can blow up in certain unusual circumstances
JRUBY-1555	DST bug in second form of Time.local
JRUBY-1872	next statement should return the argument passed, not nil
JRUBY-2214	Pure-Java version of lstat doesn't fail on non-existing file
JRUBY-1901	standardize and publish public API for embedders
JRUBY-2211	SNMP Requests does not timeout properly
JRUBY-2298	We should generate method binding code with APT
JRUBY-2305	File output cuts off at a certain point?
JRUBY-2306	NPE in org.jruby.RubyIO.flush
JRUBY-2288	UDP locking problems when receiving from multiple senders on same port
JRUBY-2333	usage of unexistant variable in REXML::SourceFactory
JRUBY-2346	Nailgun does not compile under HP-UX
JRUBY-2353	Process.kill breaks up JRuby, while works in MRI on Windows
JRUBY-2369	'ant spec' failures on on MacOS
JRUBY-2168	test_io (test_copy_dev_null) fails under WinXP
JRUBY-2410	Multiple assignment could be made faster by not returning unused array
JRUBY-2389	java.util.ConcurrentModificationException
JRUBY-929	Java input/output streams from Ruby string's backing byte array
JRUBY-1681	Pathological slowdown in Array#insert
JRUBY-1470	FileTest methods only work with string arguments
JRUBY-1576	multi-byte character encoding probrem
JRUBY-2119	Jruby shell script don't work on KSH shell
JRUBY-3360	Pure-Java tempfile does not use a #make_tmpname callback
JRUBY-2518	Dir["some glob"] doesn't work for files inside a jar
JRUBY-3367	Dir.glob processes nested braces incorrectly
JRUBY-3366	Faulty marshalling error blows up in ActiveSupport
JRUBY-2027	Problems with the H2 jdbc adapter, schema metadata behavior
JRUBY-2417	Make fields immutable where possible
JRUBY-1565	ReWriteVisitor transforms Fixnums into base 10 despite their original format
JRUBY-2917	Missing peephole optimizations in parser, compiler
JRUBY-2542	DATA.flock causes ClassCastException
JRUBY-2545	Recursively locking on a mutex results in deadlock
JRUBY-2285	Regression: rubyspec run with -V option breaks JRuby
JRUBY-2120	Wrong stacktraces from exceptions about wrong number of arguments
JRUBY-1639	Exception when stopping WEBrick running the new rails application
JRUBY-2534	jdbcpostgresql adapter inserts invalid number literals into generated SQL, causes exceptions
JRUBY-3375	'attr' implementation is incompatible with MRI 1.9.1 behavior
JRUBY-3365	Objects with custom to_yaml methods break collection to_yaml
JRUBY-2603	Couple of new rubyspec failures for URI library
JRUBY-2465	2 digit year resolves to 1st century rather than 20th when using postgres timestamp with timezone + activerecord-jdbcpostgresql-adapter
JRUBY-2672	BasicSocket#close_read and #close_write not working
JRUBY-2655	TCPSocket.new('localhost', 2001) connects on the wrong interface
JRUBY-2759	Time Zone "MET" maps to Asia/Tehran
JRUBY-2758	Class Socket is missing #bind
JRUBY-2761	Thread#wakeup fails when sleep is called with a parameter
JRUBY-2772	Zlib::Deflate doesn't appear to deflate
JRUBY-3289	ArgumentError: dump format error() when unmarshalling Rails session and EOFError when unmarshalling hash with containing value of type ActionController::Flash::FlashHash
JRUBY-3228	Some error saving to a Rails session [Marshalling bug?]
JRUBY-2792	Net::HTTP spec failures in get_print spec; IO not getting expected "print" call
JRUBY-2804	IO.popen of 'yes' process hangs on close
JRUBY-2755	Precompiled scripts do not set initial position information correctly
JRUBY-2484	unicode symbol not supported as in MRI
JRUBY-2817	File.chown works with 64bit JDK, but raises NotImplementedError on 32 bit JDK
JRUBY-2912	MS SQL-Server - Create/Drop Database bug
JRUBY-2815	System triggered from inside of tracing behaves oddly
JRUBY-3069	dbd-jdbc: Support Ruby DBI Statement.fetch_scroll
JRUBY-3235	dbd-jdbc: Add helper functions to wrap already existing jdbc Connection and Statement objects
JRUBY-3068	dbd-jdbc: Override Ruby DBI's default database return value coercion for Date / Time / Timestamp columns
JRUBY-3067	dbd-jdbc: Register a handler for DBI 0.4.x's default parameter binding type coercion
JRUBY-1345	Files added to a module via Kernel.autoload are not automatically loaded if the class they contain is extended
JRUBY-2727	ActiveScaffold 1.1.1 fails with JRuby 1.1.2, probable path problem
JRUBY-2699	If user's PATH contains '.' and 'jruby' resolves to './jruby', JRUBY_HOME is incorrectly set to '.', leading to 'NoClassDefFoundError'
JRUBY-2820	Most Etc methods behave diferently on Windows under x32 and x64 JVMs
JRUBY-2841	String#<<>
JRUBY-2844	Memcache session store does not work across multiple application servers
JRUBY-2845	'-S switch breaks if you have directory in pwd matching name of file in bin/PATH
JRUBY-2849	CCE using proc{} in AR callbacks
JRUBY-2862	Improve JRuby::Commands' handling of bindir
JRUBY-2861	Cannot call super inside a method that overrides a protected method on Java base class
JRUBY-2868	ThreadService.getRubyThreadFromThread supports only one non-rubynative thread at a time.
JRUBY-2782	"No such file or directory (IOError)" when JAR file named in java.class.path but not active filesystem
JRUBY-2901	JRuby does not support options in shebang line
JRUBY-2846	gem generate_index broken
JRUBY-2832	Rails static page caching won't generally work with Java ServletFilter unless some serious hack with the cache directory is found
JRUBY-414	Serialization of wrapped Java objects could be handled as user-marshalled data by Marshal
JRUBY-2921	Newly overridden methods are not called if the old superclass method has already been called
JRUBY-2661	specs hang under Apple Java 5
JRUBY-2933	Ruby runtimes are pinned to memory due to ChannelStream
JRUBY-1578	Incomplete HTTS response from Microsoft IIS servers using net/https
JRUBY-2941	popen IO lockup with multiple threads
JRUBY-2925	Java Integration can now instantiate Java classes with no public constructor
JRUBY-2802	JRuby wrapped Java objects formerly exposed readers for non-public fields
JRUBY-2504	JAR URLs are inconsistently supported by APIs that access the filesystem
JRUBY-1846	Kernel::fork should use forkall(2) on solaris instead of fork(2)
JRUBY-2395	Have to call setPaint instead of assigning to g.paint
JRUBY-1401	Pathname#realpath fails for Windows drive letters
JRUBY-2296	convertToRuby does not work if to_s does not return a String (but for example nil)
JRUBY-2904	Need a better solution for tracking Java object wrappers
JRUBY-1327	When define_method replaces an inherited Java method, the ruby_case_version is not replaced
JRUBY-2951	repeated popen call may throw NULL pointer exception
JRUBY-2974	multi-byte exception message turned into garbled characters when Java Exception nested NativeException.
JRUBY-2980	String#<<>
JRUBY-2981	alias_method_chain pattern is extremely show on jruby
JRUBY-2982	Unicode regular expressions by UTF-8 don't work
JRUBY-2988	jirb does not echo characters to the terminal after suspend and resume in the shell
JRUBY-2997	Dir[] results in NPE depending on permissions
JRUBY-3000	integration issues with Java classes containing inner classes
JRUBY-3007	Message method value of Exception is missing in Java when exception raised in ruby
JRUBY-3016	Nested Class/Enum issue with JRockit
JRUBY-3011	java classes with non-public constructors are incorrectly instantiated
JRUBY-2999	Regression: Inheriting method with same name from two Java interfaces causes Java classloader error
JRUBY-2700	jdbcsqlite3 adapter does not respect default parameter
JRUBY-3026	[Derby] Allow select/delete/update conditions with comparison to NULL using '='
JRUBY-3288	jruby-openssl: SSLSocket.syswrite error for big (>16k) data
JRUBY-3017	DRb "premature header" error on JRuby client
JRUBY-2766	Create caching mechanism for all our many calls to callMethod from Java code
JRUBY-3200	insert statement returns null from the postgresql jdbc adapter
JRUBY-2996	Migration step with create_table with string column with :default => "" fails due to missing default value in SQL
JRUBY-2184	ActiveRecord is slower on JRuby than on MRI
JRUBY-3202	url style Postgres configuration is broken in rake.
JRUBY-1854	def is almost 3x slower in JRuby
JRUBY-2618	Table does not exist error possibly caused by upper case table name
JRUBY-3003	ArrayStoreException in compiler when calling Array.fill
JRUBY-2180	break performance is slower than MRI, sometimes slower than interpreted
JRUBY-2304	active_scaffold - No such file or directory
JRUBY-3386	Array#eql? rubyspec failure
JRUBY-3387	Array#== rubyspec failure
JRUBY-3054	Thread#status is "run" when thread is blocking on condition variable
JRUBY-3390	RubySpec: Numeric#coerce calls #to_f to convert other if self responds to #to_f
JRUBY-3055	permission javax.management.MBeanServerPermission "createMBeanServer";
JRUBY-3072	Using a ruby Numeric to set a parameter with a signature of java.lang.Integer causes a java.lang.ClassCastException
JRUBY-3082	1.1.4 unable to use 'logging' gem (works in 1.1.3)
JRUBY-3398	Attributes defined from Java tried to use current frame for visibility
JRUBY-3397	defined? CONST is not following proper constant lookup rules
JRUBY-3089	Digest::Base stores in memory all bytes passed to the digest, causing OutOfMemoryError
JRUBY-3125	Some Socket constants not supported.
JRUBY-3128	Different jruby behaviour that ruby 1.8.6/1.8.7/1.9 when running file that is named as one of required file.
JRUBY-3175	Cloning java byte array returns incorrect object
JRUBY-3177	ConcurrentModificationException
JRUBY-3178	http spec tests fail when webrick starts on address 0.0.0.0
JRUBY-2548	JRuby conversion of String to Java String is arcane
JRUBY-3174	FFI MemoryPointer#get_string(0, x) gets confused by null byte in the buffer
JRUBY-2896	jruby -S picks up script from local directory
JRUBY-3163	Incorrect namespace for CipherError
JRUBY-1853	define_method methods do not display the correct stack trace, may not be using frame safely
JRUBY-2855	Classpath search order is not respected by require when classpath includes both jars and directories
JRUBY-3222	Problems with migrations where direct type specified
JRUBY-2424	running with -rprofile with multithreaded test causes NPE
JRUBY-2691	Update sybase driver to pass simple unit tests with jtds and verify it works with the new dialect keyword
JRUBY-3065	New public LoadService#findFileToLoad method
JRUBY-2261	ThreadContext should use SoftReference instead of WeakReference
JRUBY-2116	import org.eclipse.jface.dialogs.MessageDialog -- causes java.lang.NullPointerException
JRUBY-2898	Exception trying to use BSF (java.lang.NoClassDefFoundError: org/apache/bsf/util/BSFEngineImp)
JRUBY-2003	rexml pretty printing wrap() error
JRUBY-752	undef'ing and redef'ing methods should give disabled message?
JRUBY-2262	Java toString() mapping to invoke(... to_s ...).toString() doesn
JRUBY-3121	Glassfish Gem 0.9.0 does not work with JRuby 1.1.5
JRUBY-551	JRUBY-549 bfts test_file_test failures
JRUBY-2248	Problem with active_scaffold defaults defined in application.rb
JRUBY-2446	httprequest error for a SOAP request to a Rails ActiveWebService
JRUBY-3005	Stomp gem hangs in Stomp::Client#subscribe
JRUBY-3180	Class in default package can't be reopened under Java namespace
JRUBY-3047	IO.select sometime reports Unable to establish loopback
JRUBY-2851	JDBC adapter in JAR file not being picked up by java.lang.Class.forName in 1.1.3 (worked in 1.1.2)
JRUBY-2313	Automatically convert RubyFile to java.io.File
JRUBY-2328	Overriding require causes eval to give wrong __FILE__ in certain circumstances
JRUBY-2794	Failure in String#crypt specs, Mac OS X, Soylatte
JRUBY-2137	ENV[] is case sensitive on Windows
JRUBY-2797	File.expand_path rubyspec failure on Mac OS X, Soylatte
JRUBY-2608	Examine whether -Xrs flag to JVM could be used to improve our signal-handling logic
JRUBY-2675	jirb + jline do not work in cygwin
JRUBY-2521	Compilation Warning for Sun proprietary API using
JRUBY-2263	Running merb under a concurrent load causes ArrayIndexOutOfBoundsExceptions
JRUBY-2706	File.stat('/home') treated as a relative path
JRUBY-2557	NPE when yielding method
JRUBY-2860	EOFError while consuming REST web service from glassfish v3
JRUBY-2835	rails image_tag generates url get 404
JRUBY-3095	chmod_R broken
JRUBY-2830	String#unpack with 'w' is completely unimplemented
JRUBY-3038	Unable to insert YAML into t.text field (behavior different from Ruby 1.8.6)
JRUBY-3004	Excess warnings when using rake TestTask
JRUBY-1606	File.expand_path does not work as expected
JRUBY-750	defineAlias reports original name and not aliased one in stack traces
JRUBY-1201	TCPSocket.new(dest_adrr, dest_port, src_addr, src_port) missing from JRuby
JRUBY-3160	REXML returns error for add_attribute
JRUBY-2732	org.jruby.util.RubyInputStream is unused
JRUBY-2455	"jruby" script failed to find JRUBY_HOME leads to class not found
JRUBY-3190	method `module_eval' for main:Object should be undefined?
JRUBY-2950	Net::IMAP#authenticate stalls / blocks in recent versions of JRuby
JRUBY-1542	1.1b1 doesn't build with gcj 4.2
JRUBY-2788	Make Time.now monotonically increasing
JRUBY-3296	Etc.getpwuid should raise TypeError if invalid type
JRUBY-3167	loadpath and classpath problem
JRUBY-2983	JRuby crashes after running 110 RSpec examples
JRUBY-3085	Add constant caching for Colon2 and Colon3 (specific module and Object cases)
JRUBY-3207	super error message is inaccurate when superclass doesn't implement method.
JRUBY-2979	File#getc fails on illegal seek when reading from /dev/ttyS0 on Linux
JRUBY-3076	RubyUDPSocket.send tries to do inet address lookup, pauses too long for inet6 failure
JRUBY-2555	CLONE -JIT max and JIT threshold should be adjusted for improvements in JRuby over the past months
JRUBY-3407	FFI Stack Level Too Deep on Library.send(:method, args)
JRUBY-3410	Add -y flag to debug the parser
JRUBY-3103	Compiler closures use two different binding mechanisms, need better construction and caching logic
JRUBY-3179	JRuby can't handle do/end blocks within String-inlined expressions
JRUBY-3316	Group expression class path fails to parse
JRUBY-3151	OpenSSL::Random#pseudo_bytes raises ArgumentError on negative arguments
JRUBY-3088	"RStone" port of PyStone is slower on JRuby than 1.9
JRUBY-3120	Regression: error serializing array of objects with custom to_yaml def to yaml
JRUBY-3211	builder library is slower in JRuby than in MRI
JRUBY-1884	handling of file close while reading differs from mri
JRUBY-3214	load and require don't work correctly for .class files
JRUBY-3218	Import is sometimes confused by unquoted class name
JRUBY-3224	Array#to_java with java object reference doesn't carry over object identity
JRUBY-1079	IO.sysopen not defined
JRUBY-3071	Illegal seek error trying to read() from pipe
JRUBY-3152	Process.times returns invalid values
JRUBY-3064	Process.uid does not work on non-natve platforms (jna-posix)
JRUBY-2757	Compiled argument processing and arity checking are too large, too much bytecode
JRUBY-3061	NKF(unsupported Q encode stream)
JRUBY-3105	Embedding JRuby-Rack (non-war deployment)
JRUBY-3077	Update ruby_test tests and incorporate changes into build
JRUBY-2970	Timeout.rb is not working in special cases (Thread may block whole application).
JRUBY-3253	Lack of default jruby.home in embedded usage causes NPE
JRUBY-3063	File::link using CIFS raises Errno::EEXIST error if the 'old_file' is open while Matz Ruby raises Errno::ETXTBSY
JRUBY-3252	Iterative String concatenation operations in JRuby degrade faster than in MRI.
JRUBY-3255	jruby -S script/server fails in Rails application
JRUBY-3258	after installing minigems (and after minigem setup gems not working on 1.1.6)
JRUBY-1235	DRb hangs when transferring Ruby objects created in Java
JRUBY-3271	Java Stacktrace and exception is swallowed
JRUBY-2063	Wrong monitor handling in o.j.util.ChannelStream.read
JRUBY-2131	Select with nil arrays should throw an exception