Cascadia Ruby 2011 schedule

Saturday 30th July 2011

"Playfulness at Work"--does that mean "bringing play into the workplace" or "the way playfulness works?" Both, actually. Seven years after _why wrote "Wearing Ruby Slippers to Work," it's time to don the entire Ruby-encrusted tuxedo and storm the workplace. We'll discuss ways to keep work playful (and as a side effect do better work), including:

Dealing with crusty data formats and protocols in a lighthearted way

Scripting other people's software (whether they know it or not)

Sharing your code with co-workers without annoying them

Deploying your programs to honest-to-goodness paying customers

And because no Ruby discussion is complete without a bit of armchair sociology, we'll do some hand-waving about the importance of play to the mind and to the team.

Unscheduled

This talk will be a story of my experience crashing a full size stock car into the blunt end of a concrete wall. This is a true story that happened to me at Columbus 151 Speedway in Columbus, WI. It occurred in a recurring event, which has been featured on Ripley’s Believe It or Not, called the Back-up Race where up to 12 cars race backwards around 1/4 mi. asphalt oval at speeds up to 65 MPH.

How does one start with nothing and make something? When we write computer programs, we start with only our thoughts. One can improve one’s skills and write better programs by using techniques well known to creative artists: scratchpads, prototypes, thought streams, side projects.

Even the cleanest Ruby codebases can become littered over time with nil checks, error handling, and other interruptions which steal attention away from the essential purpose of the code. This talk will discuss strategies for writing your Ruby classes and methods in a confident, straightforward style; without sacrificing functionality or robustness. In the process, we’ll cover concepts and techniques points including:

The narrative style of method construction

The four parts of a method

Three strategies for dealing with uncertain input

Massaging input with coercion and the Decorator pattern

Lightweight preconditions

Exterminating nils from your code

The chaining and iterative styles of method construction

Eliminating conditionals with the Special Case and Null Object patterns

Ruby and Rails has already found itself in the code bases of Fortune 2000 companies, but it can take a lot of time and effort (and convincing), to get there. This talk will provide a lot of examples and stories of some of the battles we’ve fought in the space. My talk will go through:

The current landscape of Ruby and Rails in the Enterprise.

The common roadblocks that one will face when introducing Ruby/Rails into existing large scale systems.

Solutions and approaches to the roadblocks that we’ve found that have worked.

Enterprise Architecture examples, and how we fit Ruby/Rails into the fold.

Attendees of this talk will walk out feeling more comfortable moving Ruby/Rails into the Enterprise space. If we are prepared when approaching these opportunities, we’ll all benefit from a continuing influx of Ruby/Rails job offerings, and, the advancement and investment of both Ruby as a language and Rails as a framework.

Many projects involve large datasets. While humans have evolved to be master pattern matchers, trying to find patterns and potential issues by looking at database rows and xml is hard. Creating diagrams is helpful but manually creating them is time consuming and prone to error.

The graph gem makes it quick and easy to create visualizations. I’ll show how to use Nokogiri and graph to get data out of an XML file and into a format where you can see relationships and patterns. I’ll also demonstrate some of the advanced features of graph including clustering and color coding.

It will cover how we often times have 2-3 different branches running simultaneously in production, how we use continuous integration, and why continuous deployment isn’t ideal for our workflow. I’ll cover the metrics and automation pieces we have written in Ruby that help us make all of these things happen. The talk will hopefully get people to think about whether they’re deploying as efficiently as possible and what changes they can make to help their organization ship better.

Minitest is awesome. It's more powerful than test/unit, faster than cucumber, and able to leap over nothing. I'll go into detail of all the goodies that minitest provides and talk a bit about its design rationale and why it rocks.

We will discuss my personal and humble beginnings in ruby being a young college grad, entering the world of ‘professional’ software development. The Array class in Ruby immediately fascinated me. Soon, the Hash class would join its company. I finally found the granddaddy of them all, the Enumerable module.

We will explore how the Enumerable module empowers some of our favorite Ruby types (Array, Hash). We will then also take a brief look at the Standard Lib Set class (introduced in 1.9) that further shows the beauty of the Enumerable module to create data structures in Ruby. Finally, we'll see a naive implementation of another data structure using the Enumerable module.

The purpose of this talk is to share and encourage others (especially people new to Ruby) to explore core classes and Ruby. Spend time staring at methods in our classes and dare to tinker. I guarantee that doing so will be a start of a fruitful and passionate love affair with Ruby!

Unix blurs the lines between your file system, network, version control, editor, tests, and programming language. This gives it power to answer important questions: Did my rebase break any specs in the rewritten commits? Which of my classes are referenced the most, making them risky when the system changes? Do my spec files run correctly in isolation?

This talk will cover intermediate-to-advanced use of Unix to answer questions like these. The end goal is to start thinking of the entire operating system-not just the editor-as a development environment.

Once people achieve some level of Git enlightenment, they tend to make statements of the form 'Git gets a lot easier once you realize X' -- but that doesn't do much to help people staring up that steep slope.

When you're just getting started, something as straightforward as a merge can be terrifying. It can take a long time for people to really become comfortable branching and merging and stashing, let alone rebasing or cherry-picking.

This talk aims to provide two things:

a very gentle introduction to graph theory, and

a simple strategy for safely experimenting with Git operations,

so that people can build comfort and confidence with this incredibly useful tool.