Schedule Grid







Welcome and Introduction



MacRuby and HotCocoa - Rich Kilmer

Hypertable and Rails: DB Scaling Solutions with HyperRecord - Josh Tyler & Rusty Burchfield





Sinatra: The Framework Within - Aaron Quint

CloudKit: Hacking the Open Stack with Ruby and Rack - Jon Crosby





Playing With Fire: Running Uploaded Ruby Code in a Sandbox - David Stevenson

Using Shoes to create better iPhone apps - Tim Elliott





TrustTheVote: Open Source Digital Voting - Gregory Miller

Using Ruby to Fight AIDS - Jacqui Maher





There Will Be Ruby! - Hampton Catlin

CouchDB + Ruby: Perform Like a Pr0n Star - Matt Aimonetti





Building Custom Web Proxies in Ruby - Ilya Grigorik

Webrat: Rails Acceptance Testing Evolved - Bryan Helmkamp





Discussion Panel: Ruby Application Frameworks

Lightning Talks





Writing Fast Ruby: Learning from Merb & Rails 3 - Carl Lerche

Arduino is Rails for hardware hacking - Greg Borenstein





Magic Scaling Sprinkles - Nick Kallen

Unison: A Relational Modeling Framework - Nathan Sobo


  • MacRuby and HotCocoa

    Rich Kilmer

    MacRuby is an implementation of the Ruby language that runs on the Objective-C runtime under OS X. MacRuby is based on Ruby 1.9 but contains substantial modifications including the merging of object models (every Object is an NSObject), using the Objective-C 2.0 generational garbage collector, moving core types (String, Fixnum, Array, Hash) atop their Objective-C counterparts and replacement of standard libraries to more optimally integrate with OS X. MacRuby also includes a new library, HotCocoa. HotCocoa is a thin, idiomatic Ruby layer that sits above Cocoa and other frameworks.

    Cocoa classes have extremely verbose method and constant names. A substantial amount of code is written to just instantiate and configure instances of these classes. Interface Builder is used by most developers because it hides the complexity of manually configuring controls, but at the expense have having to use a GUI builder and the obscuring those configuration options inside the IB user interface. One of HotCocoa's chief goals is to allow Interface Builder simplicity, but in Ruby code. Buttons, Sliders, Windows, WebViews—the whole works—HotCocoa simplifies this process by creating a mapping layer over the top of Objective-C classes. HotCocoa adds Ruby-friendly methods, constants and delegation techniques that look refreshingly simple, but do not prevent full use of the Cocoa APIs.

    This talk with introduce MacRuby and HotCocoa and show demonstrations on how to use them to quickly build OS X desktop applications with Ruby.

  • Sinatra: The Framework Within

    Aaron Quint

    Sinatra has been getting a lot of attention lately as the next great (micro-)framework. In writing apps, diving in, and contributing the reasons for its existence have become more clear. Sinatra is not just a toy or a neat trick, its the best way to create simple and non-obtrusive web interfaces to sit on top of a new or existing Ruby codebase. I'll walk through the whats, whys, and tools for getting started with Sinatra.

  • Playing With Fire: Running Uploaded Ruby Code in a Sandbox

    David Stevenson

    In this session, David Stevenson explores how to run untrusted code inside a ruby application using a sandbox. With this powerful technique, users can upload code that integrates as part of a larger application, making it ideal for custom business rules, dynamic games (think SecondLife), and science/math applications. Ruby's english-like syntax and ease of creating DSLs makes it a good scripting candidate for non-technical people.

    The sandbox isn't perfect, however, and we'll also explore where it can get into trouble. By diving into how it works, we can understand its limitations and not create security holes when using it. We'll also look at how to make it easier to use, by adding on some helper gems to the original sandbox gem (developed by Why-the-lucky-stiff, with small improvements by David Stevenson). Finally, we'll actually write a tiny game during the sessions where the audience can upload components.

  • Trust the Vote: An Open Source Digital Public Works Project

    Gregory Miller

    The cornerstone of our democracy is the vote. In a digital democracy the substance of that cornerstone is technology. The free market enterprise experiment brought about by the Help America Vote Act of 2002 has essentially failed. No longer can the most vital process of our democracy be delivered by proprietary technology. The very thing supposed to deliver us from the hanging chad has all but dissolved trust in how our votes are cast and counted. It's time to shift away from black box voting, and move toward glass box voting.

    To restore trust in how America votes, the underlying technology of elections must be put into a public technology trust, because voting technology itself is becoming critical democracy infrastructure. For over two years an under-the-radar Silicon Valley project has been working on precisely that. Starting with a clean slate, the Open Source Digital Voting Foundation has been re-thinking the entire ballot ecosystem. That project, called TrustTheVote, is making steady progress and is now expanding, thanks to substantial financial backing and support from well-known tech sector philanthropists.

    This talk will present the TrustTheVote project and the "I count!" movement. It will cover the technology roadmap, progress so far, and next steps, including expansion of development efforts and opportunities for involvement in design and construction of trustworthy voting technology that everyone will be able to see, touch, and try—technology that will be fully federally certified and have the endorsement of the States' elections directors through a unique approach that can ensure widespread adoption. If you have ever wanted to know what you can do to make a difference in our electoral process, then this talk is for you.

  • There Will Be Ruby!

    Hampton Catlin

    Have you ever tried to catch a train running at a million miles an hour? Jumping into the traffic stream at Wikipedia is an insane adventure I've been going through. Exactly how do you launch a new platform that could instantly have millions of hits in a few hours? How do you do that and not spend 3 years researching? A fun tour of how I got Ruby at Wikipedia and did it with confidence, bravado, and alcohol. There will be cussing and lots of funny stories that should be highly educating and an insight into my technical philosophies.

  • Ruby Proxies for Scale, Performance, and Monitoring

    Ilya Grigorik

    A high-performance proxy server is less than a hundred lines of Ruby code and it is an indispensable tool for anyone who knows how to use it. In this session we will first walk through the basics of event-driven architectures and high-performance network programming in Ruby using the EventMachine framework. Then we will dissect two real-world examples of Ruby proxies and their applications:

    • Performance A/B Testing: duplicating live traffic against multiple servers to compare speed, reliability and format of the response.
    • Extending protocols: intercept packets and inject your own functionality into applications such as Memcache, Beanstalkd, and others.

    No prior knowledge of EventMachine will be assumed. Rudimentary knowledge of network programming will be helpful.

  • Writing Fast Ruby: Learning from Merb and Rails 3

    Carl Lerche

    It has been said that Ruby is a slow language, but that is not true. Numerous Ruby projects have shown that it is possible to write fast, scalable software using Ruby. Merb, for instance, is faster than any major PHP web framework.

    In this talk, Carl will show how to take the many available tools, such as ruby-prof, RBench, and kcachegrind, and turn any old Ruby into a speed machine. The tips and processes will be demonstrated with real world examples of optimizations that have been done to the Merb and Rails 3 projects.

    Topics that will be covered include:

    • Finding performance drains in existing Ruby code
    • Popular Ruby idioms that are actually quite slow
    • Using benchmarks to help determine the fastest approach to a problem
    • Understand the MRI garbage collector and how it applies to Ruby speed
    • Leveraging the power of the JVM through JRuby

    This talk is geared towards the intermediate developer and you should have a good grasp of the Ruby programming language.

  • Magic Scaling Sprinkles

    Nick Kallen

    Building a massively scaled, fault tolerant web service isn't easy, but it's definitely easier if you know which architectures work and which don't. In this talk we'll survey the architecture and complexities of a scalable web service including edgeware, middleware, message systems, load balancing, cache hierarchies, queueing theory, coordination primitives for distributed computation, designing for latency, inter-process communication, load balancing versus locality, write versus read throughput, non-relational datastores, database replication topologies, logging distributed computations, fault tolerance, deployment at scale, forensics, and the merits of suicide.

  • Hypertable and Rails: DB Scaling Solutions with HyperRecord

    Rusty Burchfield and Josh Tyler

    Every site based on a RDBMS will eventually hit a database scalability bottleneck. In this session we will introduce Hypertable, an open-source implementation of BigTable, and HyperRecord, an extension of ActiveRecord using Hypertable for storage. We will demonstrate Zvents' use of these technologies to scale a high-traffic, data-intensive consumer web application, writing billions of cells daily.

  • CloudKit: Hacking the Open Stack with Ruby and Rack

    Jon Crosby

    Learn about the architecture and construction of CloudKit, an Open Web JSON Appliance. Along the way, see how the emerging Open Stack — including OpenID and OAuth+Discovery — can be used to build open and discoverable web services in Ruby. Other topics of exploration will include cooperative Rack middleware stacks, non-relational storage with Tokyo Cabinet, new IETF drafts covering HTTP Discovery, online/offline synchronization with plain old HTTP, and more.

  • Using Shoes to create better iPhone apps

    Tim Elliott

    Shoes is a tiny graphics toolkit that embeds ruby. It allows you to do anything. You can draw squares and circles and they can move about and say "Good Morning" when they chance upon each other. Shoes lets you add layouts to your applications with ease. It borrows ideas from Processing, Lua, and HTML to make an intuitive language to convert your ideas into programs that you can share with your friends.

    This talk begins with a Shoes introduction for Ruby programmers. It won't take much to get up and running and we can move straight into a practical application of Shoes: prototyping iPhone apps. It turns out Shoes is excellent for quickly implementing ideas, testing workflow, and fleshing out the code structure. It's nice to do this stuff in Ruby first before porting it to Objective-C.

    We will also cover how to debug shoes applications and a look into the Shoes source code.

  • Using Ruby to Fight AIDS

    Jacqui Maher

    In August of 2008, Jacqui Maher visited Baobab Health in Lilongwe, Malawi. Baobab is a dedicated group of programmers, clinicians and administrators developing public health and patient data administration systems. They use a variety of hardware and software technologies, but their main applications are written in Ruby on Rails.

    This talk will discuss:

    • OpenMRS, a framework for open medical record management, currently undergoing international standardization
    • Extracting a complex data model into an easy to use RubyGem
    • Using Ruby in the third world: why it makes sense to start with the new
    • Building an infrastructure and software from the ground up
    • Collaboration with a global network of developers using GitHub
    • Development and deployment challenges in the third world
    • How technology can create a common ground between disparate cultures and groups
  • CouchDB + Ruby: Perform Like a Pr0n Star

    Matt Aimonetti

    Do you secretly dream to have a scalability like Google, easily distribute and replicate your data multiple times a day, use a fault-tolerant and schema-free solution, let your data be safely consumed by multiple partners using different interfaces? RESTful API, cloud computing and query caching sound dirty to you? This talk is for you! Come and learn about how you can use Ruby + Apache's latest document-oriented database to finally say good-bye to your old RDBMS.

    In his talk Matt will:

    • explain the difference between RDBMS, document-oriented DBMS, key-value storage systems and column-oriented DBMS
    • show how to rethink your data storage
    • demonstrate the advantages of CouchDB over RDBMS (flexibility, performance, design, reliabilty, replication)
    • show in details how to integrate CouchDB with Ruby using CouchRest
    • show how to optimize your perf by using a HTTP accelerator/load balancer
    • warn you about the cons of the CouchDB + Ruby combo
  • Webrat: Rails Acceptance Testing Evolved

    Bryan Helmkamp

    A robust suite of acceptance tests ensures your Rails app stays working giving you extreme freedom to refactor. Unfortunately, traditional full-stack acceptance testing of web-based applications has centered on in-browser solutions like Selenium and Watir that immediately present challenges like speed, timing/waiting and sharing data across processes, all through a relatively clunky API designed without Ruby in mind. Getting started was troublesome, and keeping things running smoothly was a constant concern.

    Webrat, a Ruby DSL for interaction with web applications, changes the acceptance testing ROI equation. By implementing an invisible, fast browser simulator you can use from within your test framework of choice (Test::Unit, RSpec, Shoulda or Cucumber), it sidesteps most of Selenium's drawbacks while retaining the coverage value.

    Recently, seamless Webrat integration featured prominently in the Merb 1.0 release as the recommended approach for high level testing, a theme that will be a part of the Rails 3 push. Webrat is fast becoming the ubiquitous API for driving web applications from Ruby with it's support for different adapters like Selenium, Mechanize and Celerity.

    This talk, delivered by the maintainer of Webrat, will describe the value of acceptance testing for Rails apps, common pitfalls, and Webrat's solutions. We'll look at techniques for writing maintainable acceptance tests, and maximizing their value over the lifespan of an application. Finally, we'll explore advanced techniques like applying Webrat to ease some of the pain of in-browser testing when it can't be avoided (JavaScript/AJAX, primarily).

  • Arduino is Rails for hardware hacking

    Greg Borenstein

    Just as Rails did for web development, the Arduino project combines powerful layers of abstraction with sensible defaults, making it easy to build hardware devices that sense and manipulate the physical world. So easy that artists, social workers, scientists, and even simple web programmers who lack electrical engineering degrees can do it.

    The Ruby Arduino Development project attempts to extend these virtues by bringing the beauty and power of Ruby to the Arduino platform. RAD compiles Ruby scripts for execution on the Arduino microcontroller development board. In addition to the syntactic elegance and simplicity gained by getting to program in Ruby instead of C++, RAD provides a set of declarative Rails-like conventions and helpers that reduce boilerplate and simplify often-byzantine hardware APIs.

    In this talk, I'll provide a whirlwind introduction to the world of hardware hacking and demonstrate a number of projects that use RAD to integrate hardware with other well-known Ruby projects including Sinatra, Shoes, and Archaeopteryx. Ever wanted a bell to ring when you push code to GitHub? Ever wanted your artificially intelligent DJ to be able to play real drums? If so, this is the talk for you.

  • Unison: A Relational Modeling Framework

    Nathan Sobo

    The relational model has long been the domain of databases, but hidden beneath the awkward, non-compositional syntax of SQL lies the relational algebra, an elegant and compact formalism with powerful implications for distributed application design. Because relational models don't rely on pointers and complex object graphs, it's easy to work with them across network boundaries. All data can be represented as sets of scalar-valued tuples, which are easy to encode in JSON, and all model operations can be expressed in terms of create, update, and destroy, which are compatible with REST.

    In this talk, I'll introduce two symbiotic libraries that leverage these properties to enable elegant client/server web applications. On the server, there's Unison, with an API similar to ActiveRecord's, but more general. In addition to has_many and friends, Unison adds relates_to_many and relates_to_one, allowing custom associations to be constructed through the composition of relational operators. For the browser, I'll introduce June, which offers a JavaScript version of the same API, along with a relational object-store, and I'll demonstrate how June clients can securely pull arbitrary datasets from a Unison-based server, treating it like a relational database. We'll also explore the nexus of the relational model with event-driven programming and the actor model of concurrent computation.