Failing With Friends from Crosstrain January 2014

07 Feb 2014

I had the privilege of speaking at the Crosstrain Morning in January. It was excellently organized by Philip Likens and if you have a chance to go to one in the future, you should! It is a great concept: “a diverse gathering of T-shaped people* sharing ideas to drive empathy and knowledge across disciplines”

The topic for the morning was Failure, “because so much learning can come from telling the stories of our collective failures. Whether that failure is product-related, service-related, inter-personal, financial, or otherwise, we can learn from the mistakes of those in our field and outside it.”

Here are my slides from Failing With Friends


2013 Talks

02 Dec 2013

I have been meaning to link to some of the talks I have done over the past year. So here you go:

Scaling With Friends

Big Ruby 2013 - video

What started with two brothers in the McKinney Public Library is now a world wide word phenomenon on multiple mobile platforms. We’ll look at how we have grown, the mistakes we made, and the changes we have made along the way:

  • Serving millions of players a day: Stats, stats, stats!
  • Working with constraints:
    • 1 service, 6 games (and counting)
    • Native clients means backward compatibility, ftw!
  • How do I know what to fix?
  • Instrumenting and reporting on everything Where is the data?
  • Using the database, memcache, Redis to the fullest
  • What we did wrong? What we did right? What would we do differently?

Mobile Omakase

Dallas.rb - slides

Mobile development is complicated. To be a successful soloist, you must start with the simplest possible tools that will allow you to complete the task at hand. Using Grape makes building APIs for web services simple and is tailored for creating web APIs in Ruby. RubyMotion takes the ceremony out of building iOS applications with Obj-C and lets you focus on building out the app in a language you love.

We will take a look at both of these tools, discuss the benefits, challenges, and ways to improve (and shorten) our development lifecyle with things like specs (for client and server), API documentation via fdoc, and incorporating existing Obj-C libraries with Cocoapods.


Building CatechizeMe with Rubymotion: The Gems and Cocoapods

01 Dec 2012

This is a brief write-up on on some of the gems and cocoapods I used to build the catechizeMe iOS app for using Rubymotion.

The Ruby Gems

The Gemfile for the project:

source :rubygems

gem 'bubble-wrap'
gem 'cocoapods'
gem 'motion-cocoapods'
gem 'motion-testflight'
gem 'ib'

There were not a lot of extra Ruby gems needed to put this together. The most useful were bubble-wrap, with its simplification of many things in the iOS Framework, and ib, which allowed me to use Interface Builder to layout the UI.

The other gems are fairly self explanatory. cocoapods and motion-cocoapods allowed me to choose from many existing Obj-C libraries and avoid re-inventing the wheel. motion-testflight made it easy to upload test builds for beta testers to try builds of the app during development. If you haven’t had a chance to try out TestFlight, you should definitely check it out.

Including the Ruby Gems

Using Bundler made it easy to manage the dependencies. After creating the Gemfile and making sure that Bundler was installed, gem install bundler, I just needed to download and install all the Ruby gems with a bundle install. I could also update the gems to the latest version with a bundle update. It should be noted that you can specify versions of gems in the Gemfile and you will probably want to do this to avoid getting updated gems that break something or change things underneath you.

To include the gems in the project, I just had to add a couple of lines to the Rakefile:

require 'motion/project'

require 'bundler'


Not all Rubygems will work for Rubymotion. There is no require functionality in Rubymotion, so you will need to find gems that have been built to work with Rubymotion.

The Cocoapods

There are a lot existing open source Obj-C libraries out there that can be included in iOS projects. Fortunately, we can also leverage many of those via Cocoapods, which aims to be the package manager for Obj-C projects (think Bundler). Normally, you would have a Podfile, but for Rubymotion projects with the motion-cocoapod gem, you add your Pod dependencies to your Rakefile:

app.pods do
  pod 'ViewDeck'
  pod 'QuickDialog'
  pod 'JSONKit'
  pod 'CMPopTipView'
  pod 'ShareKit/Facebook'
  pod 'ShareKit/Twitter'

Much like Bundler, you can specify specific versions to avoid the pods getting updated beneath you. The Pods are installed into your project vendor/Pods directory where you can look through all the source when you need.

Here is how each Pod was used:

  • ViewDeck: slide out a view from the left or right, similar to Facebook or Path apps. Used to make navigating and searching questions easier.
  • QuickDialog: made the settings form slightly easier to build. Documentation is weak and you will need to be comfortable spelunking.
  • JSONKit: even though bubble-wrap has helpers for parsing JSON, it relies on iOS 5 features. If your project needs to support iOS 4.3+, you will need to use something like JSONKit.
  • CMPopTipView: A nice little tooltip library to make the tutorial and show off features when some first installs the app.
  • ShareKit: A swiss army knife of sharing content to a number of sites. I only needed Facebook and Twitter, but there are a bunch more that can be used.


Adding new Pods, it may sometimes appear that the Pod isn’t available or working. I found that because some Pods affect the project .pch file, it is sometimes neccessary to rake clean to get things working again.


It is easy enough to leverage the growing number of Rubymotion gems and Obj-C iOS libraries. The challenge can be finding them so that you don’t re-invent the wheel.


LESS, CSS Frameworks, and Rails

02 Sep 2009
I have been a fan of the CSS frameworks for a while now. I started with YUI and now use Blueprint or on a regular basis. What I never liked about the frameworks was the need to add all of the extra classes to the HTML markup. It seemed messy, wasn't semantic (not that I am a fanatic about that), and made it harder to reuse partials in my Rails projects.

CSS Improved

For a while now there has been SASS, which allows you to write CSS-like files that get translated into CSS. The advantage is that you can now use things like nested rules, variables, mixins, and more. The markup is similar to CSS so the learning curve is minimal. On top of that, there is Compass, which adds some of the popular CSS frameworks as mixins. Now it is easy to mixin the styles of the frameworks to your semantic classes in the CSS without adding all of the extra framework specific classes to your HTML markup. What I did not like about SASS and Compass was the dependency on HAML. I have tried to make the switch form ERB to HAML and I know that you can use SASS and Compass without using HAML in your templates. But it always seemed like an extra unneeded dependency in my apps.

Less CSS

I recently came across LESS, a Ruby gem similar to SASS. The idea is that you can write .less files that are CSS-like and they will be translated into CSS. The advantage, as I see it, is that you can use existing .css files as .less files since the syntax is so similar. In addition to the standard CSS syntax, you also get nested rules, variables, and mixins, just like SASS, but without the extra dependency. You can also import other CSS files as-is, like the CSS frameworks, and mix those styles into your semantic styles. This eliminates the need for Compass to provide the SASS-ified version of the framework. The gem itself is not specific to Rails and can be used on any project. You just need to run the LESS compiler to translate the .less file into a .css file. There is a Rails plugin that make it easy to start using LESS in your Rails projects.

LESS In Action

So what does it all look like? I will leave you with an example of how it all fits together.
@import 'blueprint/screen.css';

#content {
  #main {
  #sidebar {

#footer {
  text-align: center; 
  font-size: .75em; 
  color: #666;
You can see more in my Basejumper, a starter Rails application.


Rails respond_to Made It Too Easy

13 Jul 2009
I recently had a spike in traffic (1-2 visits/day to 30-40 visits/day) over at Someone out on the internet came across it, found it useful, and linked to it. Yay! With this new traffic, came some new requests for features. The first was a request for a Google Gadget. I didn't know much about what I needed to create a Gadget, but after looking it up I realized I could use the CatechizeMe API that came automatically when I built the app. With just a few lines of code, the Daily Question service was created and returning JSON data. You gotta love it when things are this easy. BEFORE:
  def daily_question
    @question = @catechism.daily_question
    render :template => '/questions/show'
  def daily_question
    @question = @catechism.daily_question
    respond_to do |wants|
      wants.html { render :template => '/questions/show' }
      wants.js { render_json @question.to_json }
So now I get a daily catechism question from the CatechizeMe website or via the Google Gadget using JSON:


Older posts