Rails Underground

Talk: Working with Legacy Rails Apps - Technical Debt Hell and how to work your way out of it, Desi McAdam

Details

Many of us have found ourselves having to deal with a difficult Rails codebase. Maybe you wrote it before you got good at Rails. Maybe you are rescuing a disaster caused by someone else. Many times our gut reaction is to scrap the legacy codebase and rewrite, but what about times when that isn't a feasible approach? What to do? I will talk about some techniques for working with legacy code, estimating work on legacy apps and other such fun topics.

This topic will be presented by Desi McAdam (click for more details on Desi and all our speakers).

Talk: Dead simple JavaScript Unit Tests in Rails with Blue Ridge and Screw.Unit, Dr Nic

Details

Dead simple JavaScript Unit Tests in Rails with Blue Ridge and Screw.Unit Rails was the first place many of us learnt about unit testing, and then learnt TDD/BDD. Yet everyday Rails developers use JavaScript without writing any unit tests. This is sad.

In the past, perhaps you didn't know how to get started? Didn't know what files were needed? How to write tests? How to emulate user actions?

Not any more. The Rails plugin blue-ridge bundles one of the best JS testing frameworks Screw.Unit, with simple conventions, getting-started generators, and even a headless "rake test:javascripts" task for your continuous integration process.

After this session, you'll never write another line of JavaScript without first writing a test. Or the pagan gods of client-side scripting will slap you.

This topic will be presented by Dr Nic Williams (click for more details on Dr Nic and all our speakers). See also, a really interesting chat with Dr Nic.

Talk: Grand Unified Theory of Software, Jim Weirich

Details

Many words of programming wisdom have been written to promote the idea of low coupling between modules. "Prefer delegation over inheritance", "The Law of Demeter" are examples of these words of advice. But why does delegation introduce less coupling then inheritance. And how does the law of Demeter reduce coupling. To understand these issues, we will look at the concept of "connascence" how it appears to unify many different design principles under an overall view of coupling.

This topic will be presented by Jim Weirich (click for more details on Jim and all our speakers).

Talk: Refactoring With Fire, Gwyn Morfey

Details

New features in Rails are opportunities to improve your code. If you're handed an unmaintainable project, should you refactor it gradually or kill it with fire and start again? If you're refactoring, how do you stop the scope creeping all the way back to a rewrite-by-stealth? If you do choose to cut your losses and rewrite, then how do you avoid the 'second system' effect?

This session will use live code from several of our recent projects, and will discuss how we made the decision, how we managed the resulting work, and some of the techniques we used to beautify the code.

This topic will be presented by Gwyn Morfey (click for more details on Gwyn and all our speakers).

Talk: Blood, Sweat and Rails, Obie Fernandez

Summary

Take a break from the technical mumbo-jumbo and listen to Obie leverage his wit and real-life experience in what promises to be an entertaining and insightful session geared towards current and aspiring Rails entrepreneurs.

Details

In early 2007, Obie took a leap from being a full-time coder into the treacherous world of business. Growing Hashrocket from a little 4-person boutique to 20+ people in less than a year without going broke and keeping clients happy has been a huge challenge.

The session will cover the following topics:

• Sales and marketing: What works and what doesn’t
• Contracts and legal matters: How to cover your bases and try not to get screwed if things go wrong
• Recruiting, hiring and retaining talent: How generous do you want to be?
• Finances: How much do you charge? Time and materials or fixed bids? Cash versus accrual accounting. Keeping investors from freaking out. Collections.
• Ethics: Being a vendor versus being a partner to your clients, where do you draw the line? What do you do when things go wrong?
• Consulting skills: Execution only gets you so far.
• Operations: Fighting entropy and human error every step of the way.
• Transparency: How much do you reveal? To employees? To clients?
• Relationships (dealing with clients): They are hard to keep happy.
• Front-line management (dealing with talent): Kind of like herding cats, and the higher the talent-level, the more difficult the task.
• Dreams of product development: Escaping a cash-flow business.
• Agile practices: Work smart or don’t bother.

This topic will be presented by Obie Fernandez (click for more details on Obie and all our speakers).

Talk: Distributed and Concurrent Programming using RabbitMQ and EventMachine, Paolo Negri

Summary

How to leverage distributed and concurrent programming using RabbitMQ and EventMachine, divide & conquer, and keep all the pieces together

Details

RabbitMQ is a fast, reliable, open source Enterprise Messaging system. If you’re doing high volume messaging and need a high degree of reliability, you should definitely consider using RabbitMQ!

EventMachine is a fast, simple, lightweight event-processing library for Ruby programs. It lets you write network clients and servers without handling sockets- all you do is send and receive data. EventMachine is designed to simultaneously meet two key needs:

• Extremely high scalability, performance and stability for the most demanding production environments; and
• An API that eliminates the complexities of high-performance threaded network programming, allowing engineers to concentrate on their application logic.

In this talk:

• Learn how to process tasks in a distributed environment using RabbitMQ,
• Learn what's behind the asynchronous amqp gem and how it relates to EventMachine
• See some code with EventMachine teasers and learn how to use RabbitMQ to tame your cloud environment.

This topic will be presented by Paolo Negri (click for more details on Paolo and all our speakers).

Talk: Spending more time on the couch: Using CouchDB to avoid migrations, create offline applications and scale with greater ease, George Palmer

Summary

CouchDB is a distributed document orientated database built in Erlang with a RESTful HTTP/JSON API. It avoids the need for migrations, plays well offline and promises easy scaling. This talk introduces the concepts specific to CouchDB, looks at the benefits of using CouchDB compared to a relational database and demonstrates how to use it with rails.

Details

CouchDB is a document orientated database with a RESTful HTTP/JSON API. It is written in Erlang with scaling a foremost thought so is an excellent choice for projects that use a lot of unstructured data, projects that are becoming too complex to map to relational databases or projects that run a version of the application offline. The talk will start with an overview of how CouchDB differs from relational databases and introduce concepts specific to document orientated databases. We then discuss situations where CouchDB will be a good choice and others where it might not be.

CouchFoo is an excellent gem to use with rails for integration with CouchDB. It mirrors the ActiveRecord API in all but a few minor areas so keeps the learning curve low and the ease of migrating projects small. There’ll be examples of how to use the gem, situations in which it differs from ActiveRecord and highlights of functionality available in addition to the ActiveRecord API. Finally CouchDB takes a different stance on when the price of certain operations should be paid for and the last section of this talk looks at these situations. That’s not to say it’s better or worse – just different.

This topic will be presented by George Palmer (click for more details on George and all our speakers).

Talk: Working outside-in with Cucumber, Joseph Wilk

Summary

Cucumber is a BDD tool that can execute plain-text documents as automated functional tests through Ruby mappings. It allows you to build up a custom domain language to talk about your applications behaviour that non-technical users can understand and write. We'll look at working outside-in with Cucumber and the importance of focusing on customer value. Look at how Cucumber fits into the testing workflow, how it compliments Behaviour Driven Development and give practical examples/tips.

Details

Writing software that 'does the right thing' is dependent on good communication with the Customer. Acceptance tests can provide an important way to communicate a customers definition of done and drive use to build the right software. But often these tests are not both executable and easily accessible for non-technical people. Cucumber, a tool to support Behaviour driven development (BDD) aims to help lower communication barriers by using plain text that describes behaviour and via Ruby mappings can be executed. As programmers we can think of Cucumber features as functional tests that are accessible and editable by non-technical people.

This talk given by Joseph Wilk will draw on his experience of introducing outside-in development and having used both the original Rspec story Runner and Cucumber in building Rails apps. We will look at the background of why Cucumber is useful and how it can fit into the testing and agile process. Then through practical examples we will work through the process of turning a feature request from a customer into an executable feature. Examining some of the pitfalls and decisions experienced by people starting Cucumber for the first time. Look at the difficult tools that can be used with Cucumber such as Webrat and how to deal with testing JavaScript with such tools as Celerity or Selenium. Rspec and Cucumber has an active community and we will look at the pooled experiences and lessons learnt from its members.

While the presentation is focused on Rails examples, Cucumber can be used to test lots of different frameworks (and just plain old ruby code!). It can also be used to test code written in other languages with the help of some extra tools:

• Java: Use JRuby
• .NET: Use IronRuby
• Flex: Use FunFX

This topic will be presented by Joseph Wilk (click for more details on Joseph and all our speakers).

Talk: Agile Deployment with Ruby, Laurie Young

Summary

Deploying to and living with a number of different servers is a common requirement. Laurie Young will introduce the best ruby tools for managing this as part of your Agile life.

Details

In order to meet the needs of the various people in a project, as well as deploying software to real live users, we regularly need to use several servers. Developers, product owners, testers and users all have very different needs, which change throughout the lifetime of the project. It can be a real headache managing a number of servers, and keeping them all up and running, with the right version of the code.

Laurie will talk about the types of servers you are most likely to need, how they can be used to give all the people on your project what you need. He will also explain how you should manage these servers, and what tools you can use to make this easy and pain free.

This topic will be presented by Laurie Young (click for more details on Laurie and all our speakers).

Talk: Sneaking Ruby & Rails Into Big Companies, Maik Schmidt

Details

In big companies it can be fairly difficult to introduce new tools and technologies for many reasons. Although Ruby and Rails have become very popular over the last years, there are still software developers who have not even heard about them. That's especially true for enterprise developers whose working days are often dominated by Java and friends.

Rails has been used in production environments since its early days and it made many people's daily work much more productive and way more fun. But there are common issues many developers face when trying to get Ruby/Rails adopted: Nobody knows it. We have invested so much into other technologies. It does not scale. There is no big company behind it. It is too slow. There are no tools. And so on...

In this talk you'll learn why Ruby/Rails adoption is more often a social problem than a technical one. You'll also learn about different strategies to convince your boss, your fellow developers, and the operations department of the many advantages of Ruby and Rails. For example, you'll see why it's often advantageous to start with a pure Ruby project and not with a Rails application.

Among many other things you will learn how tiny trade-offs prevent your database administrators from suffering a cultural shock and how to turn "we always did it this way" colleagues into enthusiastic Ruby fans.

This topic will be presented by Maik Schmidt (click for more details on Maik and all our speakers). See also, an interview with Maik.

Talk: An Agile Workflow with Rails - productive Rails development and client happiness, Paul Campbell

Summary

After a year working with Contrast and Exceptional and now in the consulting world, I've learned a lot about applying various agile techniques to keep clients happy and squeeze every last inch of performance out of my development.

Details

Programming is hard. Consulting is hard. Keeping clients happy is hard. But they needn't be impossible. Agile development sprung up in the mid-nineties specifically to combat common software development failures like scope creep, client communication and buggy code. There's no one silver bullet to these approaches, but I'll show how a truly agile approach teaches a means to an end, a discipline and as a set of practices and attitudes will lead to happy, productive and profitable development all round.

This topic will be presented by Paul Campbell (click for more details on Paul and all our speakers).

Talk: Bringing the Web to Your Desktop with MacRuby, Geoffrey Grosenbach

Web-based APIs abound and give you easy access to your data.

Instead of fighting with browser implementations, write your next administrative or client-side app for the desktop with MacRuby! You get access to native widgets, graphical layout tools, and powerful APIs. Consuming XML or JSON web services is a breeze. Transparent interaction between Objective-C and Ruby source files make integration of existing code possible.

If you're familiar with Ruby or want a better way to write web-connected desktop Mac OS X apps, come learn how to get started!

This topic will be presented by Geoffrey Grosenbach (click for more details on Geoffrey and all our speakers). See also, our interview!

Talk: And the Greatest of These is ... Rack Support, Ben Scofield

Summary

The benefits of Rack support in Rails have become increasingly obvious; Rails Metal and integrating multiple Rack applications have made possible architectures that were impractical before, and some long-held opinions are ripe for change. In this session, we'll see how to set up this integration and explore real examples of how it can be used—including the rehabilitation of page caching.

Details

Over the past year, Rails has gradually become a better, more connected citizen within the Ruby web space. The Merb merger is one part of that, but one of the biggest steps came much earlier, when Rails added Rack support. In addition to the obvious benefits, Rack support in Rails has made possible some new application architectures that were either impossible or ill-advised previously. Specifically, it is now possible to build a complex Rails application that can still respond extremely quickly and directly to a specific set of requests, such as those an AJAX service might experience.

This capability has only been improved by the introduction of Rails Metal, and by the ability to integrate distinct Rack applications (for instance, Sinatra apps) with Rails projects. In this session, we’ll briefly review how to get this integration running, but the majority of the time will be spent exploring real examples of how this approach changes how applications can be built. We’ll see how this technique rehabilitates page caching, turning it from a narrowly-applied strategy to a general-purpose performance booster. We’ll also see how this approach can save an application from incredibly frequent but tiny requests that could otherwise bring it to its knees. Finally, we’ll address some general problems that may arise as this technique becomes more popular.

This topic will be presented by Ben Scofield (click for more details on Ben and all our speakers).

Talk: Rails I18n From The Trenches, Clemens Kofler

Summary

This talk aims to provide novice and advanced users of Rails i18n with valuable information on how to tackle translating and maintaining an internationalized and localized Rails application. The talk will give an insight into existing structures and techniques in Rails i18n and an overview of existing plugins and tools as well as an outlook on potential future developments.

Details

Rails has finally got a well thought-out i18n API that facilitates development of internationalized multi-language applications without having to wait for updates for Globalize et al. if a plugin didn’t work with the current Rails edge. Although developing an i18n application became much easier with the advent of Rails i18n, there are still some caveats and things worth knowing before getting started and ending up in a huge mess of unstructured translations. This talk therefore aims to provide beginners and advanced users of i18n with rock-solid information on how to tackle the difficult task of developing a multi-language application.

Topics discussed will be:

• Basic overview of the Rails i18n API and the Simple Backend that ships with Rails
• Locale files and standard namespaces
• Different approaches to doing the "same" thing (e.g. using translations vs. using different templates for translating a whole page)
• Overview of plugins and tools that facilitate development with i18n as well as current developments (e.g. experimental support for lambdas in translations and better pluralization)
• Outlook and information for people interested in getting actively involved in the development of Rails i18n and the community around it

This topic will be presented by Clemens Kofler (click for more details on Clemens and all our speakers).

Talk: The Ruby Guide to *nix Plumbing, Eleanor McHugh

Summary

A lightning tour of writing multi-process Ruby applications in the *nix environment with nothing more than a vanilla Ruby runtime and a knowledge of system call numbers.

Details

During the course of this talk I'll look at Ruby's support for the *nix process model and explore some of the cool ways this can be exploited to create multi-process applications suited to today's multi-core systems.

There will be a fair amount of code for off-line study which will be glossed over during the presentation due to the time constraint and overall the pace is likely to be brisk with the intention of going from basics to intermediate level in about thirty minutes. I would estimate between thirty and forty slides in total, which will be available online as soon as the presentation is over.

We start with the basics, demonstrating the uses of Kernel#fork and Process to spawn and manage *nix processes. This is followed by coverage of interprocess communication using signals, pipes and sockets. Next we introduce Kernel#syscall as a means of tapping directly into low-level functionality, rolling our own version of Kernel#fork on OSX before looking at named pipes and memory mapped files.

Example applications will be examined such as watchdog timers, background I/O processes and parallel enumerators.

With time running short we'll optionally follow up with coverage of System V IPC using Kernel#syscall for message queues, semaphores and shared memory.

This topic will be presented by Eleanor McHugh (click for more details on Eleanor and all our speakers).

Talk: The Invoiving Gem. Sales & payments in your app, Martin Kleppmann

Summary

You have an awesome app, and your users are willing to pay you to use it? There is still a barrier between you and the money: accounting, tax, payment processing, maybe special discounts, reseller deals and more... Martin will show how to overcome the boring financial stuff quickly using open source tools, while leaving you with the flexibility you need to scale the business in future.

Details

Commercial web apps are rapidly gaining popularity: there are many examples of small web development companies finding success in the model of charging a small-to-medium monthly subscription or pay-as-you-go fees, often targeting small business customers. These businesses rely on getting a large number of customers who each pay a small amount; it is therefore essential that the processing of the financial transactions is completely automated.

I am a developer and have experienced several web projects which needed to process financial transactions, during which I encountered plenty of challenges: automatically producing invoices, handling payments and tax, VAT rate suddenly changing, accountants' confusing terminology, bizarre legislation, complex billing relationships with suppliers, resellers and partners, internationalisation and multi-currency support.

Therefore I decided to develop some open-source tools which would deal with all the boring core financial bookkeeping within a Rails application, which would be resuable across a wide range of applications, and which would work in a way which was both developer-friendly and accountant-friendly. The result is the Ruby Invoicing Gem and associated tools. It is a framework which allows you to write just as much business logic as you need, and deals with everything else.

This walk will outline how the Ruby Invoicing Gem solves the problems which arise, and demonstrate how it works with a hands-on technical example (a Rails application operated by a small UK-based company). There will also be a perspective on interoperability between accounting applications using open web APIs.

This topic will be presented by Martin Kleppmann (click for more details on Martin and all our speakers).

Talk: Launching Ruby on Rails projects, a checklist, Robby Russell

Summary

A collection of best practices and lessons learned for launching your next Rails application.

Details

The big product launch is approaching for your shiny new application and you’re scrambling to fix last minute bugs and work out the kinks. Deep down, you have this suspicious feeling that you’re forgetting something important. Whether it’s your first or your twentieth time that you’ve launched an application, it’s almost guaranteed that there are things that will get overlooked.

In this talk, Robby Russell, a partner and the Chief Evangelist at Planet Argon will walk the audience through his team’s Project Launch checklist, which has evolved through several years of designing, developing, and deploying web applications. Robby will share his experiences and outline a collection of best practices such as; keeping your project releasable at all times, managing staging and production environments, bootstrapping your application for SEO and analytics/conversion tracking, preparing for the unexpected, and most importantly… making sure your clients are ready for the bumpy ride.

Robby’s goal is to share from the hard lessons that his team has experienced over the years and provide you with some ideas to walk away with you. As you’ll learn, it’s never too early to start preparing an application for the big launch.

This topic will be presented by Robby Russell (click for more details on Robby and all our speakers).

Talk: Behaviour driven monitoring with cucumber-nagios, Lindsay Holmwood

Summary

cucumber-nagios takes the results of a Cucumber run and outputs them in the Nagios plugin format. Instead of simply checking whether your app is up, you can monitor your production app's behaviour. Learn how to use it, what checks to write, and why it's important!

Details

Setting up monitoring for web applications can be complicated - tests tend to lack expressiveness, and quite often don't even test the right problem in the first place.

cucumber-nagios lets you write behavioural tests for your web apps in plain English and outputs the test results in the Nagios plugin format, letting Nagios notify you when your production apps aren't behaving.

Lindsay will be covering how to get up and running with the tool, writing tests for your web apps, and why it's important to test the behaviour (and not just the availability) of your production web apps.

This topic will be presented by Lindsay Holmwood (click for more details on Lindsay and all our speakers).

Talk: Building Native Mobile Apps in Ruby, Vladimir Tarasov

Summary

Building Native Mobile Apps in Ruby - write an app once, and run on all iPhone, Windows Mobile, BlackBerry, Symbian and Android smartphones

Details

Rhodes is an open source Ruby-based framework for building and locally executing device-optimized mobile applications for all major smartphone devices.
These applications work with synchronized local data and also take advantage of native device capabilities such as GPS, PIM contacts, camera, and SMS. Yet, you write the majority of your interface with high productivity HTML and Ruby. Rhodes allows you to write an app once and it will then run on all iPhone, Windows Mobile, BlackBerry, Symbian and Android smartphones.

During this session we'll build a sample app for all mobile devices, from scratch, in minutes.

This topic will be presented by Vladimir Tarasov (click for more details on Vladimir and all our speakers).

Talk: Rails and the internet of things, Elise Huard

Summary

The internet of things is a meshing of the physical and online world.

The first stage is labelling the objects around us in such a way that the label corresponds to online resources ('augmented reality'). This element has been present in Japan for a few years now, and is used for many applications. This talk will discuss what's required to make this truly practical in Rails. The second stage of this integration is to have objects communicate actively. This at present requires custom hardware with sensors - talking to APIs.

Details

What is the internet of things, and how can the Rails community move into that area?
Internet availability is increasingly common - many places offer WIFI, and data plans for mobile users become more and more affordable. The direct consequence is that we can mesh the material world with the online world.
Japan is once again ahead of the curve, with phones that have been able to parse bar codes for 4 or 5 years now, and there are many successful use cases. Think public transport - where your phone can tell you in an instant when to expect the next bus, just by capturing a bar code. Products in the shop having bar codes, so one can check all kinds of facts about them. And of course, numerous applications for advertising
The next, easier step will be NFC-enabled phones: just wave your phone next to an active resource - even more user-friendly. Then there's communication from objects themselves: from the twittering tower bridge, to a potted plant asking for water. This requires custom hardware, like arduino boards equipped with sensors, and calling APIs of web applications to contribute their information. All these exciting tendencies can be exploited, and indeed must be prepared for, by the Rails world.

This topic will be presented by Elise Huard (click for more details on Elise and all our speakers).

Talk: Sphinx - Beyond the Basics, Pat Allan

Summary

The Sphinx search service is quite easy to get up and running with a Rails app - that doesn't mean it's only useful for simple things. Pat Allan runs through some of the more advanced ways of using Sphinx with the ActiveRecord plugin Thinking Sphinx.

Details

The Sphinx search service has become the de facto search solution for Rails developers over the past few years. The popular Thinking Sphinx plugin has made it easy to get Sphinx up and running with a minimum of fuss, but sometimes that can hide the powerful ways to customise and get the most of out Sphinx for your application. Pat Allan will provide a solid overview of several different ‘recipes’ for advanced Sphinx usage, including:

• Facets
• Excerpts
• Geo-Searching
• I18n and Character Sets
• Different Delta Approaches
• Multiple Server Deployment

This topic will be presented by Pat Allan (click for more details on Pat and all our speakers).

Talk: Git Basics, Ariejan de Vroom

Summary

The Git Basics talk is geared towards people who want to use Git more effectively on a daily basis. Driven by real-life examples different git related techniques will be covered. From basic branching and tagging to how to manage/organise your repository. Special attention goes to hosting an open source project on GitHub effectively.

Details

• Short introduction to git
• Short introduction to branching
• How to use branches and tags with your Rails app and different environments (test, staging, production)
• How to manage forks and patches from other (GitHub) users (how to use the ForkQueue and the Signed-off-by feature)
• A few minutes are reserved to answer questions

This topic will be presented by Ariejan de Vroom (click for more details on Ariejan and all our speakers).

Talk: Mobilize Your Rails Application, Brendan G. Lim

Summary

Learn how to effectively take your Rails application into the mobile space using existing gems and plugins.

Details

Mobile communication and interaction shouldn't just be limited to voice. There are many ways to effectively take advantage of mobile technology that can help us build better Rails application tailored to portable devices.  Taking your application into the mobile space is easier than one would think. Find out why it’s important to go mobile and just how to do so.

Topics will include:

• Overview of history and present trends in mobile
• What’s one web and the problem with achieving it?
• Creating mobile web applications with Mobile Fu
• Tailor your application for the iPhone with Rails IUI
• Overview of SMS/MMS and why they are important
• SMS integration with Clickatell, Textmarks, and SMS Fu
• How to send and receive MMS

This topic will be presented by Brendan G. Lim (click for more details on Brendan and all our speakers).