Cascadia Ruby 2011 schedule

Saturday 30th July 2011

  • Playfulness at Work: a Real Serious Message(tm) with Ruby as the Medium

    by Ian Dees

    "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.

    At 11:15am to 11:45am, Saturday 30th July


  • 60 to 0 MPH in 2.5 Seconds: A Retrospective

    by Jim Remsik

    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.

    Coverage video

  • Code and Creativity

    by Geoffrey Grosenbach

    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.

    Coverage video

  • Confident Code

    by Avdi Grimm

    Are your methods timid? Do they constantly second-guess themselves, checking for nil values, errors, and unexpected input?

    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
    • Isolating errors with the Bouncer and Checked Method patterns

    Coverage video

  • David and Goliath, Ruby and the Enterprise

    by Dylan Stamat

    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.

    Coverage video

  • How Community Saved My Life

    by Mando Escamilla

    We all know what to do when our software isn’t working: but what do we do when our life isn’t working? This is the quick story of how my own life almost killed me and the people that saved me.

    Coverage video

  • Keynote: Chad Fowler

    by Chad Fowler

    Coverage video

  • Keynote: John Barnette

    by John Barnette

    Coverage video

  • Powerful (but Easy) Data Visualization with the Graph Gem

    by Aja Hammerly

    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.

    Coverage video

  • Shipping at the Speed of Life

    by Corey Donohoe

    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.

    Coverage video

  • Size Doesn't Matter, or: The ins and outs of Minitest

    by Ryan Davis

    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.

    Coverage video

  • The Enumerable Module or How I fell in Love with Ruby

    by Haris Amin

    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!

  • The Unix Chainsaw

    by Gary Bernhardt

    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.

    Coverage video

  • Think like (a) Git

    by Sam Livingston-Gray

    Git has a famously steep learning curve.

    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.

    Coverage video

  • To Be Announced

    by Rich Kilmer

    Coverage video