Session Schedule

By Matthew Bass

Many years ago a community would come together to help a neighbor get started. They'd all pitch in, knowing that when they needed help, those same friends would come to their aid as well. This model of community self-sufficiency has been recycled in the software world.

In this talk you'll learn how Matt is still using the homesteading model to build his consultancy, and how others are doing the same. You'll get enough of a grounding to move forward on your own, or help someone else while you learn more.

By David Bock

Capistrano is the de-facto tool used to deploy Rails applications, but it is useful for so much more. In this talk we will publish a real website from scratch, with consideration for real world stuff like safeguarding passwords, turning on and off application monitoring, multiple machine deployments, and general system administration tasks.

In addition to a real deploy in-session, we will look at the real deploy scripts for several real-world, large websites involving multiple machine architectures, minimal (sub second) downtimes, and different server configurations.

By David Bock

Rails may be the framework that turned many of us on to Ruby, but if you are using it for all of your server-related Ruby projects, you probably have a hammer and are seeing every problem as a nail. There are a number of smaller, tighter solutions to problem in this space, including GServer (built into the Ruby libraries), StaticMatic and Webby (tools for generating a static site, but with all the templating goodness), Sinatra, a small server with an awesome DSL for restful web services, and Rack, an easy way to get content published as a web service.

We will spend a little bit of time of each of these, seeing how you can use each for a project where you might have previously considered Rails.

By David Bock

Most developers who adopt Rails deploy their first application and see it get rushed under heavy load... thus the rumor that 'Rails doesn't scale'. Well, Rails does, you just have to know a few things

We will touch on a lot of things in this talk - measuring performance tuning your browser experience query tuning caching - built-in and plugins architectural modifications and more

By Rick DeNatale

A war is being waged between the Empire and the Rebel Alliance. The imperial forces are laboring tirelessly to stamp out such dangerous ideas as late-binding, and automatic memory management.

Based on long experience, such ideas are known to cause severe performance problems at best, and to bring down the Empire with errors at worst.

The year, 2008 Ruby vs. Java*, or ca 1990 Smalltalk vs. C++, or ...

The languages change, but the arguments remain. After a period in the shadows, dynamic languages have been on the rise again. Ruby has been at the forefront of this resurgence, with older dynamic languages tagging along. At the same time, hard-learned lessons from the implementation of these earlier languages are starting to have an influence on implementation of the newer ones. Witness the buzz in the Ruby community about "repurposeing" projects such as MagLev.

This talk will explore the history of the dynamic vs. static debate, and attempt to bring to light the reasons why many of the arguments against dynamic languages are based on things which just don't matter if the language isn't static. I'll also have a few things to say about why things like MagLev make sense.

By Neal Ford

The Gang of Four book was actually 2 books: a nomenclature describing common software problems and a recipe book for solutions. The vocabulary they defined is still useful. The recipes are a disaster! Ruby has powerful meta-programming facilities far beyond the languages encompassed by the GoF. It turns out that many of the structural design patterns in the Gang of Four book and beyond are much easier to solve with meta-programming.

This session compares and contrasts the "traditional" approach of design patterns with a more nuanced meta-programming approach. Using language features creates cleaner abstractions with fewer lines of code and little or no additional structure.

By Neal Ford

Building Domain Specific Languages in Ruby shows the power and flexibility of the language.

This talk covers some advanced DSL techniques in Ruby, including building really fluent interfaces, building natural language-styel DSLs, using sticky attributes, factories via const_missing, bubling methods, and other techniques. This session goes beyond the general syntactic tricks used to create DSLs; it shows how to make internal DSLs in Ruby a compelling abstraction mechanism for building frameworks and other tools.

By Neal Ford

Ruby is the revenge of the Smalltalkers. Not since Smalltalk has a language had such powerful meta-programming facilities. While this may seem like a minor feature, it turns out that surgical meta-programming allows solutions to problems that are clearer, more concise, more maintainable, and take orders of magnitudes fewer lines of code.

This session shows one of the reasons that JRuby is the most powerful mainstream language today: meta-programming. It shows tons of meta-programming techniques in Ruby, including open classes, the shadow meta-class, defining methods, method_ & const_missing, dynamically adding and removing mixins, and more. And each of these comes with an example that actually makes sense! Session TopicsModulesStructsFreezingMessages and Dynamic InvocationThe Shadow Meta-classCode as ObjectsDelegationOpen ClassesAspectsMissing! Const Method ReflectionMixology

By Chad Fowler

Ruby 1.9 the first major upgrade to the Ruby language in many years. On top of a slew of new language features, it offers an exponentially faster, byte-code compiled runtime environment.

This session will walk through many of the new features and changes in Ruby 1.9 with a focus on helping attendees both upgrade existing code to work with 1.9 as well as take advantage of new features producing cleaner, more elegant code.

By Chad Fowler

ActiveRecord is one of the leakiest abstractions you'll ever use as a software developer. Becoming a true master of ActiveRecord requires you to embrace that fact and dig into its guts. Knowing how ActiveRecord really works makes you a much better ActiveRecord programmer.

This talk will take a close look at associations, named scopes, caching, query generation, migrations and more. You'll leave with a new level of understanding of ActiveRecord and the confidence to quickly find answers in the ActiveRecord source.

By Stuart Halloway

In recent years, the Java community has embraced a variety of new languages that target the JVM, but also offer productivity advantages over traditional Java coding.

One of the most interesting of these languages is Clojure, a "Lisp unconstrained by backward compatibility." In this talk, you will see why Clojure deserves serious consideration as the next big JVM language: * Clojure provides all the low-ceremony goodness you know and love from dynamic languages such as Ruby and Python. * Clojure includes Lisp's signature feature: Treating code as data through macros. * Clojure's emphasis on immutability and support for software transactional memory make it a viable option for taking advantage of massively parallel hardware.

By Stuart Halloway

Clojure is dynamic language for the Java Virtual Machine with several powerful features for building concurrent applications.

In this talk you will learn about: * Functional programming. Clojure's immutable data structures encourage side-effect free programming that can easily be shared across multiple processor cores. * Software Transactional Memory (STM). STM provides a mechanism for managing references and updates across threads that is easier to use and less error-prone than lock-based concurrency. * Direct access to Java. Clojure calls Java directly, and can emit the same byte code that a handcrafted Java program would. So, you can easily access the java.util.concurrent library.

By Yehuda Katz

With the announcement that Merb will be merging into Rails3, you might have some questions about what that means for the future of Rails. Yehuda, the lead developer of the Merb project (now a Rails core team member), will talk about the work he's doing to bring modularity, performance, and a public API to Rails. The first Rails3 beta is scheduled for May of this year, so you can be one of the first to get a peek into the work the new Rails team is doing.

He will cover the key elements that differentiated Merb from Rails, and talk about how, specifically, the integration will occur. This will include: -how some new Merb features have gotten an overhaul to fit in more cleanly with the Rails ecosystem -what internal changes needed to be made in order to support a more stable plugin API -how you will be able to leverage the new focus on modularity in your applications -what does "performance" mean and the plans for optimizing Rails Yehuda will also provide insight into the rationale behind some of the most contentious decisions that had to be made during the merge planning.

By 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 available, 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 sh

By Kevin Smith

Spend an hour learn about Erlang -- a functional programming language designed for demanding multi-threaded environments. You'll get an introduction to the language including syntax and major concepts. You'll also learn which companies and projects are using Erlang today and the kinds of problems they're solving with Erlang.

tbd

By Kevin Smith

Learn how to use Erlang in a practical setting. This talk will cover building and deploying a simple, but complete, web application using Erlang. The talk will illustrate how to use the OTP framework to write robust servers and how to leverage third party libraries, like Mochiweb, to make developing for the web easier.

tbd

By Nathaniel Talbott

We developers spend a lot of time talking about how to improve technically at our craft, how to write better code, how to be more productive when we're writing code. But what about when we don't feel like coding? What about the emotions that often keep us from putting our fingers on the keyboard and working on that cool library we want to write or finishing up that cool side project we were so fired up about a few weeks ago?

Or to put it another way, why is it that some developers turn out so much more code than the rest of us? How do they maintain five open source projects (or more!) while we might be doing good to make progress on one? It certainly might be that they're smarter, or that they spend more time at it. But maybe not...

Maybe the reason we don't create more is that we're afraid. Afraid of not finishing, afraid of what others will say, afraid we won't know how to solve a problem, afraid that we're not working on the right thing. If creating code is even partly an act of artistry, then it's worth examining our emotional connection with what we're making. It might be time to start realizing that coding productivity is affected as much by our emotional outlook as it is by our technique.

If "fear is the mind-killer", how do we overcome it? How do we get past our fear so we can create something amazing and have a blast doing it? Those are the questions that this talk aims to at least begin answering. Finally, why is it so important we conquer our fear and go on to create? _why puts it eloquently: "when you don't create things, you become defined by your tastes rather than ability. your tastes only narrow & exclude people. so create."

By Nathaniel Talbott

Lots of developers decide to try going it on their own - perhaps they're tired of being a cube rat, having technical decisions made by uninformed management, or having to service the bureaucracy before the client. Rubyists seem to have an especially high likelihood of going independent, since it gives them much more flexibility to use the language that makes them happy.

But as alluring as it might be to "be your own boss", everyone who makes the jump from the cube to the room over the garage finds out real quick that there's a whole new set of skills necessary to be successful. Even worse, freelancing doesn't come with a training manual that outlines all these important skills, and most folks just have to learn them the hard way: by trial and error.

But what if you could get a head start on these important skills without having to fail at them first? Or at least the top five skills, the ones that are often the cause of failed projects, unpaid work, and washed out freelancers? That's what you'll get in this session. Nathaniel has freelanced for long periods of time himself, and now manages (in a cat-herding sort of way) a whole crew of freelancers at Terralien. He's worked with both experienced freelancers and folks who've just escaped the corporate maze, and has something to offer both. Whether you've been freelancing for years, have just made the jump, or are standing on the edge contemplating the rocks below, you'll want to come fin

By Glenn Vanderburg

Tarantula is a Rails plugin for doing easy, repeatable fuzz testing of Rails applications. Tarantula crawls your application, supplying random inputs at every turn and looking for signs of trouble. It can be used to regularly check for many kinds of error handling issues, cross-site scripting and SQL injection vulnerabilities, and more mundane things like invalid HTML. This talk will discuss how Tarantula works, how to use it, and how to make it a regular part of your testing strategy.

I'll discuss the various kinds of problems that Tarantula can help you detect. I'll explain how to install Tarantula, configure it for various kinds of testing, and how to interpret (and react to) its output. Finally, I'll discuss how to make it a regular part of your automated testing regimen.

By Glenn Vanderburg

Sinatra is a Ruby-based framework that makes it trivial to write simple web apps very quickly. It's much lighter weight than Rails and fills a different need, but a lot of very smart people are using this exciting new tool.

In this talk you'll learn how to use Sinatra yourself, the pros and cons of the tool, and how Relevance is already using it today.