This day-long tutorial session will get you started using Ruby on the JVM through the awesome power of JRuby! Beginning with a walkthrough of setting up your JRuby environment and introducing the fundamentals of the Ruby language, including its elegant syntax and cohesive object model, we'll quickly move on to writing a web application in Rails, covering additional Ruby language concepts as they become relevant along the way.

We'll go over installing Rails and the related concept of Ruby gems. We'll cover the various components of a Rails application, including ActionController, which handles the request-response lifecycle; ActiveModel and ActiveRecord, which represent the Object Relational Mapper fundamentals of Rails; and ActionView, its template languages and associated helpers. We'll cover using migrations to modify database schema, using validations with your ActiveModel instances to verify the data passed into your application, and all the niceties that come with Rails in ActiveSupport and Railties. And we'll do all of this in the rich context of JRuby: we'll build a self-contained .war file of your application that can be deployed like any Java web application, and monitor and profile the application using the rich tools the JVM has to offer.

Register

This session will explore all the new goodness that comes to us in rails 3. For rails developers with experience building Rails 2 apps that are trying to get their mind around all the new hotness, we are for you. We'll explore in detail:

ActiveRelation

How it will allow your finder and named scope code to simpler and more flexible

Routing, now with 62.37% less terribleness!

The routes file can really become a source of great uglification in a Rails 2 app. Let's see how the new routing syntax allow routes to be expressiver and easy to understander.

ActiveModel

The refactoring of the internals of rails now means that it's easy to plugin a variety persistence frameworks to integrate seamlessly with Rails. What's more, it's super easy to roll your own!

Bundler

You've probably heard about this new dependency management framework that's now baked into Rails. It's had its share of controversy, so let's talk about how to use it and why it's awesome.

Register

New to Ruby? No problem.

Come with us on a journey. One that involves learning a new language in a way that demonstrates features and culture in one tutorial. The Ruby language has gotten a lot of buzz in the IT industry lately. It is a highly expressive language that comes with great increases in productivity, or so some say. Test Driven Development is a "Best Practice" that has become quite popular for developing rock solid application with reduced debugging time. Ruby and TDD, two great tastes that taste great together.

This tutorial will combine TDD and Ruby training in a way to introduce you to the "Ruby Way" through tests. In this tutorial we will introduce you to the Ruby language. We will show you the basics of creating objects, control structures, using meta programming and an extended discussion on blocks and the things that might look a bit odd. You will walk away with a solid understanding of basic areas of ruby, a persistent knowledge base, in the form of a test suite, to take home and build upon, and a hunger to learn more and join the growing community of ruby developers. Bring your laptop, a sense of humor, and an open mind.

Register

Software engineering as it's taught in universities simply doesn't work. It doesn't produce software systems of high quality, and it doesn't produce them for low cost. Sometimes, even when practiced rigorously, it doesn't produce systems at all.

That's odd, because in every other field, the term "engineering" is reserved for methods that work.

What then, does real software engineering look like? How can we consistently deliver high-quality systems to our customers and employers in a timely fashion and for a reasonable cost? In this talk, we'll discuss where software engineering went wrong, and build the case that disciplined Agile methods, far from being "anti-engineering" (as they are often described), actually represent the best of engineering principles applied to the task of software development.

Testing is a fundamental part of the Agile process. We live and breathe TDD/BDD. Red/Green/Refactor is our daily mantra. We love cucumber and writing executable, customer readable specifications. We even write tests for our JavaScripts.

And yet, testing remains hard. The tests we love to write are brittle and tend to break when we refactor. Although we talk about the tests being the specification of our code, too often they specify "how its implemented" rather than "what should be done".

This talk is about how to improve the way we do testing, how to move away from merely specifying how our software is implemented to capturing the true essence of how it should function.

Your application is slowing down and you can't seem to speed it up. The code is a mess, and changes are taking longer and longer. You're afraid to release new features for fear of introducing bugs throughout the system. The marketing and sales teams are frustrated by how long new features are taking to release. All signs seem to point to the dreaded Big Rewrite.

Big Rewrites are dangerous projects. The decision to rewrite shouldn't be taken lightly. In this session, we will walk through the pros and cons of Rewrites and give real world examples of Rewrite strategies that work and that fail. From the first hint of a need for a rewrite, through the migration and deployment of the reincarnated system, we'll share our victories, sorrows, joy, and pain.

By the end of the session we hope you'll have a better idea of how to approach The Big Rewrite the next time it rears its never-welcomed head and have a framework which increases your likelihood of success

Are you pushing yourself with the right force, in the right direction, to achieve what you want, what makes you happy, what you're capable of?

Based on her experience of training for Ironman distance triathlons, Keavy will discuss the preparation involved in pushing herself towards her own mental and physical limits, and the effects this has had on other areas of her work and life.

The talk will explore some attitudes and processes in the practice and performance of sport that are critical in reaching your full potential. It will look at how these approaches can also benefit the journey not just of personal development, but career development. It won't be about achieving some grand vision of mastery, but rather on pursuing outcomes that are true to the individual; on making informed, conscious decisions about what to focus your energy on; and maintaining the drive to get there.

This talk aims to inspire people to try harder.

In the same manner that Matz Ruby has C extensions, JRuby has Java extensions. Even though JRuby lets you use existing Java classes directly from Ruby you may still want to write a pure Java extension. This could be to have a higher performing ruby class or to make an existing Java class library more 'ruby-esque'.

My use case was to provide a seamless API for the Hitimes gem across all ruby engines.

This talk will cover the facets of building Java extensions for JRuby and the burgeoning support for existing C extensions.

Mock Objects caught the developer imagination when they were introduced to the world in 2000 and there are mock object frameworks for almost as many languages as there are testing frameworks. Many teams however discover too late the pain caused by using mock objects in their tests; brittle tests, an increasing lack of confidence in the tests and an inability to safely refactor.

This talk will explore the sources of pain caused by using mock objects and present an alternative that is increasingly gaining in popularity.

The discussion about JRuby has for a long time been focused on "Bringing Ruby to the Java World" – but no longer! With the release of "jruby-jars" – a gem containing a runnable version of JRuby available to any platform – the conversation has shifted. We'll look at how akephalos (github.com/bernerdschaefer/akephalos) uses jruby-jars to bridge MRI and HtmlUnit (a pure Java library), and how you can start using JRuby today as a part of your MRI stack.

In 1996, after the fall of the Soviet Union, the U.S. State department funded the development of an import/export control system for the newly formed nations. We were involved in that effort; a major multilingual Java/J2EE application deployed in 7 countries, spanning over 10 years of development. That project has had some great successes in its lifetime, including being a factor in Poland's acceptance into NATO.

Last year we were involved in a modernization effort for that project, including new functionality and an online web presence. Using JRuby, we were able to rapidly develop new features on top of an aging J2EE codebase. This is the story of our success with JRuby in a complex technical and political environment.