00:00:14.730
Hello, everyone. I'm Charles Nutter, and this is Tom. Today, we're going to talk about JRuby deployment across various platforms.
00:00:21.520
As for who we are, we've both been JRuby co-leads for about 10 years now. Tom’s experience stretches even longer. We have been working full time on JRuby for about a decade. Currently, we work for Red Hat; earlier, we worked at Sun Microsystems and Engine Yard for a few years.
00:00:38.739
Now, we've settled into Red Hat, which sponsors our work. We enjoy traveling to conferences and connecting with all of you, sharing drinks and ideas. If you have a beer recommendation, please let us know.
00:00:50.740
JRuby is essentially Ruby, but with greater capabilities. It runs on the JVM, providing access to a wide range of libraries. We have versions compatible with Ruby 1.8, 1.9, and 2.3, but we're primarily focusing on the current versions, 2.3 and 2.4.
00:01:02.470
Built on the Java platform, JRuby addresses many issues typical of C Ruby applications, such as garbage collection and threading. In fact, JRuby often executes Ruby applications faster than C Ruby, sometimes significantly so.
00:01:20.320
For instance, if you want to handle five or ten concurrent requests in C Ruby, you typically need multiple C Ruby instances for failover, probably requiring even more instances. However, with JRuby, you can run an application efficiently within a single JRuby process, achieving substantial throughput and performance sometimes equivalent to dozens of C Ruby implementations.
00:01:39.850
This benchmark we used years ago remains valid. It compares Ruby 2.0 running a red-black tree implementation, which took approximately two and a half seconds for that benchmark. It builds a tree, manipulates it, and walks through it multiple times. While Ruby has C extensions for performance, as Chris Seaton pointed out in his talk, this is usually how people enhance the performance of a Ruby application—by extracting slow parts to C and integrating them back into Ruby.
00:02:16.360
Nonetheless, JRuby shows real magic by running the identical Ruby implementation of the red-black tree on the JVM. With JVM optimizations, we achieve almost double the performance compared to C Ruby using C extensions. As more optimizing Ruby implementations like JRuby and JRuby Truffle emerge, there’s less need to rely on C extensions.
00:02:58.350
Now, let me hand it over to Tom, who will discuss JRuby's current status.
00:03:10.080
Yes, we released JRuby 9.1.6 on Wednesday, coinciding with the conference in Ohio. This point release included many socket fixes and numerous other minor updates. We support two branches on JRuby: the legacy JRuby 1.7 branch and the master branch tracking the latest of JRuby 9k.
00:03:38.760
We maintain support for Ruby 1.8 and 1.9, and our master branch supports the latest versions of Ruby. We plan to release another point release towards the end of the year and aim for Ruby 2.4 support concurrent with the C Ruby release.
00:04:13.410
On the JRuby 1.7 branch, we intend to discontinue maintenance by the year's end, but we anticipate another point release. An interesting issue we encountered is the unification of Fixnum and Bignum into Integer in Ruby 2.4. While most people's code will remain unaffected, there is a possibility of breakage for specific use cases where precision is crucial.
00:04:41.400
Frameworks like Rails have already updated for these changes, so they should work seamlessly in both versions 2.3 and 2.4. We believe that any other database adapters which might be impacted will also adapt accordingly.
00:05:00.750
If we face any issues relating to this change, we can always create a maintenance branch, but we hope that will not be necessary. This change is, admittedly, quite significant as two classes are merging into one.
00:05:32.580
Has anyone experienced any issues related to these changes while trying out Ruby 2.4? Yes? Curious to see what actual impacts will be, but I suspect it may not be too significant. Moving on, we want to eliminate JRuby 1.7 as maintenance is becoming increasingly challenging.
00:05:50.900
More users working with JRuby 1.9 are encountering difficulties with gems since Ruby 2.0 has been around for some time now. However, if you have a compelling reason not to upgrade to JRuby 9k, we would like to understand your situation. We aim to make the transition as smooth as possible.
00:06:16.139
If you search for "JRuby 1.7 EOL," you will find a GitHub issue where we attempt to gather all challenges users face while blocking their upgrade to JRuby 9k. The JRuby 9.2 release will depend on resolving those issues so anyone stuck can make the upgrade.
00:06:54.540
A significant advantage of JRuby is its ability to interact with the Java ecosystem. You can easily script Java classes and Java objects as if they were Ruby objects, with no need for compilation or type declarations.
00:07:06.649
We provide various shortcuts to bridge the gap between Java and Ruby, which make integration seamless. The abundance of Java libraries allows JRuby to handle tasks that might not have native Ruby equivalents. For example, if you're dealing with an e-commerce API that only has Java bindings, JRuby can call those APIs directly without needing to write a separate server.
00:07:40.759
Let me give you an example: I’ve created a library called Plugin that allows you to write plugins using Ruby syntax for Minecraft, a game written in Java. For instance, with my plugin called Egg Madness, you can set how many entities spawn when you throw an egg. Every time I throw an egg, 120 chickens emerge.
00:08:18.050
This example demonstrates how easy it is to utilize the Java API while writing in Ruby. You don't have to understand Java; let me walk you through the code. We define a class called Chickens that implements a Java interface called Listener. This registration allows the Java code to listen for specific events, in this case, the Player Egg Throw event.
00:09:02.930
We modify this event to ensure that it always hatches something, in this case, 120 chicks. Afterward, we return a message to the player. If I were to write this in Ruby, I would create a class called Chickens, include the Listener interface, and define a method to handle the event. We can simplify some methods and attributes to keep the Ruby-style intact.
00:09:50.900
Now, we have something that looks idiomatic in Ruby. In my library, I created a method that specifies the event to handle, and by passing a block, you can define the event's behavior. What's fascinating is that this method dynamically generates the class during runtime, which Ruby supports but is impossible in Java.
00:10:39.950
Let’s talk about Rails 5 support. JRuby has supported Rails for years, successfully running it since 2006. Over the past decade, we’ve seen hundreds—if not thousands—of applications leveraging Rails on JRuby, and its performance keeps improving.
00:11:09.500
Regarding Rails 5, while JRuby 9.0 focused on specific improvements, we couldn’t devote much time to Rails 5 support. Currently, Rails 5 works in most cases, as the existing JRuby database adapters are compatible with Rails applications.
00:11:59.029
However, Active Record, being the most complex part of Rails, has undergone significant changes which our existing adapter has not kept pace with. We aim to ensure it passes 100% of all Rails tests and integrates into Rails continuous integration.
00:12:32.830
Active Record JDBC supports several databases including SQLite, MySQL, and PostgreSQL. We still provide Oracle and various embedded databases support. JRuby offers flexibility, allowing users to leverage Java database drivers, which doesn't require additional extensions as in C Ruby.
00:13:02.220
While providing extensive database support, we're reevaluating how many databases we truly need to maintain due to the complexities and size of the codebase. The initial aim of creating one active record JDBC version across multiple Rails versions created difficulties over time. Rebooting our library means we can significantly reduce code duplication.
00:13:29.100
Changes in integration and API over Rails versions made maintaining compatibility harder. By focusing on the latest features in Rails 5, we intend to create streamlined adapters. For active record JDBC 5.1, we will ensure it works seamlessly without interfering with users reporting issues.
00:14:16.170
With our exploration of new database adapters, we found that 75% of the existing code is compatible with Rails. We aim to discard unnecessary code and base our library largely on the Rails version's code base, reducing maintenance complexity.
00:14:56.060
Our latest work on the Sequel adapter has been remarkably successful; it's currently passing nearly 100% of active record tests. Codifying our process should allow us to replicate success swiftly with MySQL and PostgreSQL adapters.
00:15:50.760
We’re also keeping Oracle support viable through the Oracle-enhanced adapter instead of maintaining our own. Thus, it makes sense to evaluate which embedded databases among them we should continue to support.
00:16:37.410
For those running JRuby with Microsoft SQL Server, it's important to note that it can be challenging, but we are re-evaluating the viability of other database supports including in-memory databases. The majority of services, such as Redis and Memcached, have libraries that work perfectly with JRuby for a consistent user experience.
00:17:26.230
For example, libraries like ZeroMQ work seamlessly in JRuby, achieving similar performance to C Ruby. As we increase native support, we have the option to leverage additional Java libraries to enhance performance further.
00:18:04.090
Many cloud environments support JRuby deployments, particularly Heroku. You can push your application to the cloud easily, which is a significant advantage of using JRuby as opposed to traditional Ruby.
00:18:41.350
When searching for deployment strategies, it’s crucial to consider both Ruby and Java environments. Tools like TorqueBox that Red Hat has designed allow JRuby applications to run on Java servers and easily handle the complexities surrounding supportive services and component management.
00:19:30.750
Container options are also effective; for instance, deploying via Docker will enable user to run JRuby applications while offering a reliable, simple setup. Here's a tip: start with your preferred JDK and bundle JRuby to run comfortably within that environment.
00:20:15.740
The executable jar files, such as via Warbler or TorqueBox, allow for complete JRuby applications to run seamlessly across JVMs without requiring extensive server configurations, which is very advantageous for rapid deployments.
00:21:03.440
For existing applications or in transitioning between frameworks, tools like Heroku make JRuby much more applicable in various environments, including cloud solutions. Additionally, a significant portion of libraries for distributed systems work flawlessly across Ruby and JRuby.
00:21:57.790
Lastly, keeping your application simple and employing the right services makes JRuby an optimal choice for many projects. The JRubyFX, a gem built on the JavaFX library, allows quick creation of GUI applications using the same robust frameworks.
00:22:49.410
JavaFX is a powerful GUI library providing various controls and customization options, plus opportunities for creating dynamic visual experiences.
00:23:09.290
Before diving deeper, I want to clarify that JRubyFX applications can be compiled into a JAR file, allowing display everywhere JVM is supported, simple and efficient.
00:23:45.660
Importantly, JRubyFX supports both DSL and FXML. The DSL is efficient for straightforward applications, while FXML offers a markup-based approach for complex UI designs. You can interact with controls via a Ruby-written controller.
00:24:31.410
Through the JRubyFX interface, you can also create dynamic and complicated UIs while leveraging JavaFX capabilities like custom controls, event handling, and rich graphical representations.
00:25:23.700
Switching gears, it's worth discussing how JRuby can work on embedded platforms. We see an increase in embedded systems with sufficient RAM capabilities, such as the Raspberry Pi, running JRuby applications without a hitch.
00:26:05.420
Indeed, many embedded devices now have the specifications to handle JVM and JRuby, enabling the development of various applications with ease. Setup is straightforward, installing JRuby via RVM or traditional downloading methods.
00:27:02.770
Using the Raspberry Pi as an embedded environment showcases not only installation ease but functionality akin to desktop environments. You can easily implement GUIs or backend processes using JRuby methods.
00:27:53.580
The memory consumption of JRuby is often higher than C Ruby in certain uses, but overall advances in hardware capabilities for embedded systems make this less of a concern over time. The benefits of utilizing JRuby within a familiar environment offer excellent performance and seamless deployment for various developers.
00:28:41.140
As we concluded, if there are questions about performance, scalability, or use cases for JRuby on embedded environments, don’t hesitate to reach out. Let's keep the conversation open about advancing JRuby's usability.
00:29:13.790
Now we look forward to your questions, especially about JRuby 9k features, benchmarks, and any specific issues you might want to clarify. Thank you all for joining us today!
00:29:49.080
We're excited about the potential of JRuby and look forward to the future advancements in the JRuby community. Remember, feedback is valuable, and we welcome any insights or recommendations you might have.
00:30:20.959
Thank you again for your time, and let’s keep improving JRuby together!
