Ruby Conference India 2011 - Logo

RubyConf India 2011

India's second RubyConf is happening in Bangalore in May 2011. RubyConf India is presented by the Ruby Community in India and supported by RubyCentral and the Innovation & Technology Trust.
Royal Orchid Hotel, Bangalore
28th & 29th May


The keynote addresses and list of proposals that have made it to this year’s RubyConf India 2011 are listed below:


Day 1 - May 28th - Sat



Rohit Bansal



Keynote - Building Rails Apps for the Rich Client
Yehuda Katz



Video Keynote - Why Ruby again



Ruby Plus Rails Plus Your Application Minus Rails
Brian Guthrie

Single page Web apps with Backbone.js and Ruby on Rails
Prateek Mohan Dayal






Refactoring a Legacy Java Application to Rails
Nick Sieger

Deciphering The Ruby Object Model
Karthik Sirasanagandla



Make your own Rails Framework
Pankaj Bhageria

I can haz HTTP: Consuming and producing HTTP APIs in the Ruby ecosystem
Sidu Ponnappa and Niranjan Paranjape



Writing Compilers the Easy Way
Vishnu Gopal

How Ruby helps Rackspace challenge Amazon
Munjal Budhabhatti



A Quick Note from The Sponsors of RubyConf India 2011



Service (Keynote over Video Conference)
Chad Fowler

Day 2 - May 29th - Sun



Keynote - The Good, the Bad, and the Ugly
Ola Bini



Let's have a cup of CoffeeScript
Nicolás Sanguinetti

Anti-Patterns and Patterns in Rails
Chirantan Mitra and Habibullah Pagarkar



Continuous Delivery in Ruby
Srushti Ambekallu and Brian Guthrie

Mark Madsen






But the language supports it
Niranjan Paranjape and Aakash Dharmadhikari

Test Load Balancer: Rocket Booster for your Build
Janmejay Singh and Pavan K Sudarshan



Software Quality and Test Strategies for Ruby and Rails Applications
Bhavin Javia

Designing High Throughput Web Service Clients
Sherin C



Rubyizing the Dev and Ops in an Enterprise
Yashasree Barve

Memory Is The New Disk, Say Hello To Redis
Bratish Goswami



Keynote - Happiness : Ruby :: Freedom : JRuby
Nick Sieger

The super cool yakuake/visor style drop down may not work in older versions (non CSS 3) of browsers. The overlay works ok on the iPad in portrait mode, but landscape is a little awkward. Sorry. But you can see all the talks here

Bhavin Javia do |talk|
  talk.title "Software Quality and Test Strategies for Ruby and Rails Applications"
  talk.speaker :bhavin_javia
  talk.on :track2 =>
Quality is one of the most important factors in deriving business value from software. However, many teams find it difficult to incorporate the appropriate quality and testing practices into their development processes. A test strategy helps create a shared understanding of what testing will be required, and how and when it will be executed.

The Ruby and Rails communities have embraced testing and code quality as core values, and a rich ecosystem of tools has developed. Despite this support, many developers and teams overlook the creation of a test strategy as it is thought to be an unnecessary overhead that is traditionally associated with formal/waterfall style development methodologies. However, a well developed Test Strategy can be the difference between great software and a maintenance nightmare.

This presentation will explain the process of defining quality (internal and external) for Ruby and Rails applications including metrics and targets. It will then explain the process for creating and executing a Test Strategy that ensures the intended quality objectives are achieved. Additionally, it will explain how to align a Test Strategy with the typical practices of a team using Agile or Lean methods.

Learning Outcomes:

  1. Definition of Software Quality and appropriate metrics and targets
  2. Purpose and role of Test Strategy within an Agile development environment
  3. Creation of a Test Strategy tailored to suit Ruby and Rails applications
  4. Testing tool selection within Ruby ecosystem
  5. Approach and benefits to Ruby developers focusing on code quality
Brian Guthrie do |talk|
  talk.title "Ruby Plus Rails Plus Your Application Minus Rails"
  talk.speaker :brian_guthrie
  talk.on :track1 =>
Ruby on Rails is a famously opinionated framework that handles ninety percent of the problems a typical web application faces. But what about the last ten percent? Every app has to jump off the Rails eventually, whether that means integrating with an external web service, importing data from another database, or providing enhanced search functionality. In this talk I'll lead you through some patterns for handling those cases, and discuss certain features of Rails 3 that let you leverage the best pieces of the core framework without resorting to ugly hacks. Finally we'll discuss what a new, more modular core framework means for a post-Rails world.
Chiku Habib do |talk|
  talk.title "Anti-Patterns and Patterns in Rails"
  talk.speakers :chirantan_mitra, :habibullah_pagarkar
  talk.on :track2 =>
The presenters, Chiku and Habib, were team members on a distributed Agile Software project. Their job was to quickly write mission critical Rails applications, and they practiced various aspects of Continuous Delivery. Over the duration of this project, they noticed the evolution of interesting patterns that were thought to be great ideas. Many were, some weren't.

Chiku and Habib will be pair-presenting their learnings in a way that mirrors the eternal tussle that a developer faces daily - convenience versus quality. One of them will assume the role of a devil and persuasively present a code-fragment that mirrored one such anti-pattern. The other will then take over as an angel and explain the problem inherent in that code-fragment, and proceed to clean it up. They will then swap roles and proceed to the next point.

At the end of this presentation, the audience will have the knowledge of identifying and subsequently fixing similar manifestations of these problems in their code.
Janmejay Pavan do |talk|
  talk.title "Test Load Balancer: Rocket Booster for your Build"
  talk.speaker :janmejay_singh, :pavan_k_sudarshan
  talk.on :track2 =>
Test Load Balancer (TLB) is a tool that can automatically partition tests into multiple subsets, each one of which can be executed in parallel. The execution can happen on different physical/virtual machines or on the same machine as different processes or threads. The more the partitions, the less the number of tests executed on each one, and since all of the partitions start at the same time (and finish almost at the same time) overall test-execution time gets divided by the number of partitions you make. Test-running is by far the longest step in most (if not all) builds, and cutting down test-running time speeds up the build and hence the feedback loop. TLB can be used for any kind of test-suite - unit, integration or functional tests.

In addition to balancing, TLB does other interesting things like re-order tests within a subset (set of tests that run on a partition) before they are executed. For instance, it re-arranges tests to execute failing ones (that failed in the previous build) first, hence ensuring early feedback.

Most build servers (like Hudson, Go, TeamCity, Bamboo, etc.) and even tools like capistrano/cluster-ssh provide parallel execution capability (capability to execute command(s) on different machines at the same time). However, parallelization of tests needs a tool that can decide what tests need to be run in each such parallely running process across machines. This is where TLB comes in.

This talk will introduce the audience to TLB concepts and include a demo of using TLB to partition RSpec and Test::Unit suites. It'll also include a case-study on how TLB helped cut build time from approximately 70 minutes to 11 minutes (which can of course be further reduced) just by throwing more hardware at it.
karthik do |talk|
  talk.title "Deciphering The Ruby Object Model"
  talk.speaker :karthik_sirasanagandla
  talk.on :track2 =>
By personal experience, while transitioning from the world of Java to the world of Ruby, I felt great pain and agony, whenever I read statements like "Everything in Ruby is an object; classes themselves are objects". It took me more than a while to get it all right. I am of the belief that the experience is the same for many who transitioned to the Ruby platform. If you didn't experience this...lucky you! My reason for this experience is that during the early days of learning Ruby, I felt that the Ruby Object Model is some advanced topic as it is comes under Ruby Meta-programming, and that I can do away with it until I'm more than an intermediate level Ruby developer. In reality, though, any decent programming in Ruby meant understanding rightly - the Ruby Object Model. Understanding the Ruby Object Model helps not just in learning Meta-programming, but also improves code design with enriched knowledge and appreciations of the object model.

In my presentation, I intend to talk about the Ruby Object Model, elaborating on the concepts of visualizing classes and objects in Ruby, how they are different from Java, method look-ups in Ruby, class/static methods in Java/C# vs. the ones in Ruby, mixins over inheritence and composition etc. All these concepts will be communicated by means of code snippets and no-nonsense visuals (object-like diagrams).
nick do |talk|
  talk.title "Refactoring a Legacy Java Application to Rails"
  talk.speaker :nick_sieger
  talk.on :track1 =>
The JRuby team has been proclaiming JRuby on Rails as the cure to legacy Java blues for years, but we've been lacking a compelling example that developers can use as a guideline for how to achieve this. We'll discuss and demonstrate three possible approaches, allowing for a minimal, medium, and large amount of reorganisation to an existing project. Each approach will build upon the previous one, showing developers how they can take an incremental approach to introducing Ruby into an existing Java environment to increase development productivity.
munjal do |talk|
  talk.title "How Ruby helps Rackspace challenge Amazon"
  talk.speaker :munjal_budhabhatti
  talk.on :track2 =>
ThoughtWorks has been working with Rackspace, one of the leading hosting companies in the world, on a large scale data center automation project using Ruby. We want to share some insights on how Ruby enabled Rackspace, with a small development force, to challenge Amazon.

  1. Developers investing time learning and programming the domain and not the framework
  2. Ease of refactoring for major domain changes such as ipv6, architecture
  3. DSLs allowed SMEs, instead of developers, to easily tailor business logic while reducing everyone's work load
  4. Powerful Enterprise integration with disparate system via Atom, REST, custom message queue, and even SOAP
  5. Realtime manipulation of interdependent systems for integration testing
  6. Ruby philosophies and communities
  7. Q&A
prateek do |talk|
  talk.title "Single page Web apps with Backbone.js and Ruby on Rails"
  talk.speaker :prateek_mohan_dayal
  talk.on :track2 =>
jQuery is great for websites that need simple AJAX interactions and some effects (example Youtube/Flickr). However, if you want to build complex single page web applications like Gmail or Mobile Me, you need something more than jQuery. Keeping track of DOM elements to be updated in response to a particular action or result of an ajax query can become overwhelming very fast.

Frameworks like Sproutcore, Cappuccino and Backbone.js provide structure to your javascript code. Backbone supplies structure to JavaScript-heavy applications by providing models with key-value binding and custom events, collections with a rich API of enumerable functions and views with declarative event handling.

In this talk, we will go over building a simple Backbone.js application with Ruby on Rails backend and discuss some tricks and techniques that I have discovered while building The outline of the talk is:

  1. Motivation for using a framework like Backbone.js. A quick comparison with Sproutcore and other frameworks
  2. Creating models, views and collections in backbone.js
  3. Setting up a controller to route requests (and preserve the back button behaviour)
  4. Setting up backbone.js to play nicely with Rails' ActiveRecord::Base.include_root_in_json
  5. Handlebars for templating
  6. Jammit for easily packaging all asset files (including javascript files for backbone's models, views and templates)
  7. Compiling handlebars’ template files and making them available to your code for rendering in a global variable
  8. Using as_json to customize the json serialization of Rails’ model
  9. A technique to make as_json use an included association’s as_json. The change can be seen at here
  10. Thoughts on testing a full page app. Also some thoughts on creating a restful API using restfulie
niranjan aakash do |talk|
  talk.title "But the language supports it"
  talk.speakers :niranjan_paranjape, :aakash_dharmadhikari
  talk.on :track1 =>
Discussing language constructs with fellow developers in the context of solving a particular problem is something we do routinely. While most such conversations are productive and useful, a fair portion degenerate into angry brawls. A pattern we've observed in the latter situation is that a surprising number of times the argument is that, "Why shouldn't I use language feature X to achieve objective Y- after all, the language supports X."

In this talk, we will cover various features provided by Ruby that, while awesome, should be used with caution. We will cover:

  1. The appropriate situation where a certain language construct should be used
  2. Situations where I've seen it misused
  3. The underlying principles that will guide you as to how to use it best.
  4. Alternative approaches that achieve the same effect

Here's a brief list of language constructs we will cover:

  1. if and switch-case
  2. return
  3. raise (exceptions)
  4. private/protected methods
  5. variable method arity (includes ActiveRecord style constructors that take any number of arguments tunnelled through a hash)
  6. Class methods
  7. Inheritance
  8. Custom instance allocators as factories (overriding Class#new)
  9. Re-opening classes, especially classes from the core libs
  10. eval
nikolas do |talk|
  talk.title "Let's have a cup of CoffeeScript"
  talk.speaker :nicolas_sanguinetti
  talk.on :track1 =>
CoffeeScript is a great way to write javascript. It provides many abstractions that simplify the language, and a few syntax niceties that make it much less noisy than pure javascript. We'll cover the basic syntax and how it differs from regular javascript, and see some examples. Moreover, Rails 3.1 will ship with CoffeeScript by default, so this is a great time to get up to speed with it!
mark do |talk|
  talk.title "MacRuby"
  talk.speaker :mark_madsen
  talk.on :track2 =>
My intent is to deliver a functional talk on MacRuby that not only introduces features and capabilities, but gives attendees a quick path to practically using MacRuby in their everyday development. I intend to go through important MacRuby specifics like working with Apple frameworks including (but not limited to) threading with GCD, data management with Core Data and Scripting Applications. During the talk, I intend to code two quick examples of everyday MacRuby while delivering tips and hints needed to quickly get running code. Attendees are encouraged to bring their laptops and code along.
sherin do |talk|
  talk.title "Designing High Throughput Web Service Clients"
  talk.speaker :sherin_c
  talk.on :track2 =>
Consuming web services is an inexorable practice nowadays. You could be eating your own dogfood(internal) or a third partys'(external). The consuming process can be modelled either as multi-threaded or event driven. Ruby accommodates either way with stable library support(eventmachine, threadpool) and implementations(JRuby, Ruby-1.8 or 1.9).

This talk will:

  1. Weigh the tradeoffs in choosing a model by detailing an implementation each in:
    -- JRuby (threadpool without GIL)
    -- Ruby 1.8, 1.9 (eventmachine and threadpool with GIL)
  2. Dispel misconceptions regarding choice of synchronous or asynchronous I/O
vishnu do |talk|
  talk.title "Writing Compilers the Easy Way"
  talk.speaker :vishnu_gopal
  talk.on :track1 =>
The Dragon Book by Aho and Ullman teaches many great things about writing compilers and parsers. But writing a compiler from scratch is often a daunting step for a fledgling programmer. Yet, compilers are useful little things that extend our craft in surprising ways. Ruby provides wonderfully accessible libraries to dive into compiler construction and the talk will focus on one of them: Treetop

The talk will detail the construction of a simple filter language and using Treetop to parse grammar and interpret it, and then make it work. Treetop makes it very simple and intuitive to add new operators and new syntax, and the talk will walk through the addition of a new operator to the language. Towards the end, a simple cross-compiler will be discussed that translates our filter language into fast C.
yashasree do |talk|
  talk.title "Rubyizing the Dev and Ops in an Enterprise"
  talk.speaker :yashasree_barve
  talk.on :track1 =>
This talk will highlight the story of an Enterprise that adopted Ruby and Rails as its preferred technology for development in its quest of being Agile over the last four years. This step brought in a makeover in the way the development team functioned as well as the way the operations performed their job.

I would love to share my experience when the development teams embraced Ruby and Rails. The dev teams imbibed and personified the DRY concept by building and institutionalizing enterprise wide gems and plug-ins such as LDAP Management, Single Sign On, Authentication and Authorization, Usage Tracking. The team created an app that allows bootstrapping a new ruby application with enterprise specific plug-ins, configuring Continuous Integration, and deploying to shared dev box in minutes. The dev teams got hooked on to the engineering practices such as automation testing, automated deployments utilizing the power of Rails framework and components such as Capistrano. The adoption of Ruby truly changed the thinking and functioning of the dev teams.

I would also like to talk about how the operations teams opened their world to open source, specifically Ruby. After the initial resistance to open source, the Ops teams now love the Ruby and Rails infrastructure. Ruby gives them immense opportunity to maximise automation, monitoring and management of applications. The Ops team is now inching towards one click deployment of applications across environments, surely a dream come true in any enterprise.
srushti brian do |talk|
  talk.title "Continuous Delivery in Ruby"
  talk.speaker :srushti_ambekallu, :brian_guthrie
  talk.on :track1 =>
The Ruby community has driven a lot of technical innovation in deployment and configuration management over the last few years, and so the idea of delivering high-quality software rapidly should be familiar to most of us. But although our tools are state-of-the-art, getting them to work together properly can be surprisingly frustrating. In this talk, I'll explain how to implement a high-quality rapid build and deploy process using standard CI tools, Bundler, RVM, and Capistrano. I'll also discuss how to coach your developers, QAs, and client to be "production-ready, any time."
bratish do |talk|
  talk.title "Memory Is The New Disk, Say Hello To Redis"
  talk.speaker :bratish_goswami
  talk.on :track2 =>
Redis is a fast, in memory, persistent key/value store. It is often referred to as a remote data structure server, since keys can contain strings, hashes, lists, sets and sorted sets.

The first part of the talk will walk the audience through the basic features of Redis, starting from the installation to the supported data structures and the simple command set to manipulate them along with some stats related to them. Through its Ruby port Redis-rb, Redis datatypes resemble datatypes of Ruby, which makes it very natural to the Ruby programmer to use it. The simplicity and the power of Redis with Ruby will be discussed in this part. This will include a parallel hands-on session depicting operations and snippets.

The second part of the talk will cover some real world use cases. Places where Redis with Ruby is used successfully and places where Redis can win. Detailed review of a few libs/apps built around Redis. Benchmarks, master-slave replication and Redis-cluster will be discussed. And finally, places where Redis is not a good fit.

The whole talk will circle around the concept of a perfect jugalbandi between Ruby and Redis.
sidu niranjan do |talk|
  talk.title "I can haz HTTP: Consuming and producing HTTP APIs in the Ruby ecosystem"
  talk.speaker :sidu_ponnappa, :niranjan_paranjape
  talk.on :track2 =>
The Ruby ecosystem is pretty awesome when it comes to developing or consuming HTTP APIs. On the publishing front, the Rails framework is an attractive option because it supports publishing what are popularly (but inaccurately) referred to as 'RESTful' APIs quickly and effortlessly. On the consumer side, the Ruby ecosystem provides several very fluent and powerful libraries that make it easy to consume HTTP based APIs.

Since a significant proportion of projects today require that APIs be both published and consumed, many of them wind up choosing Ruby as a platform for the reasons mentioned above. This talk is targeted at folks that are currently on such projects, or anticipate being on such projects in the future.

We will cover:

Consuming HTTP APIs:

  1. The basics of making HTTP calls with Ruby
  2. The strengths and weaknesses of Ruby's Net::HTTP across 1.8, 1.9 and JRuby (possibly Rubinius if we have the time to do research)
  3. Popular HTTP libraries that either make it easier to do HTTP by providing better APIs, make it faster by using libCurl or both
  4. Different approaches to deserializing popular encoding formats such as XML and JSON and the pitfalls thereof

Producing HTTP APIs using Rails:

  1. The basics of REST
  2. What Rails gives you out of the box - content-type negotiation, deserialization etc. and the limitations thereof
  3. What Rails fails to give you out of the box - hypermedia controls etc.
  4. What Rails does wrong - wrong PUT semantics, no support for PATCH, error handling results in responses that violate the clients Accepts header constraints etc.
  5. How one can achieve Level 2 on the Richardson Maturity Model of REST using Rails
  6. Writing tests for all of this

At the end of this, our audience will understand how you can both consume and produce HTTP APIs in the Ruby ecosystem. They will also have a clear idea of what the limitations of such systems are and what the can do to work around the limitations.
pankaj do |talk|
  talk.title "Make your own Rails Framework"
  talk.speaker :pankaj_bhageria
  talk.on :track1 =>
This talk will take the audience on the path of building a basic version of a web framework like Rails. Most of us think of Rails as a black box. We do not know, or we haven't tried understanding what is happening behind the scenes. Starting from a very basic Rack server, we will build up a Rails framework with features like routing, controller, action, default views, filters, model, etc. It may not be exactly the same as what happens in the actual Rails framework, but it will help explain the concepts.

SSome basic knowledge of Ruby is expected. I will teach some dynamic Ruby that is required for to follow this talk. Finally, we will develop a web framework that will be similar to Rails. Since we will be developing only the basic features, the number of lines in this solution will be very less. People would be astonished that we actually built a Rails framework in very few lines of code.

Why should we build our own framework when Rails already exists?
  1. Make the Rails black box more transparent, i.e. help us understand what's happening behind the scenes
  2. This will encourage people to go and hack the framework
  3. It will increase people's confidence which will encourage them to contribute to Rails
Yehuda Katz do |talk|
  talk.title "Building Rails Apps for the Rich Client"
  talk.speaker :yehuda_katz
  talk.on :combined_track =>
We all know that Rails is great for building traditional web applications that serve dynamic HTML pages. But more and more, people are reaching to other tools, like Node.js, when they build web applications with a lot of logic in the client. People often use the argument that when you remove the view helpers, there isn’t much of value left in Rails.

In fact, because the Rails framework made an early bet on the REST architecture, it is extremely productive for building applications that mostly communicate over HTTP using JSON payloads. In this talk, Yehuda will talk about what makes Rails so good as the server for rich clients, and how to structure your application to take the most advantage of these properties.
Chad Fowler do |talk|
  talk.title "Service"
  talk.speaker :chad_fowler
  talk.on :combined_track =>
As software developers, testers, and project managers, we all make the same thing: experiences. No matter what your profession, the service you provide to your customers is what they'll remember the most. This presentation will put "service" in perspective and give you techniques to provide remarkable customer service.
Ola Bini do |talk|
  talk.title "The Good, the Bad, and the Ugly"
  talk.speaker :ola_bini
  talk.on :combined_track =>
Ruby turned 18 in 2011. In many countries around the world, that means Ruby is now an adult. During the evolution of the language, there have been many, many improvements. What started out as a small language has grown larger. However, the more code we write in Ruby, the more we realise that there are things that could be better. And we are also realising that there are things that just plainly shouldn't be there.

In this talk, I would like to explore some of these aspects, with an eye towards what Ruby 2.0 will be, and what the language could look like if you started from scratch. The Ruby language and the Ruby ecosystem is a fantastic place to be, but the best feature of it is that we are not afraid of evolution.
Nick Sieger do |talk|
  talk.title "Happiness : Ruby :: Freedom : JRuby"
  talk.speaker :nick_sieger
  talk.on :combined_track =>
Happiness is an infectious feeling. When Matz set out to make himself happy by creating Ruby, did he have any idea what he had set in motion? And yet, here we are, a worldwide community of computer programmers collectively discussing how to improve our own lives and the lives of others. Inspired by Matz, we sense an opportunity to leave the world a better place than the way we found it.

Closely intertwined with happiness, freedom is also infectious. The freedom to use the best tool to solve a problem. The feeling of being liberated from legacy code. The freedom to deploy your code anywhere. Using JRuby enables these situations with an extremely low friction and barrier to entry.

Ruby and JRuby are just programming tools. Can they really engender and promote happiness and freedom? As inanimate bits residing on spinning rust, perhaps not. But as the intellectual property of our community that connects us, empowers us to solve real problems and share our stories, the answer to that question becomes more positive.