Collective Idea Blog

CoffeeScript Routing, part deux

2012-02-07T10:36:46-05:00

I wrote a post not to long ago on how to roll your own JavaScript router. Our first version had named parameters, but we didn’t use them at all when calling the callbacks. Remembering the index of each parameter is a pain, so we’re going to fix that.

First things first, lets take a look at what we want to happen. Given the following route:

Route.add "/blog/:year/:month/:day", callbackMethod

We want the url http://www.example.com/blog/2012/02/07 to pass the following object to the callback:

{
  year: 2012,
  month: 02,
  day:07
}

Make it happen!

The first thing we need is a list of the named parameters in the route. We can get these by a using a simple regular expression before we process the route into a regular expression.

parameterNames = path.match(/:(\w*)/g)

Since this can, and should, differ wildly from route to route, we store those names on the same object that the route is on.

{
  params: path.match(/:(\w*)/g),
}

Now that we have the names of the parameters, we build a new params object to pass back to the callback

index = 1
params = {}
for name in route.params
  params[name.slice(1)] = matches[index++]

The resulting class now looks like this:

class Router
  clearRoutes: ->
    @routes = []
  @process: ->
    for route in @routes
      matches = window.location.pathname.match(route.path)
      if matches?
        index = 1
        params = {}
        for name in route.params
          params[name.slice(1)] = matches[index++]
        route.callback(params)
        return
  @add: (path, callback) ->
    @routes ||= []
    @routes.push { 
      params: path.match(/:(\w*)/g),
      path: new RegExp(path.replace(/\//g, "\\/").replace(/:(\w*)(?!(\w))/g, "(\\w*)")), 
      callback: callback 
    }

There you have it. A CoffeeScript stand alone router with named parameters. I’ve uploaded the resulting class along with its Jasmine tests to http://github.com/tbugai/coffeescript-router. For those of you in the ruby world, its also available as the coffeescript-router gem.

Testing File Downloads with Capybara and ChromeDriver

2012-01-30T12:25:55-05:00

At Collective Idea, we ♥ Cucumber, Capybara and ChromeDriver… and alliteration. But we recently encountered an issue with a very Ajaxy Rails app where we need to test a file download and assert its content.

Our scenario looks like:

Scenario: Exporting the fruits list
  Given the following fruits exist:
    | Name   | Color  |
    | Apple  | Red    |
    | Orange | Orange |
    | Lemon  | Yellow |
  And I am on the fruits page
  When I follow "Export"
  Then the downloaded file content should be:
    """
    Name,Color
    Apple,Red
    Orange,Orange
    Lemon,Yellow
    """

Easy enough! Early in the app’s life, we wrote this Cucumber step:

Then "the downloaded file content should be:" do |content|
  page.response_headers["Content-Disposition"].should == "attachment"
  page.source.should == content
end

This worked like gangbusters. But with such an Ajaxy app, we soon moved to ChromeDriver as our default Capybara driver and our nice green scenario turned an annoying shade of red.

When the scenario ran, Chrome triggered the download as expected but threw the file into my “Downloads” directory. Capybara had no reference to its content and to make matters worse, Cucumber didn’t wait for the download to finish before moving on.

After much frustration…

We discovered that it’s possible to provide a Chrome profile (just a collection of settings) when registering the :chrome Capybara driver. We’re registering the driver in features/support/chromedriver.rb so we added the profile there:

require "selenium/webdriver"

Capybara.register_driver :chrome do |app|
  profile = Selenium::WebDriver::Chrome::Profile.new
  profile["download.default_directory"] = DownloadHelpers::PATH.to_s
  Capybara::Selenium::Driver.new(app, :browser => :chrome, :profile => profile)
end

Capybara.default_driver = Capybara.javascript_driver = :chrome

We added a download.default_directory setting to the profile. This tells the browser where to send downloaded files. Eureka!

That answers the question of downloading the file to the proper place, but we still need to make sure we wait for the download to finish. We take care of that in features/support/downloads.rb:

module DownloadHelpers
  TIMEOUT = 10
  PATH    = Rails.root.join("tmp/downloads")

  extend self

  def downloads
    Dir[PATH.join("*")]
  end

  def download
    downloads.first
  end

  def download_content
    wait_for_download
    File.read(download)
  end

  def wait_for_download
    Timeout.timeout(TIMEOUT) do
      sleep 0.1 until downloaded?
    end
  end

  def downloaded?
    !downloading? && downloads.any?
  end

  def downloading?
    downloads.grep(/\.crdownload$/).any?
  end

  def clear_downloads
    FileUtils.rm_f(downloads)
  end
end

World(DownloadsHelpers)

Before do
  clear_downloads
end

After do
  clear_downloads
end

Now we’re equipped with everything we need to effectively manage and inspect file downloads. Our Cucumber step simply changes to:

Then "the downloaded file content should be:" do |content|
  download_content.should == content
end

And there you have it. It’s a little bit of added support code but if you’re dealing with downloads, it’s well worth your while.

Standalone Javascript Routing

2012-01-25T14:34:19-05:00

A recent project has us using spine.js as well as a few other JavaScript libraries. Though spine.js comes with its own routing, it conflicts with pjax. The solution was to roll our own.

The requirements are simple, we should be able to give it a set of routes and their corresponding callbacks and we should be able to process the browsers url upon request. The CoffeeScript for that looks like this:

class Router
  @add: (path, callback) ->
    @routes ||= []
    @routes.push { 
      path: path, 
      callback: callback 
    }
  @process: ->
    for route in @routes
      params = window.location.pathname.match(route.path)
      if params?
        route.callback(params)
        return

This code works exactly as we want it too, but there are a few things I’d like to make better. The first of which is that we have to provide a regex as the path so our routes would look something like this:

Route.add /\/blog\/(\w*)/, blogCallback

It would be much easier to read and maintain if it followed more of a rails-routing-style semantic like this:

Route.add “/blog/:id”, blogCallback

We can make this possible by processing the path string into its regex counterpart inside Route.add()

The first thing we need to do is escape the forward slashes ( / )

path.replace(/\//g, “\\/”)

Then we need to change everything starting with a colon into a capture field

path.replace(/:(\w*)(?!(\w))/g,“(\\w*)”)

And then we convert the fancied up string into a RegExp and save it as the path for our route. I’ve chained all of the replaces() together for simplicity.

path = new RegExp(path.replace(/\//g, “\\/”).replace(/:(\w*)/g,“(\\w*)”))

(thanks to Jonathan Castello for pointing out we were being too cautious with the last regex)

The updated class looks like this:

class Router
  @add: (path, callback) ->
    @routes ||= []
    @routes.push { 
      path: new RegExp(path.replace(/\//g, "\\/").replace(/:(\w*)/g,"(\\w*)")), 
      callback: callback 
    }  
  @process: ->
    for route in @routes
      params = window.location.pathname.match(route.path)
      if params?
        route.callback(params)
        return

Then in our project, we have the following setup code.

$ ->
  Route.add "/blog/:id", blogCallback
  $(document).on "ready end.pjax", ->
    Route.process()

Whenever our document is ready or a pjax link has completed, our routes get matched against the url and the appropriate callback gets fired.

Slow it Down

2012-01-18T11:13:56-05:00

Most of the time, you test your apps on a fast connection, especially when working on a local machine. Most of your clients/visitors/customers aren’t so lucky, but how do you simulate their connection speed?

If you have installed Xcode on Lion, you have access to a very cool tool called Network Link Conditioner¹.

It is a preference pane, but not installed by default. You’ll find it in /Developer/Applications/Utilities/Network Link Conditioner/ Simply double-click the prefPane and it will install itself.

Once enabled, you can set your network to simulate everything from 3G or Edge to typical DSL. You can even set your own profile to tweak the settings. It works at the network level, so it affects your entire system. No proxies or any other setup needed!

As an example, we have an app in development where we know the users will have high latency. Instead of just hoping they get better connections, we can simulate their situation and test it out, even when we’re using Rails on our laptops. We’re then using it to optimize to their situation, not just blindly².

Give it a shot and see how your sites fare.

¹ This may win the award for ugliest Apple icon. Please prove me wrong!

² Don’t prematurely optimize. That’s still bad.

Refactored for Efficiency

2012-01-17T10:15:02-05:00

Refactoring your code is for more then keeping it DRY. It also gives you a chance to make it more efficient.

Take a look at the following Objective-C. Its goal is to return the full path to a sessions folder which is a subdirectory in the users documents directory.


-(NSString *)filePath {
    NSString *baseDirectory = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
    NSString *sessionPath = [baseDirectory stringByAppendingPathComponent:self.sessionName];
    return [sessionPath stringByAppendingPathComponent:self.fileName];   
}

It accomplishes its task but is relatively expensive. There are two string concatenations, each of which involve another allocation of memory.

We can speed this up a bit by rewritting it like this:


-(NSString *)filePath {
    return [NSString stringWithFormat:@"%@/%@/%@",
         [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0], 
         self.sessionName, 
         self.fileName
    ]; 
}

The new method causes only one memory allocation and one string concatenation. Thats half of what our first attempt required.

We can also cache the result as it doesn’t change during its session. We simply add a NSString *_filePath to the containing class and refactor further.


-(NSString *)filePath {
    if(_filePath == null) {   
        _filePath = [NSString stringWithFormat:@"%@/%@/%@",
             [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0], 
             self.sessionName, 
             self.fileName
        ]; 
    }
    return _filePath;
}

The end result is a method that is twice is fast the first time it is called and even more so each additional call due to memoization.

Give pry a Try

2012-01-17T09:27:25-05:00

One of the things holding us back from developing on Ruby 1.9.3 has been ruby-debug. There are issues with installing and running it, and while they are manageable, it makes it such that (on a Rails projects with a Gemfile) every user needs to then use 1.9.3 and the unreleased ruby-debug19 version. Not fun.

So after many people suggested we try it, we gave pry a shot. I don’t know why we didn’t before; it is quick, easy, and allows a wide range of Ruby versions.

On a Rails project, your install is simple. In your Gemfile remove anything related to ruby-debug and add in pry:

group :development, :test do
  gem "pry"
end

Then, anywhere you previously used debugger use pry instead.

For example, we frequently have a cucumber step for invoking the debugger:

When 'I debug' do
  pry
end

It is a little different from ruby-debug, but we’re loving it so far!

Update: banisterfiend points out in the comments:

If you use `binding.pry` instead of just `pry` you’ll get access to all the locals at the point you call it, too :)

Welcome Ryan Glover

2012-01-09T13:10:19-05:00

We’re thrilled to welcome Ryan Glover to the team. Ryan comes to us from the scary world of government contracting, complete with the highest U.S. government clearance available. We think he might be a spy, but we’re ok with that.

Ryan is a Michigan native currently living in Maryland. Though after his stint learning Mandarin in the Air Force, he’d probably be comfortable anywhere in the world.

Online you can find him on GitHub or Twitter as @ersatzryan. We first met Ryan when he started forking some of our open source work. We loved his help and hope he continues.

We’re very excited to add Ryan to our team, so please give him a warm welcome!

Capybara, Cucumber and How the Cookie Crumbles

2012-01-05T13:26:04-05:00

When I write a new Rails application, it often needs some sort of user authentication. I like to test authentication in Cucumber and a typical happy-path scenario might look like:

Scenario: Happy path authentication
  Given the following user exists:
    | Email                    | Password |
    | steve@collectiveidea.com | secret   |
  When I go to the homepage
  Then I should see "Sign In"
  But I should not see "Sign Out"
  When I follow "Sign In"
  And I fill in the following:
    | Email    | steve@collectiveidea.com |
    | Password | secret                   |
  And I press "Continue"
  Then I should see "Sign Out"
  But I should not see "Sign In"

You’ll notice that the Given step above requires no action from the user. Givens simply set the stage for the rest of the scenario.

This will be important later.

Fast Forward…

So now that I have authentication working in my application, I’d like to use it elsewhere in my Cucumber suite:

Scenario: User email updation
  Given a user exists with an email of "steve@collectiveidea.com"
  And I am signed in as "steve@collectiveidea.com"
  When I go to the edit account page
  And I fill in "Email" with "steve@gemnasium.com"
  And I press "Save"
  Then I should be on the account page
  And I should see "steve@gemnasium.com"
  But I should not see "steve@collectiveidea.com"

But how do I write the second step to sign in my user?

Your first instinct may be to replicate the steps from our authentication scenario, but this can be a bad idea. After all, this is a Given. All I want to do is set the stage. I’ll be using this step quite a bit and the overhead of two additional requests can stack up quickly.

What I really want to do is to set the set the signed-in user directly. Here’s the current_user helper method in my ApplicationController:

def current_user
  return @current_user if defined?(@current_user)
  @current_user = cookies[:token] && User.find_by_token(cookies[:token])
end

And there inlies my answer… Let’s just set the cookie!

When /^I am signed in as "([^"]*)"$/ do |email|
  cookies[:token] = User.find_by_email!(email).token
end

And in some cases, this works great. If you use only the Rack::Test driver and avoid permanent or signed cookies, you should be all set. But as soon as you need your authentication step in a JavaScript scenario, it all falls apart.

Putting the Pieces Together

Long story short: each Capybara driver handles its cookies differently. The cookies hash we access in our step is specific to Rack::Test and is actually a Rack::Test::CookieJar object.

If you want your application cookies to Just Work™ from anywhere in your Cucumber suite, throw the following into features/support/cookies.rb:

module Capybara
  class Session
    def cookies
      @cookies ||= begin
        secret = Rails.application.config.secret_token
        cookies = ActionDispatch::Cookies::CookieJar.new(secret)
        cookies.stub(:close!)
        cookies
      end
    end
  end
end

Before do
  request = ActionDispatch::Request.any_instance
  request.stub(:cookie_jar).and_return{ page.cookies }
  request.stub(:cookies).and_return{ page.cookies }
end

You’ll need a stubbing library. I’m using RSpec.

This allows each of your Capybara sessions to keep its own separate set of cookies. And they’re real cookies, meaning that you can use cookies.permananent and cookies.signed just like you do in your controllers. Then, after each scenario, Capybara will clean its sessions, along with your cookies.

Just use page.cookies and you’re good to go!

When /^I am signed in as "([^"]*)"$/ do |email|
  page.cookies[:token] = User.find_by_email!(email).token
end

The Big Three-Oh

2012-01-04T09:31:19-05:00

Delayed Job turned 3 over the holidays. It’s been a long time coming but it finally happened. A huge thanks goes out to betamatt for his contributions and help in maintaining this project over the past year, as well as bernardelli for adding named queues. Thanks guys!

Changes

Here’s a quick rundown of the changes. You can see the full list on GitHub.

New: Named queues [ bernardelli ]
New: Job/Worker lifecycle callbacks [ betamatt ]
Change: daemons is no longer a runtime dependency
Change: Active Record backend support is provided by a separate gem
Change: Enqueue hook is called before jobs are saved so that they may be modified
Fix: Problem deserializing models that use a custom primary key column
Fix: Deserializing AR models when the object isn’t in the default scope
Fix: Hooks not getting called when delay_jobs is false

DJ 3 introduces Resque-style named queues while still retaining DJ-style priority. The goal is to provide a system for grouping tasks to be worked by separate pools of workers.

Jobs can be assigned to a queue by setting the queue option:

object.delay(:queue => 'tracking').method
Delayed::Job.enqueue job, :queue => 'tracking'
handle_asynchronously :tweet_later, :queue => 'tweets'

If you’re using rake, you can work off those queues by setting the QUEUE or QUEUES environment variable. If you’re using daemons, set the --queue or --queues option.

# with rake
$ QUEUE=tracking rake jobs:work
$ QUEUES=mailers,tasks rake jobs:work

# with daemons
$ RAILS_ENV=production delayed_job --queue=tracking start
$ RAILS_ENV=production delayed_job --queues=mailers,tasks start

DJ 3 no longer has daemons as a runtime dependency. You’ll need to add gem 'daemons' to your Gemfile if you want to use script/delayed_job. Check the comments on the commit for further explanation.

As always, feedback and patches are welcomed. :)

Type it Faster!

2011-12-15T11:23:52-05:00

I frequently see developers using backspace to delete a few words and it takes forever while they hold down the delete key. Please change your keyboard settings so I don’t have to suffer. You’ll be happier too, I promise.

On your Mac, open System Preferences, then Keyboard. You want to crank the Key Repeat all the way to Fast. I keep Delay Until Repeat a step off Short, but try going all the way then backing down if you desire.

Now go try holding down a key in an editor of your choice. Your life just got faster.

Likes vs. Favorites

2011-11-30T21:52:13-05:00

It seems like everything is social today, and everyone has their own way of marking highlights. Facebook has the Like button, Twitter lets you Favorite tweets, Google has +1, etc. While all these are basically the same idea, I find that naming plays a big part in how I use them

On Twitter and Flickr, where the term is Favorite, I use them to make a curated list of things I might want to find later. My true favorites.

Contrast that to Facebook and Instagram, where the term is Like. Because it feels less committal, I find myself liking all sorts of things. Funny post? Cute picture of your kids? I’ll Like that. It is more like a pat on the back instead of giving them an award, quicker and less permanent.

When developing an app, for you or a client, think about the terms you use and how you want people to use the feature. I’m sure other people don’t over-think the Favorite button like I do, but some will. Use language to lead people where you want them to go.

I am 9 programmer-years old

2011-11-02T11:36:30-04:00

I am about 9 years old in “Programmer Years”. Like dog-years, the conversion from human-years to programmer-years is about 7×. Thinking about a programmer development this way helps offer some lessons on growing into a fully mature developer (at about 18 programmer-years old).

During my first year (in programmer-years) I couldn’t really understand other programmer’s words and often spent my evenings balled up in the fetal position crying. This was a very frustrating couple of months. There is really nothing to do here but force your way through it. Light will come .

1-10 programmer-years old

I got so I could walk and then run, though not always running in the right direction. I was often whiny when I needed help. Other programmers raising me needed to be firm that sometimes I must solve my own problems. It was very much like my 6 year old daughter who knows how to tie her shoes, but it takes her twice as long and doesn’t turn out quite as well as when I do it for her. She is aware of this fact, so she whines and tries to con me to do it for her. If your raising a programmer in this development phase, tough love can be useful, but maybe help your youngster get the preverbal knot out.

10-18 programmer-years old

This is likely to be the most fun phase of your developer life. Latched onto a language as “the golden hammer”. You are confident that you can build just about anything. You’re adding new and more complex ideas every day and your confidence is running high. Which is cause for some caution, as this will likely lead to a couple character building disasters. Much like the 16 year old kid who’s ‘got this driving this down, man’ and then unwittingly drives his pickup truck straight into his girlfriend’s parent’s house while making-out with her (yes, that happened). My only advice here would be to try to keep older programmers around through this phase of development to save you from yourself.

18-70 programmer-years old

You’re a pro. You’re a teacher, open source contributor, and you will make big changes in the world.

70+

You can always pick out the 80 programmer-year old programmers as well. They may have a full on neck beard, they are usually grumpy, surly and often act slightly crazy when responding to seemingly trivial things.

Thinking about a programmers development this way has had a significant effect on how I learn.

When we teach a 6-year-old math we don’t hand them a math book starting with Addition, and ending in Differential Equations and say, “when you finish, you’ll know ‘math’.” Yet programmer books are not usually broken up in to “Grades”, so the inclination for newbies is to sit down with a Ruby book, for example, and ‘learn’ Ruby. A much more efficient and useful approach would be to have yourself surrounded with books for Ruby, Rails, SQL, jQuery, Unix, Python, Regular Expressions, HTML… (and others depending on what your focused on) and read the first quarter of all of them, then go on to the next quarter, much like a child in school learns a little math and science and a little geography in a particular grade, and then moves up to the next level. Programmers rarely work in a language or technology vacuum. Doing anything useful requires you know at least a few different “subjects”.

Still up for debate however, is whether to allow 9 programmer-year-olds to write blog posts for your firm…

Changing Your Stripes

2011-11-01T08:31:34-04:00

Recently we made good on a long-held idea that there should be a weekend for finishing things. Enter Finish Weekend.

We knew we’d need registration to tell us how many people would be coming. Obviously this plays a part in the size of our space, the food we provide, and the number of T-Shirts. To keep the registration honest, we decided to charge a small fee to each registrant. That’s where Stripe comes in.

Stripe uses a two part approach. First, using their Stripe.js library, you send the credit card information to their secure servers and they send back a single use token. (We’re using coffeescript here)

Stripe.createToken({
  number: $('.card-number').val(),
  cvc: $('.card-cvc').val(),
  exp_month: $('.card-expiry-month').val(),
  exp_year: $('.card-expiry-year').val()
  }, amount, (status, response)->
    if status == 200
      $form = $("#registration-form")
      $form.find("#stripeToken").val(respond[id])
      $form[0].submit()
    else
      if $(".alert-message").length
        $(".alert-message").remove();
      $(".page-header").after("<div class='alert-message error'>#{response.error.message}</div>")

This token is then submitted with in a form to your servers where you can make use of one of Stripe’s libraries to actually charge the card. We use Ruby on Rails, so our code looked something like this:

Stripe.api_key = Rails.env.production? ? "LIVE_PRIVATE_KEY : "TEST_PRIVATE_KEY"
charge = Stripe::Charge.create(
  :amount => 1000,
  :currency => "usd",
  :card => token,
  :description => "Finish Weekend Registration (#{params[:person][:name]})"
)

Part of the magic of the token passing process is having a public/private key set to be able to pass around. Since these are different for the test and live environments, we do a little magic of our own. We’re using Rails 3.1 for Finish Weekend, so we can just tack on .erb to the end of our script file which allows us to do this:

Stripe.setPublishableKey('<%= Rails.env.production? ? 'LIVE_PK' : 'TEST_PK' %>')

Overall Stripe has been awesome to work with. We got this up and running in less than an hour.

Install Ruby 1.9.3 with libyaml on CentOS

2011-10-31T11:26:13-04:00

Ruby 1.9.3-p0 makes psych—the replacement for 1.8.7’s YAML library, Syck—the default YAML parser. Psych is a wrapper around libyaml, so you’re going to need it installed and configured before installing Ruby.

If you install 1.9.3-p0 without libyaml, you’ll see warnings like this:

It seems your ruby installation is missing psych (for YAML output).
To eliminate this warning, please install libyaml and reinstall your ruby.

Installing libyaml

$ wget http://pyyaml.org/download/libyaml/yaml-0.1.4.tar.gz
$ tar xzvf yaml-0.1.4.tar.gz
$ cd yaml-0.1.4
$ ./configure --prefix=/usr/local
$ make
$ make install

Quick review of what’s going on: download and untar the source code, change to the directory and install the package. You may need to sudo the make install command. Your mileage may vary.

Installing Ruby 1.9.3-p0

$ wget http://ftp.ruby-lang.org/pub/ruby/1.9/ruby-1.9.3-p0.tar.gz
$ tar xzvf ruby-1.9.3-p0.tar.gz
$ cd ruby-1.9.3-p0
$ ./configure --prefix=/usr/local --enable-shared --disable-install-doc --with-opt-dir=/usr/local/lib
$ make
$ make install

After installing, you can verify that Ruby was installed with ruby -v. It’s also worth trying gem --version to make sure you don’t get any errors regarding psych.

I tried installing libyaml-devel and libyaml from Yum, but couldn’t get ruby installed and recognizing those packages. Out of frustration, I turned to installing libyaml by source and it Just Worked™.

Thinking about Ruby's Symbols

2011-10-24T11:32:04-04:00

I just returned from teaching Ruby & Rails in L.A. and I got thinking about Ruby’s Symbols. Symbols quickly become second-nature to Rubyists, but they’re difficult to teach.

Those new to Ruby see something like:

Person.where(:name => 'Daniel')

<%= form.text_field :name %>

and begin to get confused. Even when I start in plain Ruby and introduce symbols, usually saying “they’re mainly used as keys in a Hash” I get strange looks. They try to figure out what a symbol “means” and think of it as a variable. This is understandable. I usually try to tell those hung up on the “why” of symbols to give them a chance and they’ll soon understand how symbols are used.

In a case like validations or associations, they get confused because we’re using symbols instead of the actual thing: the column, model, or table.

validates :name, :presence => true

belongs_to :company

Seasoned Rubyists know that we do that because we’re not referring to the actual thing. We don’t want the column value, we want an identifier to that thing that we can use later.

Hashes

Then we see things in Ruby that look like symbols, but backwards.

Console/log output:

> Person.where(:name => 'Daniel').first
=> #<Person name: "Daniel", style: "awesome">

Ok, that’s just some output, and it looks more like JSON than Ruby, but we’ll frequently end up setting (and getting) them using a hash, making it more confusing.

person = Person.new(:name => 'Daniel', :style=> 'awesome')
person[:name] = 'Dan'

I think this waters down symbols a bit, but really you don’t have to truly understand symbols to use Ruby or Rails, just know when they’re used.¹

Ruby 1.9

Symbols might become even more confusing with Ruby 1.9’s new Hash syntax:

Person.create(name: 'Daniel', style: 'awesome')
Person.where(name: 'Daniel')

What?!? So we’re defining hashes with symbol keys, and a symbol is defined as beginning with a colon but we’re writing it with a colon on the other side?!?

Look at this and tell me it isn’t confusing:

> h = {name: 'Daniel'}
=> {:name=>"Daniel"} 
> h[:name]
=> "Daniel" 
> h[name:]
SyntaxError: (irb):3: syntax error, unexpected ']'

I’m not sure this will make explaining symbols any easier. It sort of meshes with the console output, but even irb displays using the older syntax. I’m actually a fan of the new syntax². It looks more like JavaScript (and Python) and saves characters, but unfortunately I suspect it will create new confusion.

Take this example:

validates :name, presence: true

:name is a pure Symbol, so the colon goes before. presence: is a symbol, but used as a Hash key. Sheesh.

Final Thoughts

We definitely want to move the language forward, but we have to be careful to not confuse new users. A common source of bugs among my training students is missing colons, thereby raising unexpected exceptions.

I’m not sure what’s needed, but maybe a rethink of how we access hashes. Would it make things easier if h[name:] worked? Would it be better if all hashes acted like HashWithIndifferentAccess and we could access them with h['name']? I’m not sure.

Symbols are a fantastic Ruby concept and make the language much more expressive. When combined with good syntax highlighting, they also help differentiate code from strings. Unfortunately, they’re only going to get more confusing for newbies.

¹ I’m a believer that mastery comes with time. For example, I didn’t truly understand how .each {} worked while I was getting started with Ruby, but it didn’t hold me back from using it. You need to recognize and be able to use the syntax, not know how passing blocks works behind the scenes.

² I wish it would have been done this way originally. The community isn’t bold enough to rip out the old way completely in 2.0. Maybe 3.0?