With an expressive language such as Ruby and with modern test practices, 100% C0 test coverage is readily achievable. But 100% coverage is meaningless without other supporting habits and practices. Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong:

• Fragile mocking
• Pair bravado
• The ugly mirror
• Parallel abstraction
• Overspecification
• Underspecification
• Invisible code
• Misplaced exemplar

We will look at examples of each of these problems, and show how to prevent them from infecting your project.

Identity Management is an important part of both corporate environments as well as public-facing web applications and yet it is often misunderstood or not given the attention it deserves. This presentation will take the audience through various technologies that can be used to manage user identities and more importantly to share and federate those identities among application both within the corporate firewall as well as beyond it. We will examine current Ruby solutions as well as solutions from other languages. We will also look at what the future may hold for identity management and what some of the complications are for Ruby in the world of federated identity.

In this talk we will examine how IronRuby can be utilized to breath new life into preexisting .NET code. The words "Silverlight" nor "Rails" will be uttered. This talk is not about glitz and glam, this is about how IronRuby can help your existing .NET enterprise.

Programmers don't know every inch of the Business Domain and Domain experts can't program. IronRuby can create an intuitive interface between these two worlds, even with legacy code.

A preexisting application will be scripted and automated utilizing IronRuby in order to create a Domain-Specific Language leading to a more dynamic and easier to use interface. The goal is to allow Business Domain experts to understand, in a natural manner, how the application is being used. Possibly even be able to write their own small bits of functionality!

In this session you will learn how JRuby can bring simplicity to the complex and rich APIs available in the Java platform. Learn how to use JRuby to tackle some common tasks in Java SE and Java EE by abstract and simplify the sometimes complex APIs of the Java platform.

Java testing can be made simpler and more expressive using JRuby. JRuby can be the wedge to introduce Ruby into your organization. Java, particularly J2EE, can be extremely difficult to unit test. This presentation will provide an introduction to tools and techniques, using JRuby, to minimize the pain of Java unit testing and maximize the love.

Metaprogramming is hip, exciting, and meta. Metaprogramming is coooooool. Metaprogramming is a pain in the butt to debug and will confuse the gosh-darn heck out of your junior programmers.

An underrated alternative to metaprogramming is code generation. Code generation permeates Rails and is one of the major causes for its success. It's a crucial strategy for reducing complex problems to simple solutions. If you want to leverage convention over configuration, code generation is the way to do it.

In this presentation we'll look in detail at a successful example of using code generation to achieve seamless and elegant enterprise integration.

ETL (Extract Transform and Load) is the red-headed stepchild of the enterprise world. Nine months might have gone into the design of your latest analytic project but you’re lucky if nine hours has been spent working through the details of transferring data from the old system to the new. With most data processing systems currently built data input and output are secondary thoughts: a painful, time-consuming exercise for whomever survives the aftermath of high priced consultants. This process is further complicated by ETL systems being closer to art than engineering. Hacks, workarounds, and inelegant but effective tricks are all standard tools in the ETL tool box. If you are (un)lucky enough to have built (or inherited) a functioning ETL system, it is often a read-only system that cannot be easily expanded without first consulting the dark gods of programming and offering up the blood of a COBOL programmer. But it doesn't have to be that way.

Our presentation will look at both guiding principles and concrete examples of the good, the bad, and the ugly of ETL systems. We'll arm the listener with strong recommendations on what to do (and more importantly what *not* to do) when building an ETL system. We'll cover automation, tricks for getting data into and out of legacy systems, potential performance bottlenecks and some favorite hacks that just might do the trick in a pinch… all with an eye to making your next ETL system more robust, faster to develop and simpler to maintain.

Ruby Anvil promises to be the rails/merb equivalent desktop application framework for Ruby. By borrowing the ideas and knowledge accumulated from both frameworks, we can utilize Ruby to create yet another framework for developers and build desktop applications with ease, speed and beautiful code. In this talk I'd like to discuss some of my plans for the future of Ruby Anvil and what is currently being developed.

Ruby Anvil is bringing all the GUI toolkits available for Ruby (FxRuby and WxRuby) and attempting to build a standard DSL that will be usable in views of a desktop application. The goal is to eventually support all kinds of GUI toolkits and technologies like Swing, RubyCocoa and OpenGL. Anvil will utilize the MVC pattern so that you can delegate objects to the view in a clean way. The data will be grabbed from the database (using one of the 3 most popular ORMS- ActiveRecord, Datamapper, Sequel). It will provide a way for you to construct widgets that you can reuse as well as provide preformed widgets you can customize the attributes of using the DSL. Merb's Modular plugin system is going to be emulated by utilizing rubygems as the package manager. In addition to having a DSL that can manipulate widgets, there will be a way to establish widgets by formatting a YAML file.

For the presentation I plan on walking everyone through creating their own Anvil application (most likely Hello World). Using the application we generated, I will show the features I've discussed in action as well as the current state of the implementation. Hopefully, I can get enough people interested to contribute!

When it comes to integration with very old legacy systems, sometimes you simply have no other option than to blackbox it. This talk will discuss using blackboxing to integrate a very old legacy system with Ruby and Rails. It will discuss the speaker's experience with creating RESTful interfaces for a new system, while also exposing an interface for a legacy system. The finished system acted like a normal web application, and no one would have to know that half of it ran off a system developed in 1988.

The experience is presented as a case study, emphasizing using Ruby's capabilities and libraries with Rails RESTful interfaces to create usable web applications for legacy systems. Previous iterations and attempts will presented, and their strengths and weaknesses discussed. The core of the presentation will center on the final solution: a number of lightweight application servers that talk to a custom web client. This approach kept the resource usage low and the flexibility high. The presentation will contain mostly high level concepts, with a good bit of code shown for the final solution.