One of the most useful aspects of JRuby is the ease at which one can integrate tools from the Java ecosystem. For developers building hybrid applications though, using Ruby tools like Bundler and Rake can result in unpleasant hacks. If you stick to classic Java tools like Maven, it can feel like writing Ruby with a straight-jacket on. This lack of mature tooling to support Java/Ruby applications leaves developers in an uncanny valley between the two universes..
With the recent rise of Gradle, which was designed to support a polyglot ecosystem through a rich plugin architecture, there is light at the end of the tunnel for JRuby developers!
This talk will introduce the jruby-gradle project, an effort to combine the very best in Java tooling with the Ruby world, providing top-notch integration for JRuby devs. During the talk we will cover the motivations of the jruby-gradle project and describe how it helps bridge the gap between Java and Ruby. By combining the flexibility of JRuby with the power of Gradle, we can breathe new life into JRuby, opening it up to an even broader audience than before.
There are many great way to use JRuby, but one of biggest some is for glue between Java world and Scripting (, Lightweight, user-friendly or...) World, I think.
We, Treasure Data: data processing service company, have some good example for this case, Norikra and Embulk. These two OSS product have completely different purpose and architecture, but both have very similar mind for using JRuby.
I'll talk about what these software are, why/how these software uses JRuby. and also about the community around these software (especially in Japan).
Years ago the enigmatic Rubyist _why created Shoes, a tiny GUI toolkit for writing fun, simple applications in Ruby. Shoes served as the foundation for Hackety Hack, a programming environment specially designed to be accessible to kids.
In the wake of _why's departure, many people assumed Shoes was finished as well. Such is not the case!
Shoes has continued to evolve and grow, and the latest revision (Shoes4) builds off the cross-platform strengths of JRuby and SWT. If you've ever wanted to write a desktop app as easily as you write a web page, Shoes is for you. If you've ever wanted to get involved in a welcoming, accessible open-source project, we'll show you how to hack on Shoes.
Get your Shoes on, and let's build something awesome!
Mirah, originally called Duby, was created by Charles Nutter. Started in 2009, Charles wanted “a 'Ruby-like' language, probably a subset of Ruby syntax, that [could] compile to solid, fast, idiomatic JVM bytecode." The word itself means ruby (the actual gemstone) in Javanese, the national language of of Java. This talk will discuss how to get started using Mirah, some of the differences between Java, the JVM, and Ruby, and the confluence bringing the best parts together.
There are times when we can work with the technologies we love. And there are times when we have to work with WebSphere and Oracle. The virtues of being opinionated have been extolled since the inception of the Rails framework back in 2005. Sometimes though, it’s necessary to be pragmatic. This talk will feature not only Ruby but also the technologies we hate to work with, the technologies that seemingly only exist to keep consultants and IT departments in work.
Twelve Factor apps are built for agility and rapid deployment. They enable continuous delivery and reduce the time and cost for new developers to join a project. At the same time, they are architected to exploit the principles of modern cloud platforms while permitting maximum portability between them. Finally, they can scale up without significant changes to tooling, architecture or development practices.
In this talk, you’ll learn the principles and best practices espoused by the Twelve Factor app. We’ll discuss how to structure your code, manage dependencies, store configuration, run admin tasks, capture log files, and more. You’ll learn how modern JRuby deployments can benefit from adopting these principles, and why they fit nicely within the cloud.
Scaling Ruby applications is hard. While PaaS solutions like Heroku provide such benefits the costs may be quite high. Most of us our looking for the flexibility of our own bare-metal servers with the scalability of a PaaS.
Docker meanwhile has also provided a great way to isolate or containerize our application. While Docker is great for distribution and deployment, we wonder can we also use it to scale our applications, i.e bringing containers up/down on demand.
Apache Mesos is one such technology we can leverage to add scale to our infrastructure. Instead of dealing with multiple machines we deal with our cluster as a single unit. We allocate resources from this single unit to Docker containers, making it very easy to add/remove resources.
In this talk, we will see a live demo of a Mesos cluster and what it takes to set it up. We will also Dockerize a simple JRuby service and add / scale it to our Mesos setup. We will also learn the advantages and pitfalls of this setup.
This is my quest for achieving fast disk IO for a JRuby persistent queue implementation. This talk will present the possible strategies for doing disk IO, the pitfals of using Java objects in JRuby for data intensive code, and how to write a Java extension to avoid the high cost of type conversion when crossing the world between JRuby and Java. This talk will be a deep dive into JRuby and Java code with benchmarks for all strategies.
JRuby may not immediately come to mind when thinking about implementing a platform for foreign-exchange and stock transactions.
This talk may prove you wrong. It will give some insights and hands-on experience into how using JRuby made our work a lot easier when building and operating a mirror-trading platform on top of an asynchronous and concurrent message-passing architecture. Indeed, by using JRuby one can benefit from Ruby's sleek syntax and elegant programming model while also tapping into the rich set of trading platform integrations available in the Java world. Furthermore, the talk will elucidate the unique robustness and monitoring advantages that we gained in our project from running our stack on top of the JVM using the Tanuki service wrapper for uninterrupted operation and monitoring various components through JMX.
This talk will teach you a magic trick. It will show you to stop our communities from breaking apart. Studies have shown that half the women who enter the technology field will leave over time. HALF! What’s happening? How did we get here? What can we do? In my talk I will show you how we can fix the diversity problem, and why we should care. I'll tell you a true story about about role models, Rails Girls Summer of Code, broken stereotypes - and cat gifs. How to build community-driven initiatives that change our world. And the best part is: Everyone can do it. In one day.