00:00:11.210
Hi, I'm Tom, and this is Charlie. We work at Red Hat, which is generous enough to allow us to work on JRuby.
00:00:18.109
We co-lead the JRuby project, and it will be no surprise that we're going to talk about JRuby. The first thing to note is that JRuby is Ruby—it's just an alternate implementation. If you've written any Ruby code that runs in CRuby, you should be able to run it with JRuby.
00:00:34.170
Sometimes, people get confused when I mention Java several times, but if you never use any of our extra features, just know that you can run your Ruby code, and it will work. You might think of Java as just an implementation detail, much like C is for regular Ruby.
00:00:45.210
We just released JRuby 9.2.0.0 last week, which is compatible with Ruby 2.3. You will need Java 7 or higher to run it. JRuby 9.2 is going to be Ruby 2.4 based, and it's actually sort of feature complete now, but we still want to add some things.
00:01:04.939
We're considering a release around Christmas. However, as you know, CRuby also releases around Christmas, and they are only putting out Ruby 2.5, making us one version behind.
00:01:20.909
Let's talk about why we implemented Ruby on the JVM and why that is useful. Both JRuby and CRuby have their unique advantages. Sometimes, the same people work on both projects, and we try to target where we want to run Python on platforms like macOS.
00:01:41.150
However, JRuby mostly targets running directly on Java itself. We have a little flexibility on the side for when we need more power to address certain limitations in Java. Meanwhile, MRI (Matz's Ruby Interpreter) has virtually no dependencies, so it has to go it alone. We're going to argue why we prefer running on top of Java.
00:02:15.860
This isn’t criticism of how CRuby is implemented; it’s just a different perspective. CRuby needs to have all the expertise to develop a fast, efficient version of Ruby, but we benefit from an army of experts working on Java who provide us with tools and features for free.
00:02:41.150
We have choices of multiple garbage collectors. There's a fantastic JIT (Just-In-Time) compiler that does a lot of crazy optimizations for our code. Java's native threading is one of the biggest differences between JRuby and CRuby, allowing us to utilize all available cores.
00:03:07.609
There's a lot of tooling available for us to debug issues, and when I say cross-platform, I mean that the JVM is literally everywhere—from normal platforms to IBM mainframes. We even have users running JRuby on IBM mainframes, Android microcontrollers—you name it. So JRuby enjoys a broad reach just from being built on the JVM.
00:03:32.209
Java compiles to an intermediary format of Java bytecode. After you compile something once, you can run it on Windows or a microcontroller, etc. Thus, it's only compiled once, which is a great advantage.
00:03:49.879
JRuby allows for Java native extensions, which include a bit of Java. The gem authors compile it once and publish the gem, so you just install it, and it works on Windows, which is often an issue with native C extensions. The equivalent of Ruby gems for Java is Maven, which has more than 47,000 libraries and tons of useful tools like Prawn for PDF generation.
00:04:21.950
However, if developers encounter issues that Prawn cannot solve, JRuby offers the feature to load Java libraries, allowing functionality as if they were Ruby libraries. If they need more capability, they can switch over to a mature PDF generation library like iText.
00:04:49.110
Additionally, you can call multiple languages that target the JVM. Thus, one can write 80-90% of the app in Ruby but switch out to Clojure if something is better suited for transactional processing or immutability. They can coexist in the same VM, utilizing the same garbage collector and even explore tools for memory usage.
00:05:19.530
Every language has its own libraries, offering additional options and opportunities. If you need to hook up to a commerce API, there might be something written in Scala that can be used seamlessly with JRuby.
00:05:54.810
Now, let’s turn it over to Charlie for a demo.
00:06:10.800
All the typical Ruby installers can install JRuby. The only prerequisite is having a JVM on your system. As expected, we have an IRB, which we call JIRB. As Tom mentioned, we can utilize any Java classes at any time as if they were regular Ruby code.
00:06:30.390
For example, we can create a new Java JFrame. Let's instantiate it: frame = Java::Swing::JFrame.new.
00:06:57.750
Now we have a window frame. Let’s make that visible.
00:07:03.300
There it is—it doesn't look like much right now, so let's set it to a size of 300 by 300.
00:07:19.920
Next, let’s add a button to it. Again, we set everything up so we can see it. Now we've got our button, and we can easily respond to events from the button using Ruby. Though we would usually have to implement the ActionListener interface in conventional Java, JRuby allows for a more 'Ruby-like' approach.
00:07:49.980
For instance, we can easily update the button text with just button.text = 'JRuby'. Then we return to our window, and it all works seamlessly.
00:08:21.120
This is an excellent way to explore different libraries on the JVM. As you can see, this doesn't really look like Java, except when we import the package.
00:08:46.850
We also have another GUI library available on the JVM called JavaFX that we have been using to build JavaFX applications with Ruby code. Charlie shows that he planned to run a demo.
00:09:19.120
There we go! The excitement of a live demo! It was a bit tricky, but I'm back.
00:09:38.600
Developing with these Java classes can be tricky. Sometimes after making minor changes, the demo may not show correctly because of how changes build upon each other in Java syntax.
00:10:06.970
Any changes here require attention, as Java classes can be complex. However, JRuby FX is a gem developed to wrap the JavaFX GUI library in a straightforward way.
00:10:49.700
It has two modes: a DSL builder for easier use, and a model-view-controller format that employs XML. Users often utilize Scene Builder, a canvas application that provides various controls for design.
00:11:01.500
It includes a palette on the left for custom controls, and once you have laid out your components, you will see properties on the right for customization. For instance, I named the left one 'Gauge' and the right one 'Slider'.
00:11:34.740
If working correctly, when the slider moves, you would see the gauge following it, showcasing simple interaction.
00:12:01.590
A more realistic application is called BreakMan Pro. It utilizes static analysis of Ruby on Rails applications, boasting a polished interface and heavily relying on JRuby FX.
00:12:27.100
JRuby benefits from advanced garbage collection algorithms and JIT optimizations on the JVM. There are parallel GCS, concurrent GC tools for live analysis, and tools for watching the heap to detect memory leaks.
00:12:56.720
VisualVM is one of the tools that provides graphical overviews of applications. You can connect it to a running JRuby application to monitor various aspects of Java's performance.
00:13:33.910
With VisualVM, you can monitor CPU usage, thread activity, and garbage collection processes, allowing developers to ascertain potential memory leaks or inefficiencies.
00:14:11.530
Furthermore, you can profile Ruby methods being interpreted in the JVM, providing insights into performance.
00:14:25.540
We've optimized Ruby's performance by implementing our own interpreter that runs Ruby code, letting us profile over time and compile directly into JVM bytecode.
00:14:49.560
By leveraging features like invoke dynamic, we've improved how Ruby and Java interact when compiling, leading to better optimization.
00:15:07.330
We’ve improved performance metrics dramatically, with benchmarks demonstrating JRuby's speed compared to CRuby, showcasing the benefits of dynamic compilation and JVM enhancements.
00:15:26.640
Using JRuby can result in considerable performance gains, especially in numerical computations where optimizing handling of objects on the JVM can reduce processing times significantly.
00:16:06.790
Additional benchmarks show JRuby's efficiency in managing and executing complex structures like red-black trees significantly more efficiently than CRuby.
00:16:29.290
Although CRuby provides concurrency, it operates under a global lock, while JRuby allows native threads to fully utilize available cores, which facilitates greater performance for concurrent requests.
00:16:54.850
Transitioning to JRuby can reduce memory needs significantly, as it generally requires only one process to handle multiple requests—leading to notable cost savings for large applications.
00:17:15.000
For instance, a friend transitioned a large application from 40 EC2 instances down to 10 and saved tens of thousands of dollars monthly simply by using JRuby.
00:17:55.190
As for JRuby on Rails, we’ve been running it since 2006, with many people successfully deploying Rails applications on JRuby.
00:18:07.680
While we were in the process of supporting Rails 5, we lagged behind yet managed to pass all tests apart from one concerning Active Record, which is crucial since running Rails without a database is futile.
00:18:58.700
We’ve since focused on improving compatibility with Active Record JDBC, an API allowing communication with various databases. Compatibility between Active Record and JRuby is a complex task indeed.
00:19:24.920
Active Record JDBC required support for various database systems with their unique features, creating compatibility complexities.
00:19:55.579
We realized addressing all compatibility dimensions proved challenging for past versions, and we’re addressing these concerns through JRuby now.
00:20:22.060
Moving forward, we're planning to support only a few essential databases like MySQL, SQLite, Postgres, and Microsoft SQL server, simplifying our prior models.
00:20:46.490
By streamlining compatibility with recent versions of Active Record, we improved our codebase's manageability and have seen great results in recent tests.
00:21:25.730
The famed Redmine project, a widely known pure Ruby project, was successfully migrated to JRuby without issues, showcasing stability and robust functionality.
00:21:57.100
Mastodon, a more complex application resembling a decentralized Twitter platform, posed more challenges but still had multiple dependencies with JRuby versions.
00:22:28.800
While some libraries presented conversion issues, the process was manageable due to active efforts from the community.
00:22:50.400
Various wrappers could fill the gaps of missing libraries, as JRuby's capabilities allow for flexible adaptation to Java systems.
00:23:05.720
Lastly, we've emphasized the necessity of community support for JRuby, aligning contributions toward closed issues, documentation improvements, and language support.
00:23:38.880
To make JRuby more effective, we invite engagement from developers familiar with JRuby and Ruby code, supporting our efforts to nurture a vibrant JRuby ecosystem, contributing code, troubleshooting, and sharing ideas.
00:24:49.679
If you’d like to learn more about deploying JRuby applications or migrating existing Ruby apps to it, look into literature from Joe Kutner and others that outline procedural approaches effectively.
00:25:13.620
The journey of transition is notable, and the community's reception of JRuby continues to evolve.
00:25:23.679
We are proud to have significant organizations using JRuby, like BBC News, proving its reliability and effectiveness for critical applications.
00:25:49.780
Charlie and I are delighted to encourage you to explore JRuby’s capabilities and hope this discussion has sparked your interest.
00:26:03.700
Let’s open the floor for questions and have an engaging discussion.
00:26:15.880
Thank you for joining us today! Feel free to discuss further around the conference if you have any additional questions.
