Zerosum Dirt(nap)

The Wefunder Petition

2012-01-31T00:00:00-05:00

Kickstarter is awesome for funding creative projects. It’s one of my favorite startups at the moment, and it’s important. I lurves it. But I wish I could use something like it to invest in actual companies – both the tech startup variety that my friends work tirelessly on as well as the hyper local variety that make those special tapas that my neighbors are raving about.

Soon, new laws may allow us to do just that.

To raise awareness of these initiatives, a few friends and I tossed together the Wefunder petition to support HR2930 and Brown’s Democratizing Access to Capital Act (S.1791) that’s currently being debated in the US Senate. Please go sign it (click the “learn more” link on the site for more background information and links).

These changes could have huge impacts for both entrepreneurs and investors, allowing bold new ideas to surface and creating a ton of important jobs and opportunities. I know that sounds like marketing speak, but it’s true. This matters.

We’ll be going to DC next week to talk to Senator Brown’s people and see what else we can do to push this forward. We’ve also been fortunate enough to get some great coverage for our efforts at BoingBoing and ReadWriteWeb.

Now go sign it already and help us send a message. And thanks!

Building Android Apps with Mirah and Pindah

2011-07-24T00:00:00-04:00

I gave a talk earlier today at the Beijing Ruby group today about my experiences building native Android applications with Mirah and Pindah.

Although I generally prefer building mobile web apps over native development when possible, Mirah is a really promising alternative to Java if you have to go native. Check out the preso below and get involved in the growing Mirah / Android community.

Make sure to grab the code for the example app on the GitHubs.

Geeks on a Train

2011-07-21T00:00:00-04:00

Geeks on a Train starts today!

This afternoon I’m leaving Dalian, Liaoning, China for a 10-day journey across China’s tech ecosystem with a bunch of awesome startup founders. By train. Because planes and buses are so last year (kidding!)

With stops scheduled in both Beijing and Shanghai and a number of events on the schedule including tech meetups, company visits, mentor meetings, and a 10x10 mini conference in each city, it’s bound to be a fun – and delightfully chaotic – experience. I’ve really been looking forward to it.

Geeks on a Train (affectionately referred to as “GOAT”) is part of the Dalian-based Chinaccelerator program, which is a Chinese startup accelerator run by program director Cyril Ebersweiler and the good folks at SOS Ventures. I was fortunate enough to meet them through TechStars in 2010 and am really honored that they invited me over to work with some of the young teams that were accepted into the program this year. How could I say no?

Chinaccelerator itself is much like TechStars, but with a brilliant international twist. The startups here aren’t just from China, they’re from all over the world, with founders from Malaysia, Canada, Italy, the Phillipines, India, and England, as well as China and the United States. It’s really fascinating to experience both the similarities and differences of startup life on the other side of the world, but a couple philosophies remain as constants: heartfelt motivation and JFDI are key.

In the two weeks I’ve been here thus far, I’ve seen the founders produce some truly great work and make impressive progress. It’s good stuff. There’s nothing more inspiring than being trapped in a room full of crazy entrepreneurs with wildly different backgrounds who are trying to change the world.

But I can only imagine what it’s going to be like trapped on an overnight train with them :).

Rails Rumble Alumni Archive Project

2011-07-02T00:00:00-04:00

2011 has been a busy year so far, full of interesting contract work, side projects, research for the next startup biz, upcoming travel plans, and not-so-fun family health issues. It’s also been a busy year for the other Rails Rumble organizers, and as such there’s currently no date set for the 2011 contest. Sorry about that :(.

However, I did find a few hours last weekend to design / develop a Rumble-related mini-site that’s been long, long overdue…

The new Rumble Alumni Archive is a searchable archive of websites and applications that were developed during contests past and present. It’s a great way to see what entries are still online and browse them by year (2007-2010), country of origin, and award.

Over 80 entries that were developed during Rumble events are still online, most of which have evolved pretty significantly since their initial weekend development sprint. For just a couple examples, check out Mocksup, Awesome Fontstacks, and IOU Mate (formerly “nDebted”). Go poke around the archive to see others; there’s some really great stuff in there. And please let us know (contact organizers at railsrumble dot com) if we’ve left anybody out.

I know I’ve said it before, but it’s really inspiring to me when I think about how many of these polished web apps started off as as disposable weekend experiments. Kick. Ass.

Song Lyrics Without the Suck

2011-06-26T00:00:00-04:00

Over the past few years I’ve been involved with a number of music-related web projects, including Loudwerkz, DMOD (RIP), and Ink19. Although I make my living on the web and love what I do, I suppose I’ve always been secretly jealous of those snobby record store employees who hear the latest cuts first, troll naive customers, and argue with their coworkers about song meanings :).

Fortunately, the web has lowered the bar to all of that stuff. What would we do without Pandora, Last.fm, and (more recently) Turntable? The one missing piece for me has always been a good song lyrics site. Sure, there are lots of lyrics engines on the web, but they’re all dreadfully designed, spam-centric, and just scuzzy feeling in general. Search for lyrics for your favorite song on Google, and you’re bound to end up looking at popup ads for diet pills.

If you’re like me, this makes you sad. And irritated. So there I was, bitching about this on Twitter one evening, when Seth Banks proposed that we actually do something about it. So we did.

Last week, Seth and I launched Lyricful, which aims to be the first classy lyrics site. We started with a nice clean design and paired it with a sizable lyrics database (growing every day), an intuitive search interface, and some SEO know-how. We’ve also added a few other things we felt fans would find useful, like song previews, concert information, and easy sharing features.

Most importantly, Lyricful isn’t running any invasive eyeball-bleeding advertising. The only ads on the site are in the form of song preview links and concert ticket referrals, relevant to the artist you’re currently browsing (which directly benefits the artist). We built this for ourselves, as music lovers and fans, which means that we wanted to make it as easy as possible to get right to transcribing, discussing, and sharing your favorite lyrics.

Since the soft launch, we’ve started working with a number of artists who were interested in Lyricful and its sister site, MusicNewsHQ. To start with, we’ve added featured / verified artist spots, which will help promote up and coming artists and ensure accuracy of the site contents. Double win. I’m really looking forward to seeing how this project evolves, having both artists and their fans involved in the process. Got feedback for us? We’d love to hear it!

Startup Workaway - Coworking in Costa Rica

2011-05-03T00:00:00-04:00

Are you a hacker? Working on a startup? How about coworking and networking with other people who are building inspiring new stuff? Sure you do.

And who doesn’t like the rain forest? See also: howler monkeys.

StartupWorkaway is something Nick, Zach, and I have been talking about for quite awhile. We actually built most of the website back in February when we rented a house together up in Quebec City during Winter Carnaval. Nick polished it up and posted it to Hacker News the other day and the response has been pretty incredible so far.

Visit StartupWorkaway for all the gory details. The application deadline is May 6th.

Easy Rails OAuth Integration Testing

2011-03-19T00:00:00-04:00

A long while back I wrote a post about Twitter auth integration testing using Cucumber. Back then OAuth was just beginning to see widespread use, but it was nowhere near as popular as it seems to be today. In my latest side project, all logins are from Twitter or Facebook because there’s simply no need for local accounts (due to the nature of the app). But that also means that we needed an easy way to support third-party authentication in our integration tests.

We’re using OmniAuth to handle auth here, which is absolutely awesome. And we’re also using the equally-awesome Capybara for integration testing. Cucumber is no longer part of my standard testing repertoire. I could go into a long rambling post as to why, but chances are you already have some pretty good ideas about that. If you haven’t felt that pain, and Cucumber works for you, that’s great. Seriously. I’m extremely happy for you.

On the other hand, if you’re dissatisfied… Capy 1.0 comes with a swanky new minimalist RSpec-friendly acceptance testing DSL that you really ought to take a look at. The 1.0 gem hasn’t been released yet, but you can pull it into your project directly from the GitHub source if you specify it in your Gemfile. It’s really quite nice and simple, and I’m very happy with it so far.

If you want OAuth integration testing to be easy, you’ll want to make sure you’re using the OmniAuth 0.2.0 or later. Among it’s many fine features is a new integration test_mode that makes testing OAuth logins less sucky than it’s ever been before. Fortunately for us, Capybara and OmniAuth go together like giant chocholate swamp rat and creamy peanut butter. It pretty much works right out of the box.

To demonstrate, let’s add a nice little integration auth helper method that we can use in our request specs to log a user in (I like to put this in spec/support/integration_spec_helper.rb):

module IntegrationSpecHelper
  def login_with_oauth(service = :twitter)
    visit "/auth/#{service}"
  end
end

Now, in your spec_helper.rb, add the following:

RSpec.configure do |config|
  # ...
  config.include IntegrationSpecHelper, :type => :request
end

Capybara.default_host = 'http://example.org'

OmniAuth.config.test_mode = true
OmniAuth.config.add_mock(:twitter, {
  :uid => '12345',
  :nickname => 'zapnap'
})

Finally, let’s take a look at an example RSpec request spec that leverages this helper to test a workflow where a user login is required:

feature 'testing oauth' do
  scenario 'should create a new tiger' do
    login_with_oauth
    visit new_tiger_path

    fill_in 'tiger_name', :with => 'Charlie'
    fill_in 'tiger_blood', :with => 'yes'
    
    click_on 'Create Tiger'
    
    page.should have_content("Thanks! You are a winner!")
  end
end

That’s it. OmniAuth’s test mode automatically mocks out the authentication workflow, allowing us to supply our own auth results hash. Requests made to the usual /auth/provider URL will redirect immediately to the provider callback, which means we never have to hit the actual provider while testing (which also means that webmock or fakeweb remain happy).

This might seem simple, and it is. And that’s kind of a big deal. So now we can get back to writing stuff that isn’t plumbing and focusing on solving real problems ;).

Better AWS Access Control with IAM (and Fog)

2011-03-02T00:00:00-05:00

Amazon are the undisputed kings of the developer plumbing revolution. EC2 and S3 are so ubiquitious to deploying web applications that sometimes it seems difficult to remember when we had to self-host so much of this stuff. But sometimes managing my access keys can be a pain. Or even worse: a security hazard.

On one hand, I don’t want to create a new account with different billing information for every single client project demo or collaboration that I roll out. Yet on the other, I’m hesitant to use my own set of keys in places where another person might have access to them. One set of keys to the entire kingdom seems like a bad idea.

The solution to this problem is Amazon’s Identity and Access Management product beta. IAM allows you to create different users and groups, and attach those to your account. So, for example, if you’re a company or a group of people who needs to share a single AWS account, you could create separate identities with separate security credentials (access key ID + secret access key) for each individual. Or if you run several different projects and want to segregate those by account, you can do that too.

Even better, you can control which AWS services that those users (or groups) have access to via policy documents. A common example might be giving a user identified as ‘projectx’ access to only a ‘projectx’ S3 bucket and no others. This way, you can keep your accounts separate, and limit them to only what they need. And if you ever need to revoke or regenerate keys because a single application is compromised, it’s far less of a problem.

Anyway, outside of Amazon’s own documentation, I couldn’t find a hell of a lot of information about using IAM in the real world, so I thought I’d demonstrate how I’m using it with Fog, which is an absolutely awesome cloud services library for Ruby.

Annotated example code seems like the right way to go here. Let’s generate a new IAM user and a set of keys for him, and give him permission to only a single bucket, which we’ll create (note that your bucket name must be unique so don’t use the sample one shown here).

First, we set up the new user name and the bucket name that we want to create, and establish our AWS credentials:

require 'fog'

username = 'testuser'
bucket = 'uniquebucketname1234'

aws_credentials = { 
  :aws_access_key_id => 'YOUR-ACCESS-KEY-ID', 
  :aws_secret_access_key => 'YOUR-SECRET-ACCESS-KEY'
}

Creating a new S3 bucket is easy with Fog:

storage = Fog::Storage.new(aws_credentials.merge(:provider => 'AWS'))
storage.put_bucket(bucket)

Fog also provides a lightweight wrapper around IAM API methods. Using this, we can create the new user and create an access key. Assuming this is successful, we’ll end up with the user ARN (which we’ll need later) and a new set of credentials.

iam = Fog::AWS::IAM.new(aws_credentials)

user_response = iam.create_user(username)
key_response  = iam.create_access_key('UserName' => username)

access_key_id     = key_response.body['AccessKey']['AccessKeyId']
secret_access_key = key_response.body['AccessKey']['SecretAccessKey']
arn               = user_response.body['User']['Arn']

We want to give this user the ability to manage their own keys (as shown in Amazon’s Getting Started guide so we create our first policy document as they suggest.

iam.put_user_policy(username, 'UserKeyPolicy', {
  'Statement' => [
    'Effect' => 'Allow',
    'Action' => 'iam:*AccessKey*',
    'Resource' => arn 
  ]
})

We also want to grant them access to the bucket we created. But only our bucket and no others. If you think constructing policy documents by hand is shitty, you’re right. Fortunately the AWS Policy Generator can help us generate the nasty bits. Check it out.

iam.put_user_policy(username, 'UserS3Policy', {
  'Statement' => [
    {   
      'Effect' => 'Allow',
      'Action' => ['s3:*'],
      'Resource' => [
        "arn:aws:s3:::#{bucket_name}",
        "arn:aws:s3:::#{bucket_name}/*"
      ]   
    }, {
      'Effect' => 'Deny',
      'Action' => ['s3:*'],
      'NotResource' => [
        "arn:aws:s3:::#{bucket_name}",
        "arn:aws:s3:::#{bucket_name}/*"
      ]   
    }   
  ]
})

Finally, let’s reset our IAM access credentials and verify we can access the bucket and upload a file to it:

aws_credentials = { 
  :aws_access_key_id => access_key_id,
  :aws_secret_access_key => secret_access_key
}

storage = Fog::Storage.new(aws_credentials.merge(:provider => 'AWS'))
storage.get_bucket(bucket)
storage.put_object(bucket, 'image.png', File.open('/path/to/image.png'))

Note that you can use the keys that are generated in place of your normal account keys pretty much anywhere, as demonstrated. However, if you’re limiting bucket access as we’ve done here, be aware that you won’t be able to do a list command to retrieve all buckets accessible to a user. I had an incredibly frustrating couple of hours the other day trying to figure out why s3cmd and the Firefox S3 Organizer wouldn’t work with my newly generated IAM keys, and the reason was simply that they were trying to get a list of buckets first, which was returning an access denied message. D’oh. (and thanks to crazed for helping me see the light on that.)

If you’re not a Ruby developer, or you just need command line access, you can also use the IAM command line tools provided by Amazon, and you should definitely check out their Getting Started guide. Hopefully IAM will find its way into the AWS Console so routine management tasks are a bit easier in the future. In the meantime, creating policy documents by hand is a big pain in the ass, but at least the Policy Generator takes a little bit of the suck out of it.

Get the full example source

Stomp in the Android Market

2011-02-26T00:00:00-05:00

My pal and “prolific prototyper” Nick Tommarello just released his latest project into the wild… Stomp.io is a social adventure and travel guide that aims to make it easier for you to find fun things to do while at home or on the go. Stomp debuted at the Launch conference run by former TC50 founder Jason Calacanis, and has gotten some great media coverage over the past couple days. Like pitches? You can watch Nick’s presentation here.

If you’re in SF, NYC, or Boston, make sure to give it a try. Hopefully it won’t take too long to spread to other areas too. Some of the challenges are… kind of nuts. Others are a bit more laid back. And there’s a lot more in-between so I’m pretty sure you’ll find something you like there. You can install the mobile version of the app on both the iPhone and Android

Oh and if you’re having problems with the Android version of the app you can yell at me. Working with Nick on Stomp was a great excuse for me to level up on Android development. There’s no better way to come up to speed on a new platform than to dive in and deliver a working application. That said, the app is still young and a bit sparse, and I’m sure there are still a few bugs hiding in the woods; Crash reports and feature requests are very welcome :). Thanks in advance!

Ohai Tumblr

2011-01-02T00:00:00-05:00

At one point in time (affectionately referred to as the “long long ago”) I used to post all kinds of stuff here, both technical / programmery and non-technical / non-programmery. Once I started using Twitter on a regular basis, I stopped posting here as much, and when I did, the content was pretty much just technical stuff. Which is a big win if you’re a fan of the signal to noise ratio.

“But,” you say, “I like more noise with less signal!”

Me too! And thus it was that I set up a Tumblr account awhile back, mostly for posting stupid pictures. But I figured, what with it being 2011 and all, that I’d maybe I’d also start writing a little bit more there. Or maybe not. We’ll see.

If you’re interested, follow me on Tumblr.

Oh, and Happy New Year!

Fooling Around with Mirah and Android

2010-12-20T00:00:00-05:00

Have you spent any time playing around with Mirah yet? You should. It’s developing into a pretty awesome language. Or maybe just a fantastic Ruby-like syntax for Java, depending on how you look at it. Mirah as a language (err, compiler) is still a work in progress, but it’s very usable as-is and fun to play around with.

If nothing else, it certainly makes writing trivial Android applications more enjoyable. Want to write one yourself? Check out Protoform, a little Mirah Android app generator that I tossed together a few weeks ago. Install it via Rubygems and get your droid on:

gem install protoform
protoform -S ~/android/sdk -T "Hello Android" -P org.zerosum.android HelloWorld

You’ll want to have JRuby and Mirah installed of course. Get JRuby with RVM and then gem install Mirah.

If you want to do Android work in straight Ruby instead, you can take a look
at Ruboto. However, Ruboto runs on Android
via JRuby, which means the runtime needs to be bundled in to the APK, leading
to large file sizes and slow execution. Mirah, on the other hand, compiles
straight to Java bytecode with no middleman and makes direct use of the Google
Android APIs. Ruboto is under heavy development and coming along nicely though, and the more Ruby-like API wrappers are a welcome alternative.

Both of these projects have the potential to be pretty important stuff. As
does anything else that makes mobile client development less painful
(Appcelerator, Phonegap, Rhomobile, etc).

A Pure Git Deploy Workflow (with Jekyll and Gitolite)

2010-11-01T00:00:00-04:00

Manually deploying static site updates is so 2003. And Capistrano is great, but it’s an extra step you don’t always need (and somewhat overcomplicated). If you’re using Jekyll to power your site and already have your data in Git, it’s pretty easy to set up a pure Git deployment workflow. Even if you’re not using Heroku ;-).

By using either Gitosis or (better yet) Gitolite, you can be autodeploying like a boss in just a few minutes. And, because Gitolite allows you to manage repository access across ad-hoc groups, you can easily allow other users to push to your remotes and update the appropriate sites without them needing shell access on your server. And share those users across multiple projects, and so on and so on.

Here’s how I set up the deploy recipe that I use for updating this blog and a couple other static sites that I’m hosting on the same box.

Gitolite Installation

First, install Gitolite on the host you want to deploy to. Sitaram’s installation instructions are really easy to follow, but I’ll summarize here (I used the root method, which I suspect is what most readers would want to use too):

git clone git://github.com/sitaramc/gitolite gitolite-source
cd gitolite-source
git checkout v1.5.6 (or whatever tagged version you want)
mkdir -p /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks
src/gl-system-install /usr/local/bin /usr/local/share/gitolite/conf /usr/local/share/gitolite/hooks

You’ll need to add a git user, who will own the repositories on the system. Create one now, and finish the Gitolite installation process:

adduser git
su - git
gl-setup /path/to/your/public-key/id_rsa.pub

Gitolite Administration

Make sure that you gave gl-setup the correct public key from your local (client) system. Now, on your client, you should now be able to check out the gitolite admin repository, through which you can manage users, groups, and repository access.

git clone git@my-server:gitolite-admin

Next, edit gitolite-admin/conf/gitolite.conf. Gitolite comes with a couple pre-defined group definitions (including one for the admin repository; don’t screw that one up). Adding a user permissions for a new repository goes like this:

repo  blog
      RW+ = kyle stan

Where blog is the name of the repository you want to create, and kyle and stan are two users who will need to be able to read and write to that repository. We have no way to identify Stan and Kyle yet, but that’s the next step. We’ll add their public keys to the gitolite-admin/keydir directory. Make sure to name them kyle.pub and stan.pub.

Add the new files to the git repo (git add .) and commit everything. Push it to the remote with git push origin master. This should push the gitolite admin changes back to your remote server and update the internal configuration, allowing Stan and Kyle to work on the blog project.

Managing a Static Site

For simplicity’s sake, let’s say that you’re Stan (Stan’s public key is your public key). To create the new repository and register it with Gitolite, you should now be able to do the following:

mkdir blog
cd blog
git init
touch index.html
git add .
git commit -a
git remote add origin git@my-server:blog
git push origin master

Instead of just creating an empty index file, make it a simple html file, or drop in a basic Jekyll site. Or, instead of creating a brand new repository, just add a remote (call it production perhaps?) to an existing Jekyll repository that you’ve been working on. In any case, when you push those commits up, Gitolite should check that your public key is authorized to perform that operation, and (assuming that it is) create the new bare repository for you automatically. Because it’s cool like that.

If you have a problem with this step, check that (a) your public key is indeed mapped to a username that is authorized to RW that repository, and (b) that the name in your gitolite.conf matches the public key filename.

If that all appears to be working, your next step will be to create a virtual host entry in your Apache config on the server (or your web server of choice). Here’s a basic Apache vhost:

<VirtualHost *:80>
  ServerName blog.superawesomedomainname.com
  ServerAdmin info@superawesomedomainname.com
  DocumentRoot /var/www/blog
  
  ErrorLog /var/log/apache2/blog-error.log
  CustomLog /var/log/apache2/blog-access.log combined
</VirtualHost>

And of course, create the docroot destination and make sure the git user owns it and can write to it. Then you can enable the config and restart Apache (or nginx or whatever).

Auto-Update on Deploy

I’m going to assume that we’re working with Jekyll here. And you should be, because it’s awesome. But if you are using some other static site generator, you can customize it pretty easily. The basic idea is that you want a post-receive hook to fire whenever the server receives a new push, and you want to regenerate the site data and redeploy it for everyone to see. This makes creating a new blog post really easy, for example.

Navigate to /home/git/repositories/blog.git/hooks and edit the post-receive file. You may also need to chmod ug+x it so it’ll execute properly. Here’s what goes inside:

GIT_REPO=$HOME/repositories/blog.git
TMP_GIT_CLONE=$HOME/tmp/blog
PUBLIC_WWW=/var/www/blog

git clone $GIT_REPO $TMP_GIT_CLONE
cd $TMP_GIT_CLONE && jekyll --no-auto $TMP_GIT_CLONE $PUBLIC_WWW
cd ~ && rm -rf $TMP_GIT_CLONE

find $PUBLIC_WWW -type f -print0 | xargs -0 chmod 666
find $PUBLIC_WWW -type d -print0 | xargs -0 chmod 777

exit

Save that, and then commit a sample change from your client and push it to the remote. The server should fire the post-receive hook automatically when the push has finished, and regenerate the site, dumping the changes into your docroot directory for the world to see. In fact, you should even see the Jekyll generation output in the git push command output, which makes it extra easy to troubleshoot in case you’re having a problem.

And voila, git auto-deploy goodness.

What’s best about this is that it’s easy to authorize new users to update a group site or blog, and manage those users all through their public keys and a simple config file. This config also makes it easy to spin up new static sites on the same host; just copy a couple configs and you’re good to go (or even better, investigate dynamically configured mass virtual hosting).

If you’re self-hosting your blog with some custom blog package you should really give this type of setup a look. I like it because it’s simple to manage access, incredibly quick to deploy updates, and everything is naturally stored in Git and in plaintext, so you’ve always got full revision history and never have to worry about vendor lock-in or proprietary formats. Need comments? Use Disqus. Less moving parts is almost always better. Simple is good.

More Jekyll, Less Hyde

2010-10-30T00:00:00-04:00

This blog has been running Mephisto since 2007 or thereabouts. And it seems like the Mephisto project has been dead for just about that long too (check that link if you don’t believe me). So that’s awesome. But such is life… and open source.

Anyway, I’ve been meaning to migrate my blog over to something else for quite some time. Switching is of course a pain in the butt so I’d been puting it off, but the decommissioning of the server host this blog used to run on was finally the shove that I needed. After evaluating a few blog engine and hosted service options, I decided to go with Jekyll . Why? Because it’s simple, static, and seems to be pretty fad-proof at this point. Also, it’s Halloween. So it’s thematic. I considered moving stuff to Tumblr or Posterous, but the import process proved to be an obstacle. And not Halloweeny at all. In the end, Jekyll was clearly the simplest and most malleable solution, and so here we are.

Moving wasn’t too too painful. I whipped up a few scripts to yank the data I needed out of Mephisto and then spent a few extra hours cleaning up some sloppiness and making sure all the permalinks still worked. I ported the NH Ruby blog and a few other small sites that were running on a Mephisto multi-site install at the same time. I really wanted a pure Git workflow for easy deployment, so I created some post-receive hooks that auto-deploy the latest changes when someone pushes to origin/production. And because a few other people needed to be able to post to the other sites, I figured I’d set up Gitolite, which makes managing access control for such things crazy easy.

The only thing that didn’t make the transition is old blog comments. I went with Disqus for the new site because I wanted to keep everything static and simple (avoiding lock-in to yet blog package that may or may not ever be updated again), and importing the Mephisto comments into Disqus was just too much of a pain to justify the time. Sorry about that.

Anyway, I’m pretty happy with the new setup. If you find anything that’s broken please let me know. Maybe if I get some free time over the next couple days I’ll document the Gitolite + Jekyll deployment config. I imagine that it’s not completely unlike a minimalist version of what the GitWrite guys had to do for their (awesome!) Rails Rumble entry this year. And yeah, I probably could have just used them too. Don’t know why I didn’t think of that earlier ;-).

Rails Rumble 2010

2010-10-21T00:00:00-04:00

This is the fourth year I’ve helped organize the Rails Rumble innovation competition and the entries this year are definitely the best I’ve seen yet. Our panel of experts have finished making their finalist selections and public voting just opened, so head on over and help us decide who gets to do a victory dance this weekend.

Announcing RubyDoc.info

2010-08-30T00:00:00-04:00

Last year we launched a little web service called rdoc.info for hosting public docs for Ruby libraries. It wasn’t a completely new idea, but there was nothing else out there at the time that was free and open source and worked on Github post-commit hooks, so I put something quick together in a day and started using it. A bunch of other people started using it too, which was great, and people started contributing patches, which was even more great (thanks in particular to Jeff Rafter and Brian Turnbull). It grew as more people and organizations like our friends at Thoughtbot started hosting their library docs on it.

Today it hosts docs for almost 3000 different Ruby projects. And today we’re killing it.

RubyDoc.info is Rdoc.info 2.0

Well, actually, it’s more like we’re replacing it. With something newer and better, of course. That newer, better thing is RubyDoc.info (source on Github), a project that originally started out as the yardoc.org doc server grew into a full-fledged rdoc.info replacement. Loren Segal (the author of YARD, easily the best Ruby documentation engine ever) and I have been working on merging the projects together for awhile now, and it’s finally cooked well enough that we’re ready to swap it over.

The new site addresses a number of outstanding issues / feature enhancements that people asked for on the old site, and it’s much more tied into the YARD ecosystem. Also, in addition to supporting GitHub post-commit hooks, it also hosts documentation for all published RubyGems. We like it, and we hope you do too.

If You’re Already Using Rdoc.info

If your docs are already up on rdoc.info, don’t worry. Your old URLs should still work, so no need to update them right away. Your post-commit hooks will still work too. If you have any problems at all, please open a ticket on the project’s Github repository and we’ll do our best to get you squared away. Thanks!

Better Docs == Better Code

Also, in case you’re not already familiar with YARD, now is a great time to learn about it and how it can help you improve documentation for your code. This new site deployment coincides with the release of the brand new YARD 0.6 and Loren’s awesome new Yardoc.org site, which has some great guides and other resources to get you up to speed fast.

Resque Mailer v1.0.0 (with Rails 3 Support)

2010-07-28T00:00:00-04:00

I just released a new version of Resque Mailer (1.0.0), my asynchronous email delivery extension for Resque gem src. If you’re already using it with Rails 2.x, there really aren’t any changes you need to be aware of. Go about your business. However, thanks largely to the efforts of Marcin Kulik, the gem now works in Rails 3.x as well. Thanks Marcin!

So why go 1.0.0? Because it’s feature complete, used by a number of people in production, and has been stable without any significant feature additions or issues for quite some time. It’s still simple as hell, and I don’t see it getting more complicated any time soon. And now that it works on both Rails 2.x and 3.x, well, that sounds like a 1.0.0 to me.

Google Analytics Integration with OAuth

2010-05-28T00:00:00-04:00

In case you’re not reading the Mogo blog, I posted a tutorial over there yesterday about how we integrate Google Analytics with Rails using OAuth and Garb . It’s not a terribly arduous process, but if you haven’t done much work with OAuth it can be confusing, and there are a couple unique Googly things about it that might otherwise trip you up.

The post includes complete code for an OAuth-backed authorizations controller too, which should help you get up and running quickly. And fwiw, it should actually be applicable to all the Google Data APIs, not just Google Analytics. Just change the request token scope.

And yeah, I really need to get back to blogging on a semi-regular basis, too.

Rails Camp New England Redux

2010-03-12T00:00:00-05:00

Already got plans for this weekend?

The second Rails Camp New England is this weekend, March 12th to the 14th, in West Greenwich Rhode Island. Hope to see some of you there! Ask me about my new startup (want an invite?) or help me fix some of the outstanding Rdoc.info bugs if you’re looking for something to do :).

The last camp in summer of 2009 was a great experience and I’ve been looking forward to a repeat. Thanks to Brian Cardarella for putting it together.

Resque Mailer

2010-01-09T00:00:00-05:00

We’ve been making heavy use of Chris Wanstrath’s Resque library in my latest project. Resque is a Redis-based background job system that Chris built for GitHub. It’s easy to use, especially if you’re already leveraging Redis in other parts of your infrastructure, and also has a nice Sinatra front-end for monitoring job status.

Anyway, Resque jobs are just Ruby classes that respond to the special perform method. They’re placed on a queue — you can place different jobs on different queues — and later, a worker polls the queue, pops the jobs off and performs the task.

We have a number of different asynchronous jobs happening in Mogo, many of which are domain-specific. But one thing we’re doing that’s very common is using the background system to process mail delivery asynchronously. Because synchronous mail delivery is for jerks.

Outgoing mail in a Rails app is generally handled by ActionMailer, which expects you to implement message delivery types as class methods on an ActionMailer “model” (a butchering of the term). So a typical mailer might look like this:

class Notifications < ActionMailer::Base

  def signup(user_id, sent_at = Time.now)
    @user = User.find(user_id)

    subject    'Welcome to Mogo'
    recipients @user.email
    from       'Mogoterra <noreply@mogoterra.com>'
    sent_on    sent_at
  end

end

Then, to send a signup message, you use the following method call from somewhere else in your codebase:

Notifications.deliver_signup(@user.id)

So this all works good but it’s synchronous. You’d like to be able to background these tasks and use Resque. But you don’t really want to mess around with the mailer implementation. Right? Me too.

So ResqueMailer does just that.

Following in the footsteps of DelayedJobMailer, ResqueMailer allows you to shift processing of your existing mailers to an async Resque worker without doing pretty much anything. Just install the gem in your Rails project (via Gemcutter) and then mix the Resque::Mailer module into your mailer.

class Notifications < ActionMailer::Base
  include Resque::Mailer

  # ...
end

You’ll need to restart your Resque workers and make sure at least one of them is working on the special mailer queue (or * for all queues). Now when you call MyMailer.deliver_signup, the task will be placed on the mailer queue and processed by the first qualifying worker.

It’s always nice when a tiny amount of code makes a task transparent. Check out the project page on GitHub for more information.

Rdoc.info Updated

2009-11-22T00:00:00-05:00

Rdoc.info is now serving up fresh docs using YARD 0.4.0. Doesn’t that new template look nice?

If you’re a Ruby OSS developer and haven’t checked out YARD yet, you really should. It’s easily the best way to generate sexy documentation for your projects and Loren has done a really awesome job with the latest release. The experimental new live docs service (with php.net-style user comments) that he’s testing out is swanky too, and we hope to roll this stuff into Rdoc.info shortly.

In the meantime, you can enjoy the latest YARD features and an updated look and feel. Make sure to add a post-commit hook to your GitHub-hosted project and we’ll automatically rebuild docs whenever you push a new release to your remote. Docs for older versions are maintained as well, and accessible via the usual commit hash url [example].

EC2 Deployment with Rubber

2009-11-17T00:00:00-05:00

At NH.rb last night I gave a talk about deploying web applications to the EC2 cloud with Rubber. Rubber is an extension to Capistrano written by Matt Conway that makes provisioning and managing multi-instance EC2 deployments magically delicious [GitHub].

Want to bring up an instant multi-role staging server fully loaded with Apache, Passenger, MySQL, and your Rails app? All gem’d up, migrated, and ready to use? Sure you do. First, sign up for an EC2 account, generate your keypair, and then…

gem install rubber

cd my-rails-project
script/generate vulcanize complete_passenger_mysql
edit config/rubber/rubber.yml

cap rubber:create_staging

It uses a Ubuntu AMI and provisions an EC2 small instance by default. If you added your account credentials and the apt packages and gems you needed to rubber.yml (and provided that there weren’t any unexpected problems), you should now have a fully functional staging server for your web app that you can visit at http://appname.your-domain.com.

Since it’s EC2 you only pay for what you use. What’s more is you can horizontally scale this out with relative ease — breaking out the individual roles to separate instances as needed — and/or add your own custom roles as needed (see the other templates available for examples).

Want to learn more? Peep my slide deck and then check out the Rubber Wiki.

Reflections on *Camp

2009-11-15T00:00:00-05:00

Last weekend I attended the first-ever New Hampshire PodCamp, organized chiefly by my friend Leslie Poston along with a crew of enthusiastic volunteer co-organizers (myself included). I only made it to the second of the two days due to prior obligations but had a good time and enjoyed meeting everyone.

If you’ve never been to a PodCamp (I hadn’t) it’s sort of like a branded BarCamp event that focuses more on how people are using technology — such as podcasting, blogging, social networks, video and music on the web — than on straight-up technical topics. I gave a presentation on Developing Twitter Micro-Apps, which I think was pretty well received.

We talked about why building apps that leverage existing social networks can be advantageous, how you can have fun with it, and how to get going really really quick with easy-to-use Ruby tools like Grackle, Rails templates, TwitterAuth (a Rails engine), Darcy’s BirdGrinder toolkit, and my own simple Retweet / Sinatra recipes. You can check out the slides if you want to learn more.

[ Note: The slides were made with slidedown. Although it’s still a little rough in places, it’s quickly becoming my favorite tool for creating slideshows in plain text. ]

That’s me looking pretty intense, live-coding some Twittery shit during the talk. Because, I’m hardcore like that. Unfortunately I didn’t have anyone record the live-coding portions of the presentation, in which we built a conversation aggregator as well as a simple faux-popularity reporting service. Ah well. Other attendees gave talks on topics as various as building interactive and community television outlets on the web, Facebook app development, film promotion, digital photography, and creating Firefox add-ons.

The event itself was held at the New Hampton school in ~~the middle of nowhere~~ New Hampton, NH, which is about an hour north of Manchester. It was quite isolated but the campus was beautiful and the solitude gave people a chance to get away from everything and kept everyone in one spot, resulting in less distractions and more focus on community. Although I really enjoy urban city-center events a lot — especially when they intelligently integrate other elements of the host city into after-hours events — there’s something really nice about isolated rural events (the first New England Railscamp was another example of this)

As someone who has never been very involved in organizing non-virtual conferences / events before, it was also interesting to observe and assist with the process of venue selection, sponsor lineup, and so on. In short: it’s a lot of work, but the payoff is great if it’s done well. Congrats and a big thank-you to Leslie (and all the other co-organizers) for putting this all together. There’s already talk of scheduling the next one for June 2010.

Notes from MIT Startup Bootcamp

2009-10-14T00:00:00-04:00

Yesterday (October 12th) I attended MIT’s Startup Bootcamp. As someone who is seriously thinking about taking some time off from his consulting lifestyle to work on bootstrapping a product, it was definitely a worthwhile event for me, and I’m glad I took good notes. I thought I’d share some of them in case you’re interested and couldn’t attend.

(If you were there, and I got something wrong or you have something else to add, please leave a comment…)

1. Adam Smith of Xobni (a Y-Combinator company). Adam was the first speaker of the day and did a nice job relating Xobni’s story. He talked at length about finding cofounders (“shake the friends tree”), their early days, angel funding, and achieving product-market fit. He stressed that being nimble is the key difference between successful and unsuccessful as a startup founder and mentioned how difficult — but necessary — it was for them to scrap an early product and change direction. “Don’t give up [on your idea],” Adam says, “90% of execution is keep going when everyone else gives up.”

2. Alexis Ohanian of Reddit (a Y-Combinator company). An energetic speaker, Alexis talked about embracing your users, and the need for evangelists to spread your message through organic traffic (“web 2.0 aka labor 2.0”). He encouraged audience members to go above and beyond when interacting with their users. Make their experience memorable, weird, fascinating, amazing, much like Zappos overdelivering (literally) on their shipping. Alexis also stressed that you need to be down-to-earth — “you don’t need to be naturally charismatic, just don’t be a dick. Be root-for-able” — both in your dealing with your users as well as with your cofounders. Most of all, do something you love.

3. Ken Zolot of MIT. Ken is the founder of MIT’s Innovations Teams program. He talked briefly about what makes interesting technology the basis of a viable company or business, and how to make that transition. Ken also stressed the importance of good communication and having tangible results to show early on.

4. Dan Theobald, Vecna. As founder of a robots company, Dan’s background was an interesting contrast to his largely web 2.0-centric peers at this event. He talked extensively about the social responsibility of a good company and incentivizing your employees. Dan is also strongly opposed to over-use of venture capital, and advised the audience to only deal with it if absolutely necessary. “Other peoples money makes you stupid,” he quipped, “avoid it at all possible”. One of the most interesting passages from Dan’s talk was about how Vecna profit shares with their employees and uses a “peer to peer” points system (employees give “cookies” to one another to reward those who are providing value) to determine distributions.

5. Kyle Vogt, Justin.tv (a Y-Combinator company). Kyle’s talk was centered around a list of “productivity hacks” but the most interesting portion of his talk was about how Justin.tv dealt with the failure of their original idea and, instead of giving up, used it as an opportunity to change direction and embrace a more mainstream approach to get to where they are today. Also, perhaps his most important advice: “stick to dot-com [domain names]”.

6. Angus Davis of Tellme. Angus, another enthusiastic speaker, related stories about Tellme’s rise and eventual acquisition by Microsoft. He also talked about his experience as an angel investor. His talk gets points for best use of technology as he employed a text messaging feedback system so audience members could tell him which vignettes they wanted to hear more about.

7. Hemant Teneja of General Catalyst Partners. Hemant, a venture capitalist with GC, talked not only about what GC looks for in prospective portfolio companies but also about what founders should look for in a VC, term sheets, and so on. An advocate of bootstrapping (is this rare for a VC?), he agreed with previous speakers that you should delay looking for VC unless you really need it, and make sure you’ve created something demonstrable and have a viable business strategy before you make that decision. What gets GC excited? Brilliant founders, solving “very hard” problems, addressing large markets, and being ahead of the curve.

8. Dharmesh Shah, Hubspot (and author of the popular On Startups blog). Dharmesh apologized to the crowd at least once for not being a professional speaker, but this seemed largely unnecessary as he had one of the more polished presentations of the day (although he did run through it a bit fast!) His talk was basically a “marketing 101” for early stage founders. “How do you get customers with $0 budget?” he asked. The answer is through inbound, not outbound, marketing; building the best experience for those who are already looking for you or the products you offer through mechanisms like search engine optimization. “Make marketing about creativity, not cash” he counseled.

9. Robin Chase of Zipcar / GoLoco. Robin talked candidly about the origin and growth of Zipcar, sustainability, and the challenges that are facing the world and environment, and how “doing good” can be a foundation for business opportunities, too. On the topic of inspiration vs execution she says that “execution is everything” and advised audience members to get started today, by building the absolute smallest thing that they can to start with. Luck is important, too, she admitted, and noted that luck happens when “preparation meets opportunity”. Be prepared!

10. Dan Bricklin, VisiCalc. Dan is an entrepreneur, programmer, and author. He created the first electronic spreadsheet application in 1979 and has been innovating ever since. Dan’s talk was a fast moving flurry of images from the early days, growth, and acquisition of VisiCalc and his company, Software Arts, and his experiences — both good and bad — as “an entrepreneur 30 years later”. His talk was refreshing and filled with humor. “You will live through things you do not expect”, Dan said as he was wrapping up.

11. Aaron Schwartz of Infogami / Reddit (a Y-Combinator company). At 14, Aaron co-authored the original RSS 1.0 specification, and has been active in the technology, entrepreneurial, and political action communities ever since. As part of the first Y-Combinator program, his company was eventually merged with Ohanian’s Redit. He talked about launching a startup and joked about what to not do (“the hollywood launch”) and what might be a better strategy (“the gmail launch”, incremental features and invitations).

12. Drew Houston, Dropbox (a Y-Combinator company). Drew’s startup, Dropbox, is now serving over 2.5 million users. Drew talked about his personal experiences from the creation of Dropbox to growing it to this point, and the challenges he faced along the way. He championed engineering-centric organizations and noted that “it’s much easier for engineers to pick up the business side than for business people to pick up the engineering side”. He also counseled the audience to “get in over their heads” and out of their comfort zones to learn things. Having friends in startups is tremendously helpful too; surround yourself with kindred spirits (which is why programs like Y-Combinator work so well).

Remote Pair Programming Resources

2009-09-15T00:00:00-04:00

I usually don’t double-post or call out the articles I write for DDJ Code Talk too much here (links are in the sidebar), but I wanted to make sure that this one got noticed.

I’ve had the good fortune lately to be working with a client who really appreciates the power of pair programming (something I’ve been admittedly a bit slow to embrace in my role as a freelancer). Since I’m only on-site with their team 2 days a week, I’ve been forced to learn a fair bit about what’s available for remote pairing tools.

Here’s the short summary: Screen + Vim + Skype is a recipe for awesome. Read the full article if you want to find out about other options.

Rumble Results

2009-09-03T00:00:00-04:00

The results are in for the 2009 Rails Rumble. Check em out and peep the winners. Some pretty impressive stuff for a single 48-hour sprint, right? Right!

I’d like to personally thank all the sponsors, expert panelists, and especially the contestants that made this years contest the best one yet. We’re looking forward to using the feedback we’ve received this year to make the next one even better, and starting to seriously discuss doing some more language/framework-agnostic events too.

But first, we need a little bit of a break :). Some downtime next weekend sure will be nice!

Rumble Build Weekend

2009-08-22T00:00:00-04:00

This weekend is Rails Rumble Build Weekend, which means that over 200 teams of 1-4 people are, at this very moment, working diligently (tirelessly!) to build the next awesome 48-hour micro-app.

This is the third year in a row we’ve run the contest and things seem to be going smoother than ever. Well, so far. Big thanks to Darcy Laycock, Erin Shine, and Jeff Rafter for being incredible co-conspirators, to all our competition sponsors, and especially to the participants who are really pouring their everything into this. I can’t wait to see how some of these ideas turn out.

In case you’re curious, we’re running the voting process a little bit differently this year, and have assembled a fine panel of expert judges to help qualify the best of the best before they go on to public voting. These people come from all corners of the web startup ecosystem and I’m really amazed that most of them were able to find the time in their busy schedules to help us out — we’re honored! So a big thanks to them, too.

The competition wraps tomorrow (Sunday) night at midnight UTC, and then the expert panelists have a couple days to work their magic. Public voting should probably open on Thursday if all goes to schedule. If you’re not competing you can still register for an account and help us judge! For more information, head on over to the competition site or check out the blog. Make sure to subscribe for updates. Thanks!

Testing ActiveRecord Observers

2009-07-25T00:00:00-04:00

Need to unit test those pesky ActiveRecord observers you’re using? I don’t use em often, but there are times when they’re definitely useful. Fortunately, since AR::Observer leverages Ruby’s Observable module all you have to do is call MyModel.delete_observers in your test setup or before block.

ZombieSighting.delete_observers

Better yet, add the exclusions to your test or spec helper file. Then you can unit test your models comfortably in isolation, and write tests for your observers that look like this:

describe Observer
  before(:each) do
    @obs = ZombieSightingObserver.instance
    @thing = Factory.build(:zombie_sighting)
  end

  it 'should generate a new notification' do
    lambda { 
      @obs.after_create(@thing)
    }.should change(Notification, :count)
  end
end

We wouldn’t want to couple zombie sightings too tightly with notifications, after all, as that might anger them even further (zombies are known to be crazy about SRP).

Rails Camp New England

2009-07-22T00:00:00-04:00

Last Friday, about 30 people descended on a large house in Bryant Pond, Maine for Rails Camp New England. Organizer Pat Allan has been running Rails Camp events in the UK and his home nation of Australia for quite some time, but this was the very first North American event (co-organized by Boston.rb’s own Brian Cardarella). Personally, I think it was a smashing success and I’m really glad I had the chance to be a part of it.

Our weekend retreat basically consisted of group hacking and pair programming, lots of lively discussions, gaming, and plenty of R&R. Frisbee was played. Food was eaten. Canoes were canoed. Urban Terror was instigated. Werewolves were slain by lakeside campfire light. Alcohol was consumed. In no particular order, of course.

In addition to the ever-important extra-curriculars, we had time to work on personal projects and share with others through a series of BarCamp-style sessions. These sessions included topics as diverse as Ruby Gems, GemCutter, Internationalization, CouchDB, and RadiantCMS. There were also a number of app demos and lots of peer consulting and mentoring going on. Experience levels ranged from complete beginners to seasoned professionals, but all egos were checked at the door and everyone seemed to get along like old friends. Social games and sessions really helped people get to know one another, and keeping the event small meant that by the time you left, everyone was on a first-name basis.

I’m not sure how (cough) productive I was over the course of the weekend, but I sure had a great time, met a lot of interesting people, and learned a lot from them. If you’ve never attended anything like this I strongly encourage you to. It’s a great mix of learning and fun, and the freestyle format allows you to make of it what you want. A far better experience than any conference I’ve attended in the past year, imo, and far less costly at a mere $120 for the entire weekend, including all lodging and food.

A big thanks to Pat and Brian for all their hard work, to Thoughtbot and ZenDesk for sponsoring, and to everyone else that showed up for being full of awesome. Hopefully we’ll do another RC New England event soon. I’m thinking that a mid-winter ski lodge excursion sounds like a damn good idea… Yeh?

TwitterAuth Integration Testing

2009-07-13T00:00:00-04:00

Michael Bleigh’s TwitterAuth gem is truly full of awesome. It’s a complete OAuth authentication and API access solution for building Twitter apps with Rails. It uses familiar conventions borrowed from the Restful Authentication plugin, too. If you’re building a Rails-based app and you want to allow your users to Sign in with Twitter there’s just no better way to go.

For this particular app, I’m using the dynamic duo of Cucumber and Webrat to whip up integration tests. Since I initially stumbled a little bit when thinking about how to test integrated authentication against an external source like Twitter, I thought I’d doc the solution here in case other people were having the same issue.

Ready? Let’s do it.

Setup

First, install the TwitterAuth gem and use the provided generator to whip up the appropriate facilities. You’ll need to register your Twitter application accounts too. Or you know what? Screw it. If you want to make this super easy on yourself, Mike wrote a really great Twitter app Rails template that does all the setup for you, including walking you through getting the dev accounts. It’s nice, try it out. You’ll be up and writing Twitter apps in no time.

For the rest of this I’m going to assume that you have all of that working, and have installed Cucumber too. Don’t have Cucumber? Install it using RubyGems and then just run script/generate cucumber inside your Rails app.

Authentication Feature

So let’s write a Cucumber feature to test authentication in our boilerplate Twitter template application. Put the following in features/authentication.feature:

Feature: Authentication
In order to create and edit games
As a user
I want to sign in with Twitter

  Scenario: Login via Twitter
    When I go to "the homepage"
    And I follow "Login via Twitter"
    And Twitter authorizes me
    Then I should see "Logged in as"

  Scenario: Checking login status
    Given I am signed in
    When I go to "the homepage"
    Then I should see "Logged in as"

  Scenario: Log out
    Given I am signed in
    When I go to "the homepage"
    And I follow "Log out"
    Then I should see "Login via Twitter"

Step Definitions

Next, you’ll need to write step definitions to satisfy the missing steps. Do that by creating a file called features/step_definitions/auth_steps.rb. The content of the file should define the following two steps:

Given /^I am signed in$/ do  
  visit login_path
  visit oauth_callback_path
end  

When /^Twitter authorizes me$/ do
  visit oauth_callback_path
end

Fake Style

The secret sauce here is FakeWeb. We’ll use it to fake out responses from the Twitter auth service so that your integration tests stay local (and reliable). Make sure to gem install fakeweb, and add the following to tests/environments/cucumber.rb:

config.gem "fakeweb", :version => ">= 1.2.5"

Now edit Cucumber’s features/support/env.rb file:

FakeWeb.allow_net_connect = false
FakeWeb.register_uri(:post, 'http://twitter.com/oauth/request_token', :body => 'oauth_token=fake&oauth_token_secret=fake')
FakeWeb.register_uri(:post, 'http://twitter.com/oauth/access_token', :body => 'oauth_token=fake&oauth_token_secret=fake')
FakeWeb.register_uri(:get, 'http://twitter.com/account/verify_credentials.json', :response => File.join(RAILS_ROOT, 'features', 'fixtures', 'verify_credentials.json'))

Here we’re stubbing out the interaction with Twitter auth, and responding to all outbound authorization attempts with canned data. Note that this references a fixture file, containing a sample verify_credentials API response from Twitter. You can obtain a copy using curl from the comfort of your terminal prompt (substitute your own username and password):

curl -i -u user:pass "http://twitter.com/account/verify_credentials.json" > verify_credentials.json

The last thing you’ll want to do is to check your twitter_auth.yml file and make sure there’s a cucumber environment defined in it. If not, you may need to add it.

And We’re Done

Alright that should do it. Go ahead and run rake features. Everything should be green. And green is good. If you need to write other features that are dependent on a login requirement, you can reuse the same “Given I am signed in” step that we created earlier.

Thanks to b.kocik, whose original post on using FakeWeb to stub Twitter auth was 80% of the solution I needed here.

Rumble Time

2009-07-07T00:00:00-04:00

We opened registration for the 2009 Rails Rumble yesterday. This is the third year in a row that we’re running the contest and it’s sure to be the best one yet. The build weekend is August 22nd-23rd but you need to register this week if you want a seat. If I were you, I’d go register now before it fills up ;-).

In other news, I’ll be presenting at the second Portsmouth Pecha-Kucha Night tomorrow, July 8th. I’ll actually be talking about the creative power of constraints, and describing our experiences organizing the Rumble will be a big part of that. If you’re in town, make sure to check it out. I’ve never done a p-k talk before but it sounds like it’s going to be a lot of fun.

The Way They Were Inside

2009-06-23T00:00:00-04:00

Last night we headed to Londonderry NH to view our submission to the 2009 48 Hour Film Project on the big screen alongside all the other New Hampshire submissions. In case you haven’t been following my tumblr (where I tend to post less techie things), I thought I’d double-post it here for your viewing pleasure:

For those of you that don’t know, the 48HFP is a filmmaking challenge to write, shoot, and edit a short 5-7 minute film in a weekend. It was also probably the biggest single influence in our putting together the Rails Rumble, which follows a similar model but is geared towards web development and tech startup bootstrapping.

It’d been a couple of years since I last participated in the project (when I was living in Boston, attempting to make bad sci-fi movies). This time around John Herman, our director, ran the project like a sea captain leading a battleship to war. It really demonstrated, to me, the power of having a consistent vision and the right people lined up to do the right jobs ahead of time. Although I’m a little bummed that I missed out on being part of the crew due to prior obligations this year, being on the brainstorming / writing team was a great experience, and I probably would have just gotten in the way during production anyway ;-).

In filmmaking as with development, constraints are a powerful thing, and the 48HFP is a real showcase of this. It also demonstrates that many of the fundamentals of the "Getting Real" philosophy can be applied equally well to all sorts of art forms and mediums. IE, don’t let time limitations or overcommitted schedules stop you from showing off your bountiful awesome.

If you’ve got a few minutes, check out www.48.tv, where you can watch a bunch of other 48HFP films — I think you’ll be impressed by the creativity in a lot of them, not to mention the production values they achieved under duress. Props to John, Dan Freund, Ryan Plaisted, Bodhipaksa, and everyone else who was involved. And thanks for letting me tag along.

Winners of the NH competition will be announced at the upcoming “Best of NH” screening, and the winner of that will move on to compete in Filmapalooza at NAB Las Vegas 2010. Many of the other films we saw last night were pretty incredible, including entries from local filmmakers like Marc Dole and Bill Rogers, so I’m not holding my breath just yet, but it certainly would be cool. Either way, the best part of these things isn’t winning, but rather seeing what you can do, and watching other people bring their A-game too. It’s inspiring.

Serious Bizness

2009-06-01T00:00:00-04:00

I’m currently available for consulting work. I took a bit of time off for some personal projects and a much-needed spring vacation and now I’m once again ready to dive into an interesting client / startup project. Are you looking for a motivated, opinionated, yet thoughtful Ruby developer who enjoys mountain biking, foreign cinema, and long walks on the beach?

Web Development: My core expertise is end-to-end web application development for Ruby, Rails, or Sinatra projects – If you’re looking for a project lead or a team to build your next big web application, I can help. Or if you need an additional hand to augment the development speed or best practices of your existing team, I’m happy to do that too.

Code Reviews: Concerned about the quality of your codebase or maybe just looking to get an outside perspective? Reviews include analysis of your code organization and structure, test coverage and effectiveness, and overall complexity / runtime efficiency.

In addition to the Ruby skill set, I’m also well-versed in JavaScript, Flash/ActionScript, social media tools, and the other standard systems and services that the web is built on. If you’ve read this blog and browsed my OSS project contributions, you already know that I’m passionate about technology, embrace web standards, and thoroughly enjoy working on innovative new ideas. I’ve also read a lot of comic books, and listen to all sorts of weird music, in case that helps.

I can provide references and an expanded portfolio by request; a rather smallish selection of work samples is currently visible on my freelance business micro-site. If you’re interested, you can get in touch via email (nap at zerosum dot org) or contact me on Twitter.

GitHub has an Apps Platform

2009-05-14T00:00:00-04:00

After I pooped out the initial version of rdoc.info a week or two ago, Jeff and I were bullshitting about the kind of stuff we could add to it when he had a bit of an epiphany: “the place for documentation about GitHub projects is on GitHub”. Yes! Of course! Why didn’t we think of that before?

So we registered the “docs” user on GitHub and went about building an extension to rdoc.info based on the GitHub pages platform. As of now, when you enter a project on rdoc.info, it’ll build docs for them locally and also generate a GitHub-themed set and push them to the docs user account pages on GitHub. In fact, you never even have to visit rdoc.info if you don’t want to (although project documentation will continue to be available there). For an example, see Nunemaker’s HTTParty API Docs. Make sure to play with the methods and namespaces buttons in the header.

As far as I know, we’re the first ones to use GitHub pages as an actual “app platform”, which makes me kind of giddy. You can read more about what we did and how we did it over on Jeff’s blog. He deserves most of the credit for this one, including that awesome GitHub YARD theme and more than a fair bit of tricksy JavaScript goodness. Of course, GitHub deserves a lot of credit too, for building an awesome and extensible service. If you run into any issues with the docs stuff (which is still kinda experimental), please report them via the GitHub project. Thanks!

Railsconf 2009 Recap

2009-05-13T00:00:00-04:00

I’m writing this from a cramped airline seat as we jet back from Las Vegas to balmy Manchester, NH (wifi on planes is awesome — thanks Southwest). Amanda and I spent a week in Vegas during which I attended Railsconf 2009 and caught a couple of pretty incredible shows. Then we road tripped it out to the Grand Canyon in Arizona and hiked in below the rim. Which was absolutely breathtaking. I wish we could have spent more time there and less in the city, to be honest.

Anyway, the conference itself had both its high and low points, but it was neither a total stinker nor an overwhelmingly fantastical experience this year. Peter Cooper, whom I had the pleasure of meeting there, has done a much better job than I of summarizing over at RubyInside. Friends Ben Scofield and Nick Quaranto also have some great notes at their respective sites. In fact, I’m going to steal Ben’s format for this post.

People

The best part of a conference is the people and the conversations, and the afterhours activities. Or at least, that’s been my experience thus far. This time around was no different. Greets to bcardadella, bphogan, brupm, bryanl, bscofield, cdwarren, croaky, cwsaylor, danabrit, davidcjames, defunkt, dpickett, erebor, fowlduck, greggpollack, graysky, jamesgolick, jeffrafter, jharuska, jimweirich, joefiorini, jnunemaker, jremsikjr, keavy, knowtheory, lazyatom, linoj, mbleigh, mojombo, patmaddox, peterc, qrush, rbates, reinh, robertdempsey, seanhussey, skizzles, solaredge, techpickles, wifelette, wycats, zachinglis and anyone else whom I might have forgotten to add to the list (sorry!). Thanks guys.

Sessions

The sessions this year were spotty, but generally I think the content was better than the previous Railsconf. I mistakingly sat through too many introductory talks and many others reported the same; everyone could benefit from session experience level labels. It’s weird that the organizers don’t do this, since they ask speakers about the experience level of their talks as part of the proposal process.

In any case, a number of the talks I saw this year stood out as being particularly great:

Jason Rudolph and Larry Karnowski on JavaScript integration testing (using the BlueRidge project)
Bryan Helmkamp’s Webrat talk
Michael Bleigh’s Twitter app development session
Blythe Dunham on her experiences integrating SMS support into Rails apps

There were a lot of talks this year about testing, cache control / optimization, and Rack / Rails Metal. As well as some useful Rails 3 speculation and discussion. All good stuff.

Interestingly, I really didn’t care for many of the (very rough) ideas expressed in Yehuda’s mountable Rails apps (Rails 3) session — in particular I really had no clue why they kept comparing Rails (a framework) to Drupal (a CMS). But, that said, the talk did do a great job stimulating discussion about alternative approaches in “CabooseConf” — apparently just a small room with, uh, tables and stuff — between myself, Bryan, Josh, Ted and others. For this reason it definitely belongs in my favorite sessions list.

[mountable app slices] are a challenging problem, and there are a lot of issues in terms of sharing application state, resolving cross-app dependencies, and so on. I hope that we’ll have an elegant solution to this soon; but I suspect that the real answer may be in making component-sized micro-apps easier to mount and integrate rather than taking an “app slices” or engines approach (if the latter case prevails, the Radiant extensions system has some stuff we can learn from).

The keynotes were mixed also

The opening DHH keynote teased us with some interesting Rails 3 info but also repeated a lot of mantras we’d heard before with the usual rallying cries
The “fireside chat” with Tim Ferriss was a bit of a disaster; although I think there were at least a few interesting nuggets in there somewhere
Chris Wanstrath’s “how to be a famous Rails developer” essay was a definite highlight; well written and thought-provoking, it should be a wakeup call to those people in the community who put personal ego before productivity and creativity
Uncle Bob was full of energy and was no doubt entertaining, but to be honest, the content was blah to say the least. More repetition of the same rah-rah we’ve had drilled into our heads for eons, without anything new. A little disappointed but almost everyone else seemed to love it
The closing Rails core panel… to be honest, I skipped it. I hear it went well, though

The Rails Rumble Panel

Speaking of panels, I think our own Rails Rumble / productivity panel went fairly well, although it was missing much of the energy present in our pre-panel planning conversations, which was really a shame. It’s doing decent in the ratings but not stellar, hovering around a 3/5. As Ben (one of our panelists) notes on his own blog, the panel format can be a difficult one to get a lot out of, and I definitely felt this myself sitting through other panels last week. However, I think the Rumble panelists did a damn good job discussing the merits of innovation competitions and relaying advice about finding teammates / cofounders, translating their entries into marketable web properties, and noting the tips, tools, and techniques that helped them excel in a severely constrained timeframe.

Overall

I had a good time, and visiting Vegas for the first time was certainly an interesting experience. I’m glad I went, and happy that we had a chance to participate. It was awesome to see (almost) everyone from the community in the flesh again, especially folks like Jeff and Ben, whom I’ve been working on side projects with on and off. It’s amazing how much easier it is to hash out ideas in person that it is over chat or phone conversations sometimes.

Will I go again next year? I don’t know. If it’s in Vegas, probably not. As much as I enjoyed seeing the sites, frankly I felt that it was a bit distracting. If the conference is in Vegas again next year, I certainly hope the organizers hold it somewhere other than the Hilton. Although it was easily accessible by monorail it’s relatively removed from the rest of the strip, and the in-venue food and entertainment options there are limited to say the least. If I’m going to be distracted, I at least want those distractions to be convenient! At least a drunk Billy Mays was there (at the Hilton, attending another convention). Maybe next year we can get him to show us how to pitch our apps to consumers during a keynote? Maybe?

Vegas Next Week

2009-05-01T00:00:00-04:00

So yeah, I’m headed off to Vegas this weekend for Railsconf 2009. It’ll be my first evar visit to that area of the country, and although it wouldn’t have been my first choice for a conference location, I’m really looking forward to it (also looking forward to a side trip to the grand canyon after the conference wraps).

I hope to see some of you there and I know that everybody says this, but if you see me in the hallways, definitely come say hi and introduce yourself. To be honest, I often feel a bit overwhelmed at conferences and the things I remember most are the people that I meet and the discussions that we have in the hallways, during hack sessions, or over dinner and beers.

While you’re there don’t forget to check out our panel presentation for the Rails Rumble on Wednesday at 4:25. If you’re going to be attending and want to record the presentation for us, please get in touch with me. You would be my personal hero. I’m looking forward to a couple sessions in particular and I’ll likely also be attending the community organizers BoF, as a way to make up for the fact that I’m missing out on the NE User Group Leader Summit tomorrow.

We’ll be staying at the Sahara during the conference and I’ll probably be checking in occasionally on BrightKite if you want to stalk me.

Rdoc.info

2009-04-29T00:00:00-04:00

For the past few months I’ve been trying to roll out a 1 or 2-day micro-app every month. Because, why not — it’s fun and refreshing. In February there was tweetdreams, March was Mogo madness (in use at offrails.org), and in April we spent a few days tossing this together.

The this that I refer to in the previous paragraph is Rdoc.info, a simple web service that generates documentation for Ruby libraries that are hosted on GitHub. You can add a new project and it’ll clone the repo from the hub of Git, use YARD to generate rdocs, and then host them for you. So you can read them. Online. Because it loves you.

If you’re the project owner, it’s even better; just add the following simple post-commit hook to your project’s settings in GitHub http://rdoc.info/projects/update and it’ll automatically regenerate documentation for you whenever you push to the remote. So yeah, unlike a random Twitter vanity application, it’s like, actually useful and stuff.

I’ve shown this to a few friends and they’ve had some good suggestions for how to make it more useful. Jeff, in particular, had some really great ideas that we’ve been looking into (more on that later, hopefully). Anyway, I’ve doc’d feature ideas in the project’s GitHub Issues list, and although we plan to get to them sooner or later, I wanted to release it first as-is, in the spirit of “release early, release often”. If you want to help out, the project has been open-sourced in the usual place.

Rumble Panel Needs Your Help!

2009-04-22T00:00:00-04:00

Railsconf is less than two weeks away. I’m pretty excited because this year we’re doing a Rails Rumble panel with a bunch of swell people who developed some pretty amazing things within the compressed event timeframe (48 hours). Winners and other innovators from both the 2007 and 2008 events will be present. The session is called “Starting Up Fast: Lessons from the Rails Rumble” and the point of it is that these guys will be sharing the tips and tricks that let them build great stuff quick with Rails. Hopefully their advice will be applicable to your own startups and hobby projects, in “real life” as well as within the innovation competition atmosphere.

So this is where we need your help. What do you want to ask them about? Project scoping for early and frequent iterations? Essential dev tools and techniques? Finding dependable partners / cofounders? General work habit questions? Inspirational mantras? Anything goes. Please submit your questions via Google Moderator. The event will be recorded and made available afterwards, so you won’t have to be in attendance to get your answers.

Why Namespaces Are Important

2009-04-17T00:00:00-04:00

Apparently both Extlib and the Mash library, which the latest version of the Twitter gem relies on, both define Mash as a top-level class. This is lame.

It means that if you’re building an app that uses the Twitter gem to poll their API, you can’t use DataMapper (which relies on Extlib) for your ORM. This is but one example of an affected application, of course (retweet stack trace). Integrity’s twitter notification support is another victim. Epic namespacing fail.

So whose fault is this? The Mash library? Extlib? Which came first? Which is more widely used? OMFG fight!

Seriously, who cares? If you’re asking yourself these questions you’re missing the point.

module Org
  module Zerosum
    module Util
      class CollisionPrevention
        def initialize
          puts "gtfo"
        end
      end
    end
  end
end

Java users, and consumers of other modern programming languages, figured out why namespacing was important a long time ago. In fact, one of the few things I actually liked from the Java world was it’s use of hierarchal domain names in packages to ensure class name uniqueness and prevent this sort of ugly namespace collision. It’s simple and effective. And yet we don’t see a strategy like this in use in Ruby gems all that often. It’s not like Ruby doesn’t provide us with a mechanism for it; Modules provide a really easy way to accomplish this. So why aren’t we taking advantage of it in our libraries?

I don’t mean to single out Extlib and Mash in my rant here – I’m just picking on them because they happen to demonstrate an obvious problem that we’ve all run into on occasion. Hell, I’m guilty of it too. Anyway, the bottom line is, that if you intend your code to be sucked into someone else’s application and reused, please do your best to prevent obvious namespace collisions. It’s as easy as A::B::C (or Tld::Domain::Feature::Specification).

Thanks for listening! :)

Getting Started with CouchDB

2009-04-06T00:00:00-04:00

I’m a little late to the party on this one, but CouchDB sure is the new hotness. We’ve been tossing around an idea for a new project and it’s a great fit for so many reasons. Schema-less? Check. Distributed and fault-tolerant? Yup. Document revision-aware? and it speaks JSON natively via a RESTful API? Oh yes. It’s easy to see why so many people are getting excited about it.

If you’re used to working with relational databases, it definitely requires a bit of mental reprogramming to really grok Couch, particularly when it comes to working with views and designing document relationships without traditional joins, etc etc. It’s powerful stuff, and after working with it just a little bit, I’m pretty enthusiastic, but still feel like I’ve got a ton to learn.

Anyway, in terms of Ruby client interfaces… there are a surprisingly large number of options that’ll make your life easier. Candidates include ActiveCouch, CouchFu, and RelaxDB. There’s also a DataMapper adapter. My personal pick would have to be jchris’s CouchRest library though. The core of it is very simple, modeled around Couch’s own couch.js library. Plus, the ExtendedDocument model stuff gives you most of what you’d want from a traditional ORM through properties, callbacks, validation mixins (lifted from DataMapper), in-line views (think of them as finder/scopes on steroids), attachments, and so on.

Before diving in too deep I figured I’d port a simple project over to Couch in order to familiarize myself with it. So I created a branch of the Retweet project that uses CouchRest instead of DataMapper. Check it out if you want to see how the CouchRest::ExtendedDocument stuff works in a simple project — only one model in this case. It’s quite nice. There’s also a CouchDB branch of sinatra-template, if you wanna use that to bootstrap your own ideas.

Btw, if you’re on a Mac, and using MacPorts, make sure to port selfupdate to the latest and greatest and then port install couchdb-devel to fetch CouchDB 0.9.0. Anything older than that won’t work with CouchRest.

New Biz Cards

2009-04-03T00:00:00-04:00

So what do you think?

Btw, it’s true about the sci-fi gadgets — they’re made to order :). I’m also available to build web applications, of course. Probably a better investment.

And yes, the Nth Metal (consulting business) site needs a bit of a makeover. All in due time.

Hello Mogo

2009-04-01T00:00:00-04:00

“In brightest day, in blackest night, no feed shall escape my sight!”

MogoFeed is a small planet-style feed aggregator built on top of Sinatra, leveraging DataMapper and Paul Dix’s supa-fast Feedzirra library for the actual feed processing. It also teams up nicely with [the all-knowing, all-powerful] Sphinx, making feed search a breeze. There’s a working example of Mogo in action installed here.

Source is available on GitHub so feel free to fork away if you’re in need of such a thing. Patches and pull requests happily accepted.

Sinatra Isn't Pushy

2009-03-22T00:00:00-04:00

I gave a hands-on introductory talk about Sinatra at last weeks NH.rb meetup. In case anyone is interested, I’m also embedding the slides below. Looks like scribd butchered them a little bit, but you can always download the original set in PPT format or whatever too (follow the link).

As you might expect, my presentation includes a number of borderline awful puns. Probably not as bad as the puns in a typical Git presentation, but still. You have been warned.

A Quick Introduction to Sinatra (NH Ruby) A Quick Introduction to Sinatra (NH Ruby) zapnap

A full meetup report is available as well. You can find the full source for the sample door prize chooser app that we live-coded during the presentation via GitHub.

Design Refresh

2009-03-21T00:00:00-04:00

It was about time, I guess. This blog had been in need of a facelift for many many moons. Anyway, let me know what you think. It’s rocking a tweaked-out version of the classic cutline theme that I ported to Mephisto/Liquid with some supernatural green custom goodness. The banner image is a photo of some awesome graffiti I found in a bathroom in a Burlington VT bar last October. I know how that guy feels.

I also pooped out a tiny personal microsite earlier this week, which you can find over at nickplante.info if you’d like to stalk me further. Eye-burning green highlights ftw.

Rumble Panel At Railsconf

2009-03-01T00:00:00-05:00

I’m happy to report that our panel, Starting Up Fast: Lessons from the Rails Rumble, has been accepted for the 4th annual Railsconf event in Las Vegas.

I’ll be moderating a panel of competition winners and participants, and we’ll be discussing how they were able to achieve some impressive feats in the compressed contest timeframe. It should be packed full of useful real-world advice on how to organize and launch Rails applications quickly. We’ll also talk about the event itself, and the nature of innovation competitions in general (and why you should get involved!) I guarantee that it will be fun, but I can make no guarantee about whether or not there will be choreographed mock-fighting. That’s up to you.

Panelists include our friends Joe Fiorini (grand prize winner 2008), Josh Owens (grand prizer winner 2007, design award 2008), Ben Scofield (winner, solo division for both 2007 and 2008), James Golick (winner, most useful 2008), and Darcy Laycock, who participated in the 2007 contest and joined the organizational team for the 2008 event.

So if you’re making the voyage to the City of Sin in May, make sure to check us out. I’m excited, and it’ll be great to meet many of you there! Also, you can teach me how to gamble. I hear that I have a pretty bad tell. Whatever that is.

UPDATE 3/16: The panel is scheduled for May 6th from 4:25pm to 5:15pm PDT in Pavilion 9 – 10

Micro App: Tweet Dreams

2009-02-04T00:00:00-05:00

I was feeling kind of meh last week, so I decided I’d take a day off from the paid projects and hack out an ‘app-in-a-day’ microapp. If you know me, you know that this is something I talk about doing all the time and publicly advocate, but rarely find the time to actually execute on ;-). I’d really like to change that, and devote more time to my own projects this year.

Of course, the hardest part about doing this sort of thing is coming up with a concept that can be created and deployed within the timeframe you have available. For the Rumble, we gave teams of 4 people 2 full days, and lots of prep time. But in this case I wanted to see what I could do with a designer in, say, an afternoon, without any advance planning at all. Just for fun. So I chatted up my designer friend Ty and we came up with the concept of a really simple Twitter-based dream journal, that would display random tweets that had to do with what people were dreaming about. Nothing fancy, sort of a rip off of OhMyScience but without the science. Because who needs science, right?

Ty whipped up a fun single page Goodnight-Moon-inspired design and I wrote a tiny amount of code to morph my Sinatra app template into a Twitter keyword aggregator, and about 3 hours later tweetdreams.org was ready to go. It may not be the most innovative or featureful website you’ve seen this week, but it’s cute and was fun to build and a few people have said some nice things about it. Frankly, that’s enough for me.

The moral of the story is that you don’t have to do something earth-shattering, massive, or insanely innovative to enjoy doing it. If you’re feeling kind of down or like your current work projects are neverenders, block out a day and bang out a microapp. Just shipping something will often make you feel better about yourself, regardless of the complexity involved. Don’t be afraid to call it ‘v1.0’ and move on to the next one. On the web, nothing is every finished. And that’s a good thing.

So yeah, check it out if you’re interested. The sub-100 lines of source, sans Ty’s awesome theme, is also up on teh GitHubs if you wanna make your own Twitter-fueled microapp.

The Way You Wear Your Hat

2009-01-23T00:00:00-05:00

So the Sinatra guys just kicked out v0.9. Classy and well-dressed, as always. If you haven’t played around with Sinatra before, you should really give it a look. It’s often everything I need for building lightweight micro-apps. Very easy to learn and use, too.

Of course, Sinatra is intentionally quite small and doesn’t dictate what testing framework, ORM, or templating language you use. Having choices is great, but using a common set of tools with Sinatra can also cut down on initial configuration time and make it even more appealing for quick tasks.

Personally I’ve found that my own ideal application template consists of RSpec, Haml, DataMapper, and a few bits of well-placed glue. If you want to give Sinatra a spin, and just want some sensible defaults baked-in from the get-go, check out the application template that I pushed to GitHub earlier today. It should help get you up and running fast. And it might make pancakes for you too (but probably not).

Just fork the repository, rename it, and start writing specs and code. When you’re done, use the included Rackup script to deploy it via Passenger. Couldn’t be easier. If you have any criticisms, suggestions, or improvements, let me know. Or hey, just send a pull request.

Thanks to Ryan Tomayko, Blake Mizerany, and the rest of the Sinatra team for creating such a fun (and truly minimalist) web framework.

New Radiant Extensions

2009-01-13T00:00:00-05:00

We launched a new Radiant-based site for a client last month. It was a small project but involved the creation of a couple new extensions, so I thought I’d take the opportunity to OSS them. In case anyone is interested…

Flash Gallery Extension — An extension that works with Todd Domineyâ€™s excellent SlideShowPro (SSP) Flash component to easily create elegant Flash-based media galleries within Radiant (Note that SSP is a commercial product; however a trial version is available suitable for testing this extension).
Upcoming Events Extension — An uber-simple extension that allows creation and management of important dates within a Radiant CMS instance.

That is all.

NHRuby & the Importance of User Groups

2008-12-27T00:00:00-05:00

There are some changes in store for NHRuby in 2009. Group founder Scott Garman is headed out to the west coast and is therefore stepping down as coordinator, and I’ll be stepping in to fill the void. Over the past 2 years Scott has done a great job getting things started and lining up interesting content. I hope we can keep the momentum going in his absence!

Meetings will continue to be held at RMC Research in Portsmouth (directions), but the dates will shift slightly; from this point forward we’ll be meeting on the third Thursday of the month. We’ve also set up new mailing lists and a new website to document group activities and associated shenanigans. I’ll be migrating more archival material over from the wiki shortly.

The 2009 event calendar kicks off to a great start with a talk by Jon Linowes on January 15th. He’ll be speaking about ReviewRamp, his Rails-based startup, Cucumber integration testing, and his own DynamicRecord framework. If you’re in the southern Maine, New Hampshire, or northern Massachusetts area I really encourage you to come out and hang with us. We’re a small, friendly group, and new people of all skill levels are always welcome.

Never been to your local user group? You’re really missing out. Attending them is a great way to learn firsthand about new ideas and technologies from passionate people who actually give a shit. It’s also a great way to network and find other folks to bounce ideas off of or work on projects with you. The Internet is a great place to meet people too, of course, but there’s just something special about meeting someone in person, being able to pop your hand up in the middle of a talk to get clarification, or grabbing a beer or two after an inspiring discussion. Also, it’s easier to tell if they’re trying to manipulate you into sending them money. If you haven’t yet attended your local user group(s), make it part of your new years resolution to change that.

And if your area doesn’t have a user group? Then start one. You might be surprised at who shows up.

Merb 2 == Rails 3

2008-12-23T00:00:00-05:00

Wow. Well, this is… somewhat unexpected. And very, very cool.

No kidding, right? Personally, I’m excited. I think the Merb 2 / Rails 3 announcement makes a ton of sense (read the links above for details); Rails with a modular Merb-like architecture and a set of reasonable Rails-ish defaults is an epic win for both camps, if done right. It’s truly an exciting time to be a Ruby developer. Happy holidays everyone.

Why I Love Vim

2008-12-07T00:00:00-05:00

Back when I was a Java developer, I knew and really liked me some IntelliJ. Later, when I moved over to Ruby full time, NetBeans seemed like a damn good choice. After all, I was used to having a “proper” IDE, it had pretty nice Ruby support and also, much to my joy, it had a Vim plugin, which allowed me to use my favorite editor from my pre-IntelliJ days. Win.

Fast forward to about six months ago when I decided that I’d ceased to care about heavyweight IDEs. I just didn’t use enough of their features to make their overall (often cumbersome) weight and memory footprint worthwhile. So goodbye NetBeans with Vim plugin and hello Vim. MacVim, specifically.

Why Vim? Because Vim is universal. Because Vim is love.

Dave Thomas and Andy Hunt famously wrote “Choose an editor, know it thoroughly, and use it for all editing tasks” in their seminal masterpiece, The Pragmatic Programmer. I couldn’t agree more. There is no tool in a programmer’s toolbox more important than an editor, and the importance of knowing it inside and out cannot be understated. For me, ever since college, that editor has always been Vim. It was just everywhere that I needed it to be. It was ubiquitous. I could use Vim at home on my desktop, at school, at work in the campus NOC, at the CS lab, and in any number of remote shell sessions, on even the most obscure platforms. One ring to rule them all.

Vim is also small, and quick. Once you know what you’re doing, it’s quicker and easier to manipulate text in Vim than any other editor that I’m aware of. Of course, the learning curve is steep, relative to other editors. But it’s worth it. When I’m writing code, switching between files, replacing text, et al, I don’t want to have to use the mouse too frequently. Vim, in all of it’s keyboard-centric glory, delivers. MacVim also provides awesome mouse highlighting and menu option support, for the best of both worlds.

There’s also massive value in Vim’s powerful plugins system. Without some of these awesome third party extensions folks have developed for Vim, it wouldn’t be nearly as appealing as a desktop code editor. But by adding plugins like NERDTree, rails.vim, vcscommand.vim, and FuzzyFinder, it becomes a full-fledged programmers editor for me, something that easily outguns TextMate, NetBeans, Komodo, and all the other would-be competitors. Customize it to your hearts content.

Anyway, I just wanted to put that out there. Vim rules. And Tim Pope, author of rails.vim, rules too (even though he looks awful in drag). His plugin, along with NERDTree, vastly simplifies my day to day editing tasks, and reproduces all the functionality I would have actually used from a more fully-featured IDE. Thanks guys. You’re my heroes.

For more information on using Vim as a Ruby developer, see Jamis Buck’s post from a few months back about switching back to Vim from TextMate. It’s a well-written argument, but the really amazing thing about the article is the number of comments it generated. It’s great to see so much love for such a great editor and I’m glad to be in such good company.

So, what’s your favorite go-to editor? If it’s Vim, I’d be curious to know what plugins you’re using and how you’ve customized it.

PS If you’re also a MacVim user, make sure you install the :Bclose script too!

Demystifying Rails Plugin Development

2008-11-18T00:00:00-05:00

My slides from the Voices that Matter (Pro Ruby 2008) conference…

Demystifying Rails Plugin Development

Thanks to everyone who attended and of course to the organizers for putting together a great conference.

Vote Or Die

2008-10-26T00:00:00-04:00

OK, I’m being a bit overly dramatic. But seriously, go sign up to judge and vote in the 2008 Rails Rumble. Help us decide which of the amazing web applications featured on our leaderboard deserves to take home the goods. Oh, and tell your friends. The more opinions the better.

If you need extra motivation, we’re giving away a number of Amazon gift certificates to random voters. There’s still time, but hurry up; voting ends November 1st.

While we’re on the subject, there’s also another important election coming up too ;-). I’m not going to pretend to tell you who to vote for, but (if you’re a US citizen) just make sure you understand the issues at stake and vote responsibly. Thanks!

OpenID, Simplified

2008-10-11T00:00:00-04:00

The build portion of the Rails Rumble is next weekend. Wow, time really flies, eh? It seems like it’s only been a few weeks since we announced it. We filled all 200 seats this year and even had to open up a few more. I’m really amped, and am looking forward to seeing some truly amazing microapps come out of this weekend sprint. I think they’re going to be even better than last years’. I hope you’ll help prove me right.

Anyway, I posted earlier today over on the Rumble blog about our decision to mandate OpenID usage in the registration (and voting) app and JanRain‘s involvement in the Rumble as a sponsor. We’re using their new OPX ASP service to provide branded railsrumble.com OpenIDs to users who don’t have them. It’s pretty great. We really didn’t want to run our own provider and then be saddled with the upkeep of it. It makes much more sense to delegate that to a third party who is an expert in that realm.

Personally I think OpenID is, for the most part, pretty swank. Yes, it has its flaws. And maybe it isn’t a proper fit for every application. But for an event of this sort, a decentralized identity / login system is absolutely critical. It would be silly to force users to create dozens of different accounts (all with different login names, password criteria, etc) just to evaluate new applications.

I’m both excited and relieved that providing OpenID registration services is becoming easier and easier. It’s really about time and SaaS OpenID facilities makes a ton of sense for sites, like us, that want the benefits of providing OpenID without the hassle of operating and maintaining it long-term.

I expect a lot of competitors this year to use Jim Neath’s Bort or a similar blank slate Rails application to bootstrap their development. This is a good thing and it doesn’t void the rules in any shape or form as long as the kit is just bundling plugins and not providing major application functionality in and of itself (like Radiant or Spree does). One of the best things about Bort is that it supports OpenID right out of the box, in addition to stock Restful Authentication style user accounts. Epic win for you. And your users.

If you aren’t using Bort or something similar, you may want to check out our OpenID Simplified plugin, which was extracted from the Rumble voting app itself. It’s a combination of the classic OpenID Authentication plugin with some bits from Restful Auth, and a few extras to make adding OpenID-based user accounts to your application dead simple. What it doesn’t do, however, is provide non-OpenID-enabled account creation.

“Wait, what? You can’t create accounts with it?,” you ask, “What were you thinking?”

First of all, yes, you’re right. OpenID isn’t ubiquitous yet. And maybe it never will be. But it’s certainly better (at least imo) than creating yet another user account with yet another set of credentials (or worse yet, the same set). Options like the free MyOpenID affiliate program and JanRain’s branded OPX service make it just as easy to have users proxy-register with them as it is to create a one-off local user account. By signing up with one of these services you can provide your own logo and copy and have the logged-in user directed back to your site, once they complete the signup process.

Also, by integrating the ID Selector widget, many of your users even realize that they actually already have an OpenID account – via Flickr, Blogger, Wordpress, etc – and therefore bypass this unnecessary registration situation altogether.

My point is that, although it may not yet be perfect, we’re getting to the point with OpenID services where adding support for them is almost as straightforward as implementing our own local accounts system. Many of your users will already have an OpenID account. Sometimes they just need to be made aware of it. For those who don’t, it’s becoming easier and easier to allow them to create an account that they can use anywhere, without placing the burden for maintenance of that on yourself.

Testing Workling with RSpec

2008-10-04T00:00:00-04:00

Workling is my current sauce of choice for interfacing with message queues and performing asynchronous background tasks in Rails apps. We’re using it in production in a couple of places (with Starling) and it works great. In fact, we liked it so much that we wrote about it in Practical Rails Plugins.

Anyway, one thing we didn’t discuss there was how to test your workers. I’m an RSpec junkie, and I want to make sure that my Workers are behaving the way that I expect at all times. The solution is pretty simple. I modified a code snippet written a while back by David Altenburg to spec his BackgroundRB workers…

Just add the following to your spec/spec_helper.rb:

module Workling
  class Base
    class RailsBase
      def self.register; end
    end
  end
end

worker_path = File.dirname(__FILE__) + "/../app/workers"
spec_files = Dir.entries(worker_path).select {|x| /\.rb\z/ =~ x}
spec_files -= [ File.basename(__FILE__) ]
spec_files.each { |path| require(File.join(worker_path, path)) }

Now you can add specs for your workers to spec/workers/my_worker_spec.rb:

require File.dirname(__FILE__) + '/../spec_helper'

describe MyWorker do
  it "should manufacture a new widget at the happy castle widget foundry" do
    Widget.should_receive(:find).with(1).and_return(@widget = mock_model(Widget))
    @widget.should_receive(:manufacture)
    MyWorker.asynch_manufacture_widget(:widget_id => 1)
  end
end

Register for the Rails Rumble!

2008-09-29T00:00:00-04:00

Registration for the 2008 Rails Rumble opened last Friday. If you haven’t already registered and want to compete, you better hurry up. There are only 25 seats remaining (out of a maximum of 200!) at the time of this writing. I’m guessing those will be gone very, very soon.

We’ve been working hard to make this years competition even better than last year and I think everyone is going to have a lot of fun. In addition to all the great prizes that sponsors are putting on the table, and the insane amount of community goodwill surrounding the event, there are also a number of companies running workshare programs. If you’re a fan of the coworking concept you may want to check these out. I know I’m wishing there was one in my town.

On the other hand, if you’re geographically isolated from the rest of the Ruby world, don’t despair! It’s a virtual competition and you can compete from anywhere. Look at it as a great opportunity to assemble a distributed team of entrepreneurially-minded developers and designers and see how well you can work with each other. If you’re looking for people or ideas, make sure to check out the #railsrumble channel on the Freenode IRC network or post to the blog.

Upcoming Speaking Gigs

2008-09-15T00:00:00-04:00

I’ve firmed up a few speaking gigs for the next couple months. And I wanted to share.

First of all, tomorrow night, September 16th, I’ll be presenting a “casual intro” to every-day Git usage at NH.rb. Brian Turnbull and Scott Garman will also be presenting, on HTTP and Rails deployment stacks, respectively.

If you live in the ME/NH/Northern MA area and are interested in Ruby, I really encourage you to come to these meetings. They’re a great way to meet other local developers and learn about new cutting edge topics. If you can’t make this one, the next one is scheduled for October 21st (they’re always on the third Tuesday of the month). I’m scheduled to speak at that one, too. Topic is currently TBD but I’m sure we’ll come up with something fun.

Meeting other Rubyists and learning about hot new tech isn’t enough of a reward in and of itself? Well, there’s free swag too. This month we’ll be giving away a few copies of my new book, Practical Rails Plugins along with some other Apress goodies (thanks Apress!).

NH.rb is also giving way a free core conference pass to the upcoming Voices That Matter: Professional Ruby Conference (Boston, November 17-20). Pretty great, right? Sounds like this is going to be a great conference and they have a bunch of top notch speakers lined up. I’ll be there too (how was that for a segue?), speaking about Rails Plugin development strategies on the first day of the event. Hope to see you there!

jQueryConf 2008 Agenda

2008-09-01T00:00:00-04:00

The JQuery team just announced the agenda for JQueryConf 2008 and it looks pretty solid! I’m happy that I registered early, as it appears to have sold out.

Last year’s “camp” was great and I’m sure this year will be even better, with two tracks to cater to both beginning and advanced developers. The only item from my wish list that’s missing from the agenda is unit testing JQuery client code (and plugins). Oh well! If you’re interested in this topic, Chad Meyers just wrote up a great intro to using JQuery’s very own QUnit testrunner over on his blog. Good stuff!

Update 9/29: I posted a summary of conference highlights over at DDJ Code Talk.

2008 Rails Rumble Kickoff

2008-08-26T00:00:00-04:00

We just set up the new blog site for the 2008 Rails Rumble contest. This year the event will be held the weekend of October 18th. Registration should open within the next couple weeks. That is to say, we’re working on it. Read the faq ’n rules for more info.

Greets to co-organizers Darcy, Erin, Carter, Brian, and Rodrigo.

Practical Rails Plugins

2008-08-23T00:00:00-04:00

Hey wow, author copies of my book just showed up yesterday. That’s pretty cool. My side of things has been finished for a few months now, but it’s nice to finally see it in print!

The book, Practical Rails Plugins (Apress 2008), is aimed at the beginning to intermediate Rails developer, featuring a number of recipes for using popular third party plugins in Rails projects. So it’s sort of a recipes book but with a focus on leveraging plugins to accelerate feature development, and on standalone mini-projects rather than code snippets, which I think is much more illustrative for developers who are new to the framework. Topics include video transcoding and asynchronous processing, state machine modeling, payment processing, geocoding, full text search, testing and a whole lot more.

I wrote about 50% of the content, David Berube (author of Practical Ruby Gems and Practical Reporting with Ruby and Rails) is responsible for the rest. If you want to pick up a copy, you can order it via Amazon. We also put up a companion site for the book last week, if you wanna check it out.

Razume in the News

2008-08-06T00:00:00-04:00

Just wanted to take a quick moment to call attention to this TechCrunch article which announces the unveiling of LaunchBox Digital’s first nine startups.

My favorite of the group is Razume, a collaborative resume review service. But hey, I’m a little biased — we know those guys! For the past couple months, we’ve had the pleasure of helping them develop their Rails-based online resume building tools, document management, and peer review features. It’s been a fun ride and it’s great to see them finally launched and seeing some much deserved attention.

In any case, congratulations to Sam, Brian, and the rest of the team on the formal launch. Razume is sure to be an indispensable resource for recent college grads, connecting them with professional resume experts and like minded job seekers. Rock on, Wayne.

Debugging ActionScript in the Browser

2008-07-31T00:00:00-04:00

Alright, so the dirty truth of it is that I used to do a fair bit of Flash / ActionScript work. No, I’m not ashamed. Flash can be a real pain in the ass but I really do enjoy using it for tasks like interactive widgets and media playback. And it’s a fantastic tool for information visualization (I wrote a Carnivore client library for AS 2.0 way back in the day). I’ve been more focused on Ruby work these days, but from time to time I still dabble and do the occasional bit of Flash work for a badass creative agency.

In any case, if you’re developing applications or widgets for browser-based deployment with Flash, you’ve doubtlessly noticed that certain things just don’t work the same way in the ‘Test Movie’ facility as they do in the browser (cough cough MovieClipLoader cough). Fortunately, there’s a way to see your trace() logger messages in a live browser session, too.

First, you need to download and install a debug version of the Flash Player in Firefox. Next, install Alessandro Crugnola’s Flash Tracer plugin. An older version for FF2 is available at the Firefox addons site, so make sure to snag the one from the link in this article if you’re using Firefox 3.

After restarting the browser, you can select ‘Flash Tracer’ from the Tools menu and it’ll pop up a sidebar that will contain any logger ouput in currently loaded SWFs. Make sure to adjust your preferences to specify the log file location and max lines of history to maintain. It’s really an invaluable tool for when Test Movie just ain’t cuttin it. Thanks Alessandro!

NH Merb

2008-07-13T00:00:00-04:00

This Tuesday (July 15th), NH Ruby morphs into NH Merb for the night! Guest speaker Jeremy Durham is coming up from Boston to give a talk about his journey converting an existing Rails app to Merb. Should be good stuff, especially for those of you who are curious about Merb and how it might be of benefit to you as a Rails alternative.

If you’re in the seacoast area, make sure to stop by. As always, more details and directions on the wiki.

Passenger <3 Sinatra

2008-07-04T00:00:00-04:00

A couple people have asked me how I’m hosting the Sinatra-based pastie service we wrote in yesterday’s revised tutorial. The previous version ran on a mongrel handler frontended by nginx, but for this version I decided to try something a little different.

One of the big announcements at Railsconf last month was that Passenger (aka mod_rails) would be releasing a v2.0 with support not only for Rails applications but also for Rack, meaning that any Rack-based Ruby web framework can also run on it. Yay for deployment options, right? So anyway, I figured we’d give that a shot.

For those of you who haven’t yet mucked with it, Passenger is dead simple to setup. Run gem install passenger to pull down the gem, and execute the passenger-install-apache2-module command to build and install the Apache 2.2 module (you’ll need the proper Apache libraries to be present of course). The command output will show you how to configure Apache to load the module.

Getting Passenger to run a Sinatra-based application also turned out to be remarkably easy. All you need to do is create a regular old Rackup script. The file will need to be named config.ru and should contain all the logic necessary to initialize our app:

require 'rubygems'
require 'sinatra'

Sinatra::Application.default_options.merge!(
  :run => false,
  :env => ENV['RACK_ENV']
)

require 'toopaste'
run Sinatra.application

Place this file in the folder on your server where toopaste.rb and the views directory reside.

Next, create a public directory. This is where any static images, JavaScripts, or stylesheets would be kept (we’re not using any, in this simple example). Point your vhost’s DocumentRoot here:

<VirtualHost *:80>
  ServerName paste.zerosum.org
  DocumentRoot /var/www/apps/toopaste/public
  ...
</VirtualHost>

You might as well create a tmp directory too. You can place a restart.txt file in this directory to tell Passenger it needs to reload the app without restarting Apache (you can use this in your cap restart tasks, too).

Couldn’t be much easier. For more information on deploying other Rack-based frameworks (Merb, Camping, Ramaze, etc) and various other config options, check Passenger’s user guide.

Clone Pastie with Sinatra & DataMapper 0.9

2008-07-02T00:00:00-04:00

Waaaay back in November I wrote a DataMapper and Sinatra tutorial. DM was still pretty immature at the time, and it quickly became outdated. I promised I’d update it once 0.9 was released.

Better late than never, right? Anyway, without further ado, here’s Toopaste Tutorial 2.0:

What We’re Building

Today we’re going to learn how to write a dirt simple pastie clone using Sinatra and Datamapper. For those of you unfamiliar with pastie systems, they’re commonly used in IRC to paste bits of code to a globally-visible place outside of the channel. So you copy some code from your IDE, paste it into a web page, submit it, and the Pastie system fancies it up with some syntax highlighting or whatnot. You can then copy the resultant URL and paste it back into the channel so other people can view it.

The interesting thing isn’t the application we’re going to build here so much as it is the tools we’ll use. That is, we’ll be using the pastie example to introduce you to two cool new pieces of Ruby tech: Sinatra, a Ruby web micro-framework, and the DataMapper ORM package.

Sinatra

Sinatra, on the surface, is a lot like Camping, another Ruby web all-in-one-file micro-framework. Camping hasn’t seen much active development lately though, and the syntax can be a bit strange for new users. Sinatra is much more straight-forward and accessible. It’s really a kind of domain-specific language for writing simple web applications, used to define RESTful actions and how they should be handled. This makes it perfect for lightweight mini-apps. It’s also ORM-agnostic, instead of being married to ActiveRecord like both Rails and Camping are.

Sinatra has been making cameo appearances supporting a number of high-profile Ruby-based web apps, including Heroku and GitHub. It runs on top of Rack, which means that it plays nice with a wide variety of Ruby web app servers, including Mongrel, Thin, and Ebb. It also means that you can host your Sinatra applications easily with Apache and Phusion Passenger, as of Passenger 2.0. For more information, check out the ‘official’ Sinatra tutorial (oops dead link). There’s also an open source Sinatra book in the works.

DataMapper

There are a number of reasons why I prefer this approach, but that’s fodder for an entirely separate blog post, so I won’t get into it here. Besides, the team has already written a great summary of why DataMapper rocks. Read it. It’s good stuff. Oh, and performance kicks ass too.

Take that, non-believers!

Prerequisites

OK, anyway. Tutorial time. Found your plastic hat? Good. Let’s go. First let’s get the gems we’ll need. As of this writing, DM is at v0.9.2 and Sinatra is at v0.2.2. We’re also going to retrieve the Syntaxi gem, which we’ll use for syntax highlighting.

sudo gem install sinatra data_mapper syntaxi

The data_mapper gem is a “meta gem” that includes the most commonly used gems from dm-core, dm-more, and others. We’ll be using a couple of these additional libraries — dm-timestamps and dm-validations — in this tutorial.

Since DM uses the DataObjects.rb (DO) drivers, you’ll want to install them too. For this tutorial we’ll be using Sqlite3 as a data store. If you want to use MySQL or Postgres or any other database supported by DO, well that’s cool too (just make sure to get do\_mysql or do\_postgres).

sudo gem install data_objects do_sqlite3

The Code

Now that our prerequisites are satisfied, let’s get started by creating the file toopaste.rb:

require 'sinatra'
require 'dm-core'
require 'dm-validations'
require 'dm-timestamps'
require 'syntaxi'

DataMapper.setup(:default, "sqlite3://#{Dir.pwd}/toopaste.sqlite3")

class Snippet
  include DataMapper::Resource

  property :id,         Integer, :serial => true    # primary serial key
  property :body,       Text,    :nullable => false # cannot be null
  property :created_at, DateTime
  property :updated_at, DateTime

  # validates_present :body
  # validates_length :body, :minimum => 1

  Syntaxi.line_number_method = 'floating'
  Syntaxi.wrap_at_column = 80

  def formatted_body
    replacer = Time.now.strftime('[code-%d]')
    html = Syntaxi.new("[code lang='ruby']#{self.body.gsub('[/code]', replacer)}[/code]").process
    "<div class=\"syntax syntax_ruby\">#{html.gsub(replacer, '[/code]')}</div>"
  end
end

DataMapper.auto_upgrade!

# new
get '/' do
  erb :new
end

# create
post '/' do
  @snippet = Snippet.new(:body => params[:snippet_body])
  if @snippet.save
    redirect "/#{@snippet.id}"
  else
    redirect '/'
  end
end

# show
get '/:id' do
  @snippet = Snippet.get(params[:id])
  if @snippet
    erb :show
  else
    redirect '/'
  end
end

Next we’ll dissect this code listing to give you a brief look at how DataMapper and Sinatra work. We’ll show the code listings for our views as we get to them.

Code Analysis: DataMapper

The first couple lines require the libraries we’ll be using in this example. dm-core represents the DataMapper core libraries, and dm-validations and dm-timestamps both add extra bits of non-core functionality to DataMapper. In this case, requiring timestamps means that fields such as created\_at and updated\_at automatically get branded with the current Date/Time when a model is created or updated. As for validations, well we’ll see them in use shortly.

Before we create out first DataMapper-backed model we have to set up the database. The following line sets the default database connection and tells it to use the Sqlite3 file-based database in the current working directory. It won’t exist yet but don’t worry, we’ll be creating it automatically when we migrate.

DataMapper.setup(:default, "sqlite3://#{Dir.pwd}/toopaste.sqlite3")

Persistent Models and Properties

Next we define our model, Snippet. Since we want to persist snippets, we include the DataMapper::Resource module in the class definition. From an end user point of view this is the same as inheriting from ActiveRecord::Base in Active Record. It’s a nice bonus that we don’t have to use inheritance to accomplish this any more.

include DataMapper::Resource

The property declarations in our model are DataMapper’s way of specifying attributes, which translate to database table columns. This might look a little bit odd at first if you’re coming over from Active Record…

“OMG I don’t have to put comments in my source file to remind me what attributes are available on my models?!”

It’s like a little slice of heaven, isn’t it?

property :id,         Integer, :serial => true    # primary serial key
property :body,       Text,    :nullable => false # cannot be null
property :created_at, DateTime
property :updated_at, DateTime

The only two required parameters are the name of the property and the type, but you can also add other options to mark a property as the primary serial key, prevent it from being null, and so on. Properties get public accessors by default, but you can modify that by setting the :accessor option to :private or :protected (:reader and :writer options are also supported for even more control).

Another interesting DM optimization worth noting: by default, the text field (body) is lazily loaded. Text columns are expensive in databases, and by using lazy loading, we only access them when they’re needed. This speeds things up significantly in most cases. However, if you don’t want to do this for whatever reason, you can just pass a :lazy => false option in the text column property declaration.

Validation

The validators we’re specifying should look relatively familiar to anyone familiar with AR. They’re only available to us because we required the dm-validations library, as mentioned. This is part of DM’s Merb-like minimalist approach; start with just the bare essentials, and allow developers to mix in extra functionality as its desired. The kitchen sink is so fail, right?

# validates_present :body
# validates_length :body, :minimum => 1

So why are these lines commented out then, you ask?

Well, we could explicitly add the validates_present :body to specify that the body property must be present, but that’s already handled for us in the property declaration since we specified :nullable => false. If dm-validations is not required, the nullable option will simply ensure that the database column isn’t null, but if validations are in use it will augment this behavior to assume that we not only mean ‘not null’, but also ‘not empty’.

Likewise, validates_length could be useful in certain situations, but in our case we just want to make sure that the paste body isn’t empty, which is already handled for us by the nullable option on the body property.

There are lots of other validations that we can add in this manner, of course. For more information see the DataMapper API documentation.

Syntax Highlighting with Syntaxi

The only custom method we’ve added to our model, formatted_body, is pretty straightforward. It just takes the body of our snippet (a property on the model) and wraps it in some code that gives us pretty syntax highlighting and line numbering. Syntaxi leverages Jamis Buck’s Syntax gem to mark up the specified code, wrapping CSS span tags around things that should be colored, adding line numbers, and some other goodies too — you’ll see the CSS in our layout shortly.

def formatted_body
  replacer = Time.now.strftime('[code-%d]')
  html = Syntaxi.new("[code lang='ruby']#{self.body.gsub('[/code]', replacer)}[/code]").process
  "<div class=\"syntax syntax_ruby\">#{html.gsub(replacer, '[/code]')}</div>"
end

The replacer stuff just keeps us from stumbling on syntax coloring markup in our output HTML.

Auto-Migrations

Now that we’re done defining our database-backed model, we’re just about ready to move on to the web-serving portion of the tutorial. But first, we need to tell DataMapper to create the appropriate database table if it doesn’t already exist. We do this by using the DataMapper.auto\_upgrade! method, which checks to see if the database table that corresponds to our model(s) need upgrading and then creates or updates them as appropriate. It’s a non-destructive way to do auto-migrations (the destructive equivalent is auto\_migrate!)

Code Analysis: Sinatra

Moving on to the Sinatra portion of our tutorial, you’ll see that routes and actions are intimately married in Sinatra. Although this may not be desirable for a larger application, it’s great for smaller, simpler web apps like this pastie project. In this case we’re talking uber-simple; we only have three actions and they’re only ever available at these three URL patterns.

The Index Action / New Snippet Form

The first of our actions needs to display a form to create a new paste. It should always be available at '/', the application root.

get '/' do
  erb :new
end

This tells Sinatra that when a GET request for '/' comes in, that we should use the erb helper to render the new.erb template, which is stored in the views/ subdirectory by convention and marked up with embedded Ruby (ERb). We can render our responses inline as well, which works for dirt-simple applications, but in most cases you’ll prefer to keep the view templates outside of this file.

In any case, the new.erb template is shown below:

<div class="snippet">
  <form action="/" method="POST">
    <textarea name="snippet_body" id="snippet_body" rows="20"></textarea>
    <br/><input type="submit" value="Save"/>
  </form>
</div>

The Create Action

Our next action is analogous to a #create action in RESTful Rails. The action is requested by a POST to the application root. Sinatra supports the standard GET and POST HTTP methods as well as PUT and DELETE, meaning that you can build 100% RESTful applications with it.

post '/' do
  @snippet = Snippet.new(:body => params[:snippet_body])
  if @snippet.save
    redirect "/#{@snippet.id}"
  else
    redirect '/'
  end
end

Pretty standard stuff, right? We retrieve the parameter passed to us from the new paste form, instantiate a new model and try to save it. If the validations pass, we redirect to the #show action equivalent. If not, we’re just going to dump you back to the #new form again. Since the only way the action will fail is if the body property is empty, we’re not going to bother with any sort of error message at this time. We’re not rendering anything here (merely redirecting), so no template is required.

The Show Action / Show Me The Snippets!

If our post is successful, we’re going to be taken to the #show action, which lives at /:id, where :id is the primary key of the corresponding database record. This action will also get accessed directly when you paste that URL to the chat room, and people click to view your code.

get '/:id' do
  @snippet = Snippet.get(params[:id])
  if @snippet
    erb :show
  else
    redirect '/'
  end
end

In the code listing above, we look up the particular snippet specified in params[:id] and set an instance variable by calling DataMapper’s get method (equivalent to Active Record’s find and one of many ways to do record lookups with DataMapper). If the @snippet is not found we’ll redirect back to the new snippet form. Otherwise we render an ERb template, which of course has access to that instance variable. Here’s the code you’ll want in /views/show.erb:

<div class="snippet">
  <div class="sbody" id="content"><%= @snippet.formatted_body %></div>
  <div class="sdate">Created on <%= @snippet.created_at.strftime("%B %d, %Y at %I:%M %p") %></div>
  <br/><a href="/">New Paste!</a>
</div>

The Layout

We’re pretty much done at this point. However, to dress up our output we’ll use an ERb layout template with some CSS to handle the syntax highlighting that Syntaxi provides for us. If it exists, Sinatra will render a special view template (just like Rails does) named layout.erb in the views/ subdirectory. This layout will be used to wrap the output of the other views rendered when the erb helper method is called.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title><%= @title || 'Toopaste!' %></title>
  <style>
    html {
      background-color: #eee;
    }
    .snippet {
      margin: 5px;
    }
    .snippet textarea, .snippet .sbody {
      border: 5px dotted #eee;
      padding: 5px;
      width: 700px;
      color: #fff;
      background-color: #333;
    }
    .snippet textarea {
      padding: 20px;
    }
    .snippet input, .snippet .sdate {
      margin-top: 5px;
    }

    /* Syntax highlighting */
    #content .syntax_ruby .normal {}
    #content .syntax_ruby .comment { color: #CCC; font-style: italic; border: none; margin: none; }
    #content .syntax_ruby .keyword { color: #C60; font-weight: bold; }
    #content .syntax_ruby .method { color: #9FF; }
    #content .syntax_ruby .class { color: #074; }
    #content .syntax_ruby .module { color: #050; }
    #content .syntax_ruby .punct { color: #0D0; font-weight: bold; }
    #content .syntax_ruby .symbol { color: #099; }
    #content .syntax_ruby .string { color: #C03; }
    #content .syntax_ruby .char { color: #F07; }
    #content .syntax_ruby .ident { color: #0D0; }
    #content .syntax_ruby .constant { color: #07F; }
    #content .syntax_ruby .regex { color: #B66; }
    #content .syntax_ruby .number { color: #FF0; }
    #content .syntax_ruby .attribute { color: #7BB; }
    #content .syntax_ruby .global { color: #7FB; }
    #content .syntax_ruby .expr { color: #909; }
    #content .syntax_ruby .escape { color: #277; }
    #content .syntax {
      background-color: #333;
      padding: 2px;
      margin: 5px;
      margin-left: 1em;
      margin-bottom: 1em;
    }
    #content .syntax .line_number {
      text-align: right;
      font-family: monospace;
      padding-right: 1em;
      color: #999;
    }
  </style>
</head>
<body>
  <%= yield %>
</body>
</html>

Hallo Pastie!

You can fire up your new Sinatra and DataMapper-powered application by issuing the following command:

ruby toopaste.rb
== Sinatra has taken the stage on port 4567!

Sinatra sits on top of <a href="http://mongrel.rubyforge.org/">Mongrel</a> by default, making it super-easy to use (and thread-safe to boot!). If you open up a web browser and point it at <code>http://localhost:4567</code> you'll see the results. Copy and paste away. You now have a fully functional (albeit slightly retarded) pastie clone with  syntax highlighting for Ruby code snippets. And the core logic is all contained in a single file, with a few external ERb templates for cleanliness.

Wrapping Up

As we mentioned earlier, Sinatra is based on top of Rack which means you can deploy it in a number of ways. It’s incredibly useful for lots of quick tasks and is definitely my “micro framework” of choice at the moment. DataMapper is well, just awesome. What else can I say? Lots of Merb developers already know this, of course.

OK enough blathering for now. Longest blog post. Ever. If you like, you can play with the finished app or check out the sources on GitHub. Enjoy, and please comment if you have any problems or suggestions for improvements. This code was written and tested on OS X 10.5 and Debian Etch. Special thanks to Jonathan Stott for the early review and fact checking.

Radiant Scoped Multi Update

2008-06-24T00:00:00-04:00

Blog updates have been pretty infrequent lately. As have my OSS contributions. Sorry! I haven’t had an awful lot of spare. Between client work and wrapping up my book (more on that soon), things have been a bit… insane.

However, I did find some time over the weekend to finally update the scoped multi-site Radiant extension fork to work with 0.6.7 and latest edge.

Note that the old URL is no longer accessible, as the Radiant Github presence was recently refactored to remove extensions from the core project repo.

I'm Back

2008-06-03T00:00:00-04:00

I’m back on the east coast after a 1.5 week west coast mini-tour, culminating with Railsconf information overload and a couple of great parties. I’ve written up some session highlights over at DDJ (parts one and two) in case you’re interested.

Greets to all the fine folks I met at the conference, especially the Offrails crew and Jason LaPier, my local guide to Portland nightlife and microbrews (also a badass Rails developer who was recently published in Pragprog’s Advanced Rails Recipes). Thanks dude!

If you’ve sent an email and I haven’t gotten back to you yet, my apologies; I’m still a bit jetlagged and trying to catch up on a ton of things.

Travel Plans

2008-05-20T00:00:00-04:00

I’ve got my itinerary planned out for Railsconf. I’ll also be hitting up a couple other west coast cities before landing in Portland. First stop is SF to visit my friend Ankit on Friday. Then trekking up to Eugene on the Amtrak Coast Starlite (I love me my trains) late night Sunday to hang and brainstorm with our designer/big-thinker Ty for a few days. Then it’s off to Portland on Thursday.

If you’re in any one of those cities and want to grab a beer (or a smoothie), hit me up on Twitter. Hopefully I’ll see some of you at Railsconf.

Also, I’ll be giving a talk at NHRuby tonight (5/20) on Rack. If you’re in the area, stop by.

Random Passenger Observations

2008-05-05T00:00:00-04:00

Played around with Passenger (v1.0.4) a bit more last weekend. Deployed a Radiant instance with it for staging. Overall, quite happy. However, thought I’d take the opportunity to jot down a few observations:

First, Radiant, with a smattering of extensions, takes a while to start up on the vhost we’re playing around on (yes, need to pump up those specs before deploying anything real). Since Passenger cleans up idle Rails instances when they fall into disuse, this can mean a harsh initial request delay for infrequently accessed hosts.

Passenger has clearly targeted the shared host market, where hosts have a large memory footprint and a large number of applications. The same strategy doesn’t work quite as well for a small VPS memory footprint and a single application root, where it would make sense to keep an instance in memory at all times (and clean it up and respawn it, perhaps, on occasion if an idle timeout is reached).

The solution in this case is to increase the Rails pool idle timeout to something that matches your traffic profile (of course, the tradeoff there is with the growing memory footprint of long-running processes…). And while you’re at it, adjust the maximum number of spawned instances — it defaults to 20, which is great for a dedicated with 2GB but not so good if you’re running a single application on a 512MB VPS.

More information is available in the architectural overview and the excellent user guide that the Phusion guys have put together. The SpawnManager itself is written in Ruby, and has a set of RDocs that you might want to take a look at as well.

We initially had some process ownership issues, where the Rails production log wasn’t being written to. The Rails server instance is going to be running as whatever user owns config/environment.rb (unless you change this in the config), so make sure to chown/chmod appropriately.

Finally, the restart mechanism, although a bit odd, is pretty useful. If you touch a file called restart.txt in the #{RAILS_ROOT}/tmp directory, it’ll reload the application instance on the next request without having to explicitly restart apache. Here’s a Capistrano deploy:restart task for this:

namespace :deploy do
  task :stop, :roles => [:app] do
    puts "Use the deploy:restart task to restart the Rails application"
  end
  task :start, :roles => [:app] do
    puts "Use the deploy:restart task to restart the Rails application"
  end
  task :restart, :roles => [:app] do
    run "touch #{current_path}/tmp/restart.txt"
  end
end

Note To Self (Good Examples Are Hard)

2008-05-03T00:00:00-04:00

The single hardest thing about writing a book, I’ve decided, isn’t the writing part. It certainly isn’t the technical part either. I don’t mean to downplay my own skills or those of any other technical author, but the truth is that you don’t have to be a guru to write a fantastic book (it does help, of course).

The key to writing good book material is being able to show people how to do things while keeping them entertained. That means coming up with examples that tread the line between being practical, being appropriately demonstrative, and being correct. Good examples are the hard part.

When developing an example, you’re trying to come up with something that has the following characteristics:

It’s interesting. That is, it’s worth writing about in the first place. No one wants to read another blog post creation example (unless there’s something unusual about it). BORING.
It represents best practices. You’re an author. You have to be right. Or at least able to competently defend your implementation choices, anyway.
It illustrates those concepts that you’re trying to write about. This should be first point, rather than third. See what I mean?
It minimizes focus on those elements that you are not writing about. That is to say, we shouldn’t spend a lot of time talking about fuzzy bears, even though there are many different types of fuzzy bears, six species of which are listed as vulnerable or endangered by the World Conservation Union (whose headquarters are in the scenic Lake Geneva area of Gland, Switzerland).

The last point is a tricky one, but it’s important. You have to cut corners when creating good examples — but not the important ones or the ones that would prevent it from representing best practices. If you’re trying to illustrate, for example, how to build a tag cloud, you don’t want to spend lots of time on the CSS for making it pretty. Leave that to the CSS books.

If your example involves video transcoding, and the point is to illustrate the use of a message queue, you’re going to be really tempted to spend an extra 2-3 pages on certain format discrepancies or operational edge cases but DON’T. It’s interesting, sure, but if it’s not central to what you’re currently trying to demonstrate (message queues). You must resist.

If your example is a simple web service for sharing geographic location data and you’re using a bunch of RESTful conventions, make sure to explain the basic concepts. But don’t write a dissertation on REST vs SOAP. And don’t worry about responding to formats that aren’t part of the main example.

Just because it’s how you’d do it in a real-life project doesn’t mean it’s how you’d write about it or explain it to others. Keep it simple, lively, and (as Gold Five so succinctly put it before crashing his X-Wing) stay on target.

Music To Code By

2008-04-18T00:00:00-04:00

There’s a good thread going on over at Hacker News today regarding music for coding sprints. It’s interesting to see that a number of people, like me, have trouble concentrating when listening to music with prominent lyrics, whereas others thrive on it.

A lot of people also seem to really dig electronica. I guess that’s no big surprise. It’s never done much for me, personally, although there are a few electronic pieces I do really like (NIN’s Ghosts being a recent example). Being an ex-hc/metalhead I gravitate more towards melodic post-rock stuff and the occasional poppy masterpiece.

Here’s some stuff in my current work playlist:

Explosions in the Sky
Mogwai
Castor
My Bloody Valentine
Elliott
Pinback
Isis
On The Might of Princes
Jesu
Portishead
Dredg
National Skyline
Pelican
Low Frequency In Stereo
Radiohead
There Were Wires
Godspeed You! Black Emperor
Mouth of the Architect

Yes I know some of these bands have lyrics. But they’re so fuzzed up or unintelligible that my brain doesn’t seem to process them while working, so all is good. And in the case of bands like Elliott and Pinback and Dredg, the vocals are prominent but somehow almost feel like more of an instrument. Also seems to work. Kind of strange, I guess.

NHRuby Hackfest

2008-04-14T00:00:00-04:00

Yep, that’s right. Hackfest tomorrow night in Portsmouth. Bring any code you’re having issues with. Failing that, I’ve got a couple project tickets (DataMapper, Radiant) that we can dig into. We’ll spend 30 minutes or so on a quickie mod_rails demo while we’re there too.

In other local news, John Herman has been swell enough to put together an NH Media Makers group. The first get-together is May 11th at Crackskulls in Newmarket. Rock out.

Mod_Rails Revealed

2008-04-12T00:00:00-04:00

The hardworking hackers over at Phusion finally unveiled Passenger (mod_rails) earlier today. I just moved one of our staging servers over to it and will be playing around with it a bit more over the weekend. So far I’m happy to report that, as advertised, it’s dead easy to use… and the performance seems solid.

I’d write up a tutorial but honestly it’s so simple that it’s completely unnecessary (imagine that!). Check out the updated screencast for all you need to know to get up and running and make sure to dig into the provided docs if you need more. They’re very thorough.

In summary, it’s great to see more Rails deployment options emerging, and it’ll be interesting to see viable shared hosting options for the low-end market too. Although I’m a strong believer in the app server + frontend web server pairing, there are a whole class of applications for which it just seems like overkill.

A hearty ‘nice work’ to everyone involved! Now where’s my mod_rack? :-)

UPDATED 4/12: this blog is now running on mod_rails and Mephisto 0.8!

2008 Rails Rumble Rumors

2008-04-10T00:00:00-04:00

Just to clear up any possible confusion on that matter: Yes. There will be a 2008 Rails Rumble. And no. It will not be in May. Probably September or October.

We have a lot of great ideas (thanks to everyone that participated and commented) that will improve on last year’s experience dramatically and the whole team is looking forward to it, in a big way. More information coming soon, I promise, as well as an announcement, new blog, and specific details prior to Railsconf.

Oh, and speaking of Railsconf… Josh Owens, of TastyPlanner fame (last year’s grand prize winner), is giving what looks to be a fun talk about their experience building a kickass app in a 48 hour timeframe. If you’re going to be there, you ought to check it out. Especially if you’re interested in participating this year. If you haven’t yet registered for the conference, you’re running out of time, so get to it.

See you there!

Radiant Super Multi Go!

2008-04-03T00:00:00-04:00

Here at Ubikorp we’ve used Radiant as the basis for a number of client projects who needed core CMS-like functionality. As anyone who’s played with it knows, Radiant is very barebones; this is intentional and a welcome change from most packages, which attempt to throw the kitchen sink of clutter at each and every problem. Fortunately, it’s easy to build on top of the basics by using a well thought-out extensions system — there are a large number of stock extensions available (and it’s also really easy to roll your own for custom app logic).

One of the more interesting extensions is the multi-site extension. To be honest, multi-site capability is something I really feel should be a core feature, but since it’s not, this approach works surprisingly well (at least until you start adding other extensions that would ideally be multi-site-aware). Radiant school headmaster Sean Cribbs wrote an initial version of the extension back in November, but it didn’t quite work for us on a particular project — we needed to be able to scope individual user-level access to particular sites. So we extended it, and thus the scoped multi-site extension was born.

Well, actually, it’s just a fork of the multi-site plugin. For now.

Features:

scopes user level access to individual sites (admins and developers still have access to all sites)
regular users can’t see, edit, or access other user sites that they don’t own
optionally scopes layouts to sites
snippets usable everywhere, but display and editing of snippets limited to admins/developers

Anyway, if you’re interested in seeing our changes you can check it out on github in my fork of Sean’s Radiant repo. Is this a candidate for integration into the existing extension, or should we spin it out as a separate extension? Let me know what you think.

UPDATED 6/24: The URL is out of date. See this blog post for more details and updates (the latest version requires Radiant 0.6.7 or later).

Twittering

2008-04-02T00:00:00-04:00

I’ve been bitten by the Twitter bug. I know, I’m a little late to the party. But being late is fashionable. And I sure like the fashion.

Anyway, go ahead and stalk me. If you dare. Or check out the status updates in the blog sidebar if that’s what you’re into. I’ve also added my DDJ blog feed to the sidebar. A couple of my recent articles:

Roll Your Own Web Framework (an introduction to Rack)
Rails: Vendor Everything Just Got Easier (the new config.gem features in Rails Edge)

More soon. Promise.

Mod_Rails Teaser

2008-03-20T00:00:00-04:00

Well, this is sure to stir up some buzz in the Rubyverse…

DDJ Code Talk Launches

2008-03-15T00:00:00-04:00

The legendary Dr Dobb’s Journal just announced the launch of their new blog and forum system, DDJ Code Talk. I was extremely honored when Jon asked me to contribute, as DDJ has long been one of my favorite industry pubs. Them peoples is hardcore.

In the coming months I’ll be contributing articles about Ruby, web application development, and lightweight languages. Head on over to check out my first article for them, a quick survey of Alternative Ruby Web Frameworks. There are a few other Ruby geeks hiding in their trees too, and a broad range of topics, including Python, Java, .NET, D (!), databases and web service architecture and design. Thanks for reading!

NHRuby: Django/Rails

2008-03-09T00:00:00-05:00

If you’re in the ME/NH/MA area on Tuesday, make sure to stop by the NH Ruby SIG; Brian Turnbull will be presenting an in-depth talk comparing the philosophies of Rails and Django. I’ve never done any Python work at all myself, so I’m really looking forward to this dissection.

If you’re not in the area, you’re still in luck. We’re trying something new this month, and will be broadcasting the event live via WebEx. Big thanks to Tim Golden and our sponsor RMC Research for hooking this up!

(NOTE: we usually meet on the third Tuesday of the month, but our host had some scheduling problems this time around; we’ll be returning to the normal schedule in April)

Git Ur Radiant Extensions

2008-03-05T00:00:00-05:00

I published a new Radiant extension yesterday: Database Form. It provides a new page type and tags for constructing contact and request info forms and will save user responses to a database table. Those responses can then be exported for use in another application (CRM, etc). See the README for usage and examples. It was extracted from some client work that we’ll be deploying soon.

If this sounds good, you can download or clone it from GitHub. While you’re there, spend a few minutes poking around; GitHub is pretty dang cool. They’ve definitely succeeded in making Git repository hosting stupid simple. Just click a button to create a project, follow a few commands on your local system to import your sources, and you’re off and running. You can then view the repo history, browse the source, see diffs, download a tarball (for easy extension installation in your pre-existing Radiant project), and fork it if you want to add your own features. That’s where things get sweet, of course: Fork the project, make some changes, and send me a pull request so we can merge them into the master branch. All this is possible without GitHub, but it sure does a swell job of streamlining things and abstracting the suck away.

It also exposes the links between developers and their project contributions in a pretty cool way. See the DataMapper project’s “network” page to see what I’m talking about. Ryan Tomayko has pointed out that this sort of interaction starts to smell an awful lot like a MySpace for developers, where lines in the social graph are drawn based on OSS project work. Wow, that’s a cool thought, ain’t it?

Principle of Least Surprise

2008-03-04T00:00:00-05:00

One of the things I love about Ruby is that it tends to follow the principle of least surprise; things just work the way you would expect them to, with precious few exceptions (cough cough inject cough). Horray for intuitiveness.

On the other hand, I’ve become so spoiled by The Principle that willful violations stand out like the sober guy at the all-inclusive beach resort. I know I’m being a nitpicky ass here, but this Rails bug^H^H^H ticket makes me kinda ill. Funny, because in my previous life as a Java/PHP developer, I wouldn’t have even batted an eyelash at it.

OpenID + Client Certs = Win

2008-02-22T00:00:00-05:00

I’m a big fan of OpenID. Or rather, I’m a big fan of what OpenID and data portability mean for the web at large in the coming white days. Single sign on and distributed identity is certainly an idea that’s been long overlooked and it’s time that we changed that. The next time you write a web application, ask yourself: “do my users really need yet another set of login credentials?”. Then implement OpenID. It’s really simple, especially in Rails. I gave a presentation on it at NHRuby last month (download PDF).

So, as gah-gah as I am over single sign on for ease of use, I’m a embarrassed to note that, like almost everyone else, I’ve completely overlooked client certificates for web-based authentication. By using client certificates you one-up single sign on by removing the need to use a login/password at all. This isn’t new; it’s something that’s been available in every web browser for pretty much as long as anyone can remember. And yet I’ve never, ever seen a site that supports them for an authentication mechanism. Sad faces abound.

But wait! OpenID to the rescue! It turns out that MyOpenID (and a host of other OpenID providers) DO make use of them. So if you create a client certificate with your OpenID provider, you can eliminate the need to use a login/pass with any OpenID client sites. Cheers to Dr Nic Williams for digging this up. Sometimes old (and ignored) is the new new. Rock on.

More details at Dr Nic’s blog.

Plugins Are Unnecessary

2008-02-20T00:00:00-05:00

Plugins really are unnecessary — Jay Fields is absolutely right. RubyGems is a great package management system and there’s no reason it can’t do double duty here, if we just impose a few extra restrictions on Gem/Plugin structure. There are other benefits too using Gems too, such as versioning and dependency management, which is somewhat painful in the world of Rails plugins.

Merb already uses Gems for plugins/extensions. Why doesn’t Rails? Historic reasons, most likely. Rails itself predates the existence of Gems iirc. But seriously, how hard would it be to rewrite `script/plugin` to install a gem and unpack it into `vendor`? That’s the first step.

ActiveRecord: Importing YAML

2008-02-20T00:00:00-05:00

Backing up ActiveRecord models to YAML is easy to do, and can be convenient for creating ‘templates’ that can later be imported to restore basic project structure in a new database. However, the import process can be a little tricky, as the instantiated objects don’t seem to respond correctly to `new_record?`

Here’s what our YAML might look like. Note that it’s a serialized `CustomWidget`, which is an ActiveRecord model that inherits from `ActiveRecord::Base`.

--- 

- !ruby/object:CustomWidget 
  attributes: 
    name: DoSomething
    updated_at: 2008-01-28 05:02:54
    description: Does something.
    created_at: 2008-01-28 05:02:54
  attributes_cache: {}

We can automatically instantiate the appropriate Ruby objects from this using the following code:

class CustomWidget < ActiveRecord::Base
end

YAML::add_private_type("CustomWidget") do |type, value|
  CustomWidget.new(value)
end

obj = YAML::load(File.open("template.yml"))[0]
=> #<CustomWidget name: "DoSomething", created_at: "2008-01-28 05:02:54", updated_at: "2008-01-28 05:02:54", description: "Does something.">
obj.save
=> true

So what we’ve done is taken YAML from one project and tried to use it to import the same data into another database (note that IDs are stripped). We define a transfer type for the YAML, providing a mapping to the class, and then we call `YAML::load` to load it up. This returns an array, in this case it contains a single `CustomWidget` object. Everything looks swell. We call `save` on the new object and it returns true.

However, if we check the `count` of `CustomWidgets` that exist in the database, we’ll find that it’s unaltered; no new record has been saved. It turns out that this is because the imported `CustomWidget` doesn’t report true when `new_record?` is called.

obj.new_record?
=> nil

In order to save itself to the database and get a new ID, the `CustomWidget` instance has to first respond correctly to inquiries as to whether or not it’s new. We’d like `new_record?` to return false. The quick-fix secret is to manually toggle the `@new_record` instance variable. If we do that, calling `save` will return true and actually save the object to the database as well this time. Big yay, right?

CustomWidget.count
=> 0
obj.instance_variable_set("@new_record", true)
obj.new_record?
=> true
obj.save
=> true
CustomWidget.count
=> 1

Yes, this is an ugly hack. Did I say ugly? I meant gross.

Constraint-Driven Development++

2008-02-08T00:00:00-05:00

There was a nice writeup on ReadWriteWeb yesterday about Montreal’s upcoming Blitzweekend event. Like the Rails Rumble that we organized last September, Blitzweekend is another attempt to give people a “weekend to build a functioning startup from scratch”. Unlike the Rumble, it isn’t a competition, and it places added value on physical proximity.

Josh Catone (of ReadWriteWeb and also RailsForum) dubs this sort of thing “organized ultra-rapid development” and notes that, against all odds, this strange weekend-startup phenomenon seems to be trending up. This is really just constraint-based development taken to the next level, and the reason it’s exciting is simple: it pushes you to deliver results, immediately.

Results, of course, are what makes application development exciting; seeing a movie get automatically reencoded after upload, a search query produce a number of restaurants in my area, plotted on a map, a transaction get authorized and recorded by the third party API you’re using. And later, seeing your end to end workflow in place and your first user signup. When we see results, we get motivated to work harder in order to see even more impressive results. When we don’t see results, we get depressed, we step back, we overthink. Our motivation falters.

Events and contests like Blitzweekend help give developer-entrepreneurs that extra motivation kick that they often need to get over the motivation speedbump, and an opportunity to gather a team together and just go for it. If you haven’t tried it, you really should. In the process you’ll find out if you can work with your team in the long haul, write some (hopefully) great code, and figure out whether or not the idea has legs to stand on. If it does, you’ll have visible proof of this and will probably be more jazzed than ever to continue working on it. If it doesn’t, you won’t have to spend any more time wondering “what if”. All in 2-3 days.

(It’s important to have realistic expectations of course. Are you going to be able to build the next Flickr in 48 hours? Or the next Facebook? Nope. But you sure can get a nice first iteration out there and working. Every application has to start somewhere, and if the first iteration of your idea isn’t ugly and lacking important features, then there’s a good chance it took you too long. Short iterations can pack a lot of result-fu ninja punch.)

Anyway, I’ve rambled on for a bit and I’m sorry. We’ll do another Rumble, or something like it, later this year. For sure. But the reason I’m writing is this: You don’t have to wait.

That is, you don’t need an actual event to prove that this brand of ultra-mega CDD works.

Take the last 3-4 days of this month, of next month, of whenever. If you’re a freelancer, just tell clients you’re unavailable during those days. Get 3 other people to do the same thing. Agree on an idea, flesh out the basics. And just do it, Nike-style.

I’m seriously thinking about doing just this, starting at the end of February, maybe at the end of each month. Anybody wanna be on my team?

Slacking

2008-01-30T00:00:00-05:00

Like my pal bryanl over at smartic.us, I too want to apologize for being a bad blogger lately. I’ve just been stupid busy with both personal stuff and lotsa client work, which of course is both a blessing and a curse.

In any case, my head is almost back above water and I hope to be back on track writing regular (and hopefully interesting) posts within the next week or two. I’ve been working on some fun projects and I want to talk about it, really, but at the end of the day I’m just tired and don’t know where to begin. I’ll figure it out.

In the meantime, if you’ve got free cycles and some cash in your wallet to burn, pick up a copy of Dave Berube’s new book on Ruby Reporting, which was just published by Apress. I served as a technical reviewer on it, which was a really great experience. Even though Dave and I don’t see eye to eye on absolutely everything (cue groans about a particular chapter dealing with MS Access integration), it’s full of fun Ruby code and unique reporting tips, including examples that interop with Google AdWords, SugarCRM, and PayPal. Congrats man, nice work!

Railsconf Registration Open

2008-01-30T00:00:00-05:00

Registration for Railsconf 2008 opened earlier today. According to the site, there will be more advanced-level sessions this year, which is definitely a good thing. Last year was a fantastic experience, but it felt like I was constantly stumbling into sessions where the subject matter was a bit too noob-centric (thank goodness for the IRC peanut gallery).

Of course, that said, as with all conferences, the discussions you get into in the hallways and after hours are usually more beneficial than any session you could ever attend anyway. But still, I’m really hoping sessions are labeled with a suggested experience level this year.

Am I going? Honestly don’t know. I’d like to. It’s really an amazing thing to see 1500+ Ruby developers all descending upon one location at one time. That spectacle alone is probably worth the price of admission. Plus, the microbrews in Portland are top-notch. I’m guessing it will sell out, so I better make up my mind sooner rather than later. How about you?

NHRuby 2008

2008-01-14T00:00:00-05:00

The Seacoast NH Ruby SIG (NHRuby) will hold it’s first meeting of 2008 tomorrow, Tuesday January 15th in Portsmouth. I’ll be talking about OpenID and Scott Garman will be doing an overview of some funky stuff he’s doing with ActionMailer. Check out the Wiki for directions and other goodies, as usual. Hope to see you there!

I also want to send a quick congratulatory note to Scott, who launched his Rails-based startup CampaignLever a few weeks ago. CampaignLever is a tool to help grassroots organizations build effective letter writing campaigns. Nice work man!

Storing YAML in YAML Fixtures

2008-01-10T00:00:00-05:00

If you ever find yourself in a situation where you have an attribute value that needs to be serialized (stored as YAML) and used within a (YAML) fixture, you can do something like:

FancyWidget:
  id: 1
  name: FancyWidget
  serialized_hash: "<%= {:abc => {:xyz => 'foo'}}.to_yaml %>"

Or, if you want to embed YAML directly you can do:

FancyWidget:
  id: 1
  name: FancyWidget
  serialized_hash: |
    ---
    :abc: 
      :xyz: foo

This is probably old hat to a lot of you, but I figured I’d doc it here since the solution felt somewhat non-obvious at first. Rails stores serialized attributes in your database this way, so you might run into this if you’re using ActiveRecord’s serialize method.

Coworking Jealousy

2008-01-06T00:00:00-05:00

I’m calling it now: Coworking spaces are the new startup incubator. No, I’m not talking about shared office space. No way. It’s different:

Coworking is a movement to create a community of cafe-like collaboration spaces for developers, writers and independents.

The whole concept feels very, very right to me. See, I don’t really want coworkers, just like I don’t really want a full-time ordinary run-of-the-mill 40 hour/week job; I’d rather be sharing a space with 4-10 other self-motivated similarly-minded freelancers, who split their days between client work, personal startuppy ideas, and OSS projects. Especially ones that can hack some mean code, or who have a sick artistic bent.

Of course, you need a critical mass to make something like this work, and people who can commit to participation. Those can be hairy obstacles. Coworking spaces usually develop in larger cities because, hey, they have the ecosystem to support it. The numbers are on their side. San Francisco, Washington DC, Boston and Seattle all have fairly well known coworking spaces. There are a number of entries at pbwiki for small cities, but for the most part, those links are just people who are interested should something become available.

Man, I’m jealous. I want a coworking space in my city. Hrmm.

Reading List Update

2007-12-29T00:00:00-05:00

So I updated this blog from Mephisto 0.7.3 to the latest trunk yesterday and I’m happy to report that the process was 100% painless. Edge has a number of nice nuggets missing from 0.7.x, which is over a year old at this point. In any case, thanks to Rick and the rest of the Mephisto team for the smooth upgrade path. I can’t wait for 1.0, which I hear is rumored for a January release ;-).

While I was in the blog tweaking mood I also decided to install the mephisto_feedreader plugin and wired it up to display my shared items from Google Reader. This replaces the static “reading list” that was previously in the sidebar. I scan / read a good number of blogs, probably too many, and I often tag 2-3 things a day on average that I feel are useful / interesting / irreverent. Sharing is good and I have nothing to hide. For great justice!

Holiday Gifts: Ruby 1.9

2007-12-26T00:00:00-05:00

Happy holidays everybody. In case you haven’t heard, Ruby 1.9 was released yesterday. If you’re not exhausted from overeating and traveling, I’d encourage you to spend a few minutes taking it for a spin.

Ruby now runs on top of YARV, and these benchmarks indicate that there are some pretty impressive performance increases over 1.8.6. That said, 1.9 is a development release; it’s not currently intended for production use and don’t expect Mongrel or Rails (or various other gems) to run on it just yet.

For more information, Dave Thomas has written a nice, concise list of pros and cons over on his blog, and Mauricio Fernandez has been maintaining a full list of changes found in 1.9. Enjoy!

DataMapper 0.2.5 Released

2007-12-21T00:00:00-05:00

Sam released DataMapper 0.2.5 on Wednesday. It includes a bunch of tasty bugfixes before our next leap to 0.3.×. Give it a try if you haven’t, I think you’ll like it. And if you don’t, well, you’re… whatever.

One of the changes that I’m particularly fond of is proper method visibility for properties:

class Person < DataMapper::Base
  property :ssn, :private => true
  property :login, :protected => true
  property :name
  property :address

  has_many :dogs
  belongs_to :alien_overlord
end

The private and protected options are really just shortcuts for (`:reader => :public, :writer => :private`) and (`:reader => :public, :writer => :protected`), respectively. In most cases you’ll want your reader to be public, but if you want to apply the same visibility modifier to both reader and writer, there’s an ‘:accessor’ option too. The property visibility is respected for mass assignment, which is a nice natural way to do things imo, unlike the hacky attr_protected stuff in ActiveRecord, which never felt right to me.

In any case, we’ve also updated the Website and Getting Started page, which was a little out of date. See those links for installation instructions and feel free to pop into the `#datamapper` channel on IRC, hit up the mailing list, or even leave blog comments here if you have any issues.

Other important changes (see the changelog for a complete list):

`MyModel#[]` only accepts a primary key now, not an options hash (use first, all)
`database.get` (equivalent to AR’s `find_by_id`) is approximately 25% faster than before!
Persistence module added (you no longer have to inherit from DM::Base, although I still prefer this approach)
You can now set indexes with `:index => true` and `:index => :unique`
Validatable gem now used for handling validations

To REST Or Not To REST...

2007-12-18T00:00:00-05:00

Assaf Arkin is right, and I stand corrected. SimpleDB ain’t RESTful. Hell, it’s not really even GETSful. But it sure sounds nice when they put it in the marketing literature. Sigh.

From Subbu’s blog: “The technology powering SimpleDB is definitely impressive [..] However, as a REST API, it is a disappointment. The API failed (a) to identify resources, and (b) to specify operations on resources in a RESTful way. It uses a single verb GET to create, delete, update, or get data from the store.”

In any case, Assaf whipped up DeHorrible, a Rails proxy that appropriately RESTifies (GETStifies) SimpleDB. lol.

I’m still psyched about the SimpleDB announcement, and looking forward to trying it out, but I really wish Amazon would clean up their supposedly RESTful APIs. Yes, I’m looking at you, Flexible Payments.

Is it really that hard?

Links for 12.17.07

2007-12-18T00:00:00-05:00

Some git goodies, updates to both Rails and Merb, and other stuff this week. Here’s the breakdown:

Evan Williams writes about how to evaluate a new product idea<
Giston — a piston lookalike for git
Gitosis — host and manage a git repo, with access control, easily/safely…
RSpec 1.1 is Released — with support for Rails 2.0.1+ and the new RSpec story runner (!)
Rails 2.0.2 is Released — includes sqlite3 as the new default database and an important fix for RubyGems 0.9.5
Merb 0.4.2 is Released — performance enhancements, etc.

SimpleDB is RESTful & Schema-less?

2007-12-16T00:00:00-05:00

So the big web service of the week announcement goes to Amazon, for their AWS SimpleDB hosted service. This should place nicely with EC2, which is an interesting service except for the fact that persistent data across sessions is problematic (every time you boot an EC2 node it’s a clean slate).

So what is SimpleDB? It’s:

Built in Erlang (wow, maybe Erlang is worth learning after all, right?)
~~RESTful~~(see comments); API returns XML
Schema-less
Non-relational

Wait, what? Schema-less? Non-relational? Yup. In case you haven’t noticed, there’s been a groundswell of interest in this area lately… Perhaps most buzz-worthy is the CouchDB project, which also uses REST for inserts and queries, storing your data in schema-less databases which Amazon confusingly refers to as “domains” (see other differences). CouchDB is pretty neat, and all the cool kids seem to like it. RDDB has similar goals. And then there’s DBSlayer, which takes the approach of wrapping a REST API around traditional relational databases (MySQL, etc).

So why the interest in moving away from traditional RDBMS, which have served us well for so many years? Simplicity. Ease of scaling. The emphasis on removing business logic from the database and keeping it in the application, where it belongs. At least, those are the arguments. I’m no expert, but I’m certainly interested. Assaf Arkin summarizes the argument much better than I can, and his article Read Consistency: Dumb Databases, Smart Services should be required reading for anyone who’s interested in the future of (dumb) databases on the web. Assaf also has a follow-up article on the merits of CouchDB, specifically. There’s a lot to think about here.

Of course, another key value prop with the Amazon service is that it’s hosted. By Amazon. They claim it’s fast and reliable (they should know a thing or two about that), and it looks to be relatively inexpensive, when you consider that the alternative is clustering your own databases for the same kind of speed and reliability. It’ll be interesting to see how this turns out and I’m anxious to play around with it.

All that said, there’s no Ruby library wrapper for SimpleDB yet. However, as Chad Fowler notes, there are already three different projects registered with RubyForge. None of them have checked in even a single file as of this writing, but you know that somebody out there is hard at work (hint hint), and I’m sure you’ll see it before too long. Alternatively, you can build one yourself.

Me? I’ve already got too much on my plate this week. And I still have to get that DataMapper cheat sheet done, too.

/me apologizes again

/me goes outside to shovel snow

NetBeans: Helpful Plugins

2007-12-13T00:00:00-05:00

So, NetBeans 6.0 Final was released a few weeks ago. v6.0 is all about the Ruby love, right out of the box. If you haven’t tried it, I implore you to give it a shot. Even if you’re not a fan of traditional “heavyweight” IDEs, I think you’ll be impressed with what they’ve done. There’s even a slimmed-down Ruby-only version. But sometimes, I must admit, I still miss the power and (relative) simplicity of vim.

I’m in the process of re-reading The Pragmatic Programmer, and was just pawing through the passage on “power editing”, in which Dave and Andy suggest that you “choose [one] editor, know it thoroughly, and use it for all editing tasks”. For me, that editor is most definitely vim. I’ve used it for quite some time, it’s familiar, I don’t even have to think about the keybindings when I’m working in vi, and I’m spoilt by the easy text manipulations that just aren’t possible with some fancy graphical editing tools. I use vim for practically everything text-related.

Everything, that is, except writing Java and Ruby code (and a few random tasks that have to be performed in a word processor, sadly). Yep, you read that right. I use vim for sysadmin tasks, hacking quick scripts, editing config files, and even taking notes, but lately I haven’t been using it where I’d probably see the single largest productivity boost from it.

Since switching to NetBeans, my comfort level with having all the tools I need in one place has increased dramatically, including things such as easy access to a console, in-IDE debugging, test output, solid class introspection, integrated rdocs, and so on. But I also realize that I’ve been doing myself a bit of a disservice when in “heavy edit” mode. Fortunately, that’s easily fixed, as there’s a vi plugin for NetBeans. YES. No idea why I didn’t bother to search for something like this before.

So in any case, if you’re interested, you can retrieve the NetBeans plugin from the jVi homepage. The file named nbvi-FOR-NB-RC1-1.1.2.×6 is the one you want (as of this writing, anyway). Once you’ve downloaded the package, you can install it in NetBeans by going to tools => plugins. Choose the downloads tab, click ‘add plugins’, select the vim core and keybindings plugins, install them, and be happy. Thanks guys, this is so awesome.

Oh and speaking of plugins, here are a few other helpful Ruby-related plugins for NetBeans that you may be interested in. Most of them are available through the plugins browser built into the IDE.

Rspec Support (nice!)
Ruby dark pastels color scheme (hrmm looks familiar…)
HAML and SASS plugin (if that’s the way you roll)
Extra Source Code Hints

Emerging Technologies Conference 2008

2007-12-09T00:00:00-05:00

I really enjoy the technology conference ritual, make it a point to get to at least a few every year. I particularly enjoy the smaller regional conferences. Where else can you (a) get exposure to new technologies, (b) meet the smart hackers who created your favorite OSS tools, © get away from home for a long weekend, and (d) get schooled at werewolf, all at the same time?

Alas, with winter upon us, it appears that the 2007 conference circuit is winding down. That means it’s time to look forward to… Why, the 2008 conference circuit, of course!

The Third Annual Emerging Technologies for the Enterprise Conference has been announced; it will be held in Philadelphia, March 26-27th. Last year they had some great talks by high-profile Rubyists such as David Black, Geoff Grosenbach, and Amy Hoy. Rod Johnson, father of the Spring framework, also gave a talk last year.

This year, Floyd Marinescu of InfoQ will be giving one of the keynotes. Obie Fernandez and Peter Armstrong (the author of Flexible Rails, which I’m really looking forward to reading) have already been announced as Ruby community speakers.

Got something worth talking about? Tracey asked me to note that there’s an open call for presenters. The submission deadline is 1/7/08.

Dates for RailsConf (5/29-6/1), Mountain West RubyConf (3/28-3/29) and GoRuCo (4/26) have already been announced as well. Feel free to mention any other interesting events that I’ve omitted in the comments!

Rails 2.0 Released

2007-12-07T00:00:00-05:00

It’s official; Rails 2.0 was officially released this morning. Gem update rails to snag it. There’s some great stuff in there, if you haven’t been keeping track, including further augmentation to RESTful conventions, multiview, HTTP authentication, sexy migrations, and on and on and on.

You can read all about it here and also make sure to check out the feature summaries that Ryan Daigle has put together as well as the series of Railscasts Ryan Bates has been doing on the new features. Thanks for the hard work everyone.

Links For 12.05.07

2007-12-06T00:00:00-05:00

Waiting at IAD for a connecting flight home (en route from Beijing). It’s snowing. That means delays. I’m tired. But at least I have some time to catch up on blog reading and link posting. Here’s the rundown of goodies on my reading list atm:

A Quick Jaunt Through Merb’s Framework Code — essential reading for anyone looking to get started with Merb.
NetBeans 6.0 Final is officially released — Best Ruby IDE on the planet imo, nice to see it finally finished and out there.
A Great Interview with Tor Norbye of the NetBeans team — and the difficulties of doing proper Ruby type inference
Loic Le Meur’s Ten Rules For Startup Success — common sense of course, but good reading
Setting Up a New Rails App with Git — good getting started tutorial if you haven’t yet switched over
Rodrigo Kochenburger has a new blog — he’s a smart cat so make sure to add him to your feed reader

Software Development 2.0 China

2007-11-29T00:00:00-05:00

Today I’m in Beijing, attending the CSDN-Dr. Dobb’s Software Development 2.0 conference. It’s my first time in China and it’s quite an honor to be here. I’ll be giving a Ruby on Rails overview and code analysis talk as part of tomorrow afternoon’s session. Looking forward to talks by Andrei Alexandrescu, Tenni Theurer, Dan Theurer, Jonathan Palley and of course DDJ’s own Jon Erickson.

Links For 11.24.07

2007-11-24T00:00:00-05:00

JRails – Drop-in JQuery replacement for Rails prototype/script.aculo.us helpers.
NetBeans 6.0 RC2 – Available for download.
Gemtacular – Rate and Review Ruby Gems.
LiveConsole – IRb over TCP remote console. Cool idea.
Google TV?
Rake tasks for QueryTrace
Rails 1.2.6 – Includes an important security fix. gem update rails -y

Ruby Method Visibility

2007-11-22T00:00:00-05:00

In Java (and most OO languages), declaring a method as private means that the method can only be accessed within the context of the defining class. Similarly, protected means that the method can only be accessed from that class or any of its subclasses.

In Ruby, things are a bit different. Both private and protected methods can be called by any instance of the defining class and its subclasses. Inheritance plays absolutely no role in determining the visibility of a method. The difference instead is that private methods can never be called with an explicit receiver, even if the receiver is self. This means that it’s not possible to access another object’s private methods, even if the object is of the same type as the caller. A private method must be called from within the calling object.

Consider the following example:

class Person
  def public_method
    "public"
  end

  protected
  def protected_method
    "protected"
  end

  private
  def private_method
    "private"
  end
end

class SalesPerson < Person
  def check_protected_method_explicit_receiver
    "#{self.protected_method} method OK with explicit receiver"
  rescue
    "failure accessing protected method with explicit receiver"
  end

  def check_protected_method_implicit_receiver
    "#{protected_method} method OK with implicit receiver"
  rescue
    "failure accessing protected method with implicit receiver"
  end

  def check_private_method_explicit_receiver
    "#{self.private_method} method OK with explicit receiver"
  rescue
    "failure accessing private method with explicit receiver"
  end

  def check_private_method_implicit_receiver
    "#{private_method} method OK with implicit receiver"
  rescue
    "failure accessing private method with implicit receiver"
  end
end

The public method can of course be accessed from anywhere (in this case, outside the class with an explicit receiver) and both private and protected methods of Person will obviously raise a NoMethodError.

Person.new.public_method
=> "public"
Person.new.private_method
=> NoMethodError: private method `private_method' called for #<Person:0x6ec698>
Person.new.protected_method
=> NoMethodError: protected method `protected_method' called for #<Person:0x6ea5c8>

So the protected method cannot be accessed outside of the class or it’s subclass, but from within the subclass, using it with either an implicit or explicit receiver works fine:

SalesPerson.new.check_protected_method_explicit_receiver
=> "protected method OK with explicit receiver"
SalesPerson.new.check_protected_method_implicit_receiver
=> "protected method OK with implicit receiver"

The private method can also be called from the subclass, but note how it only works with an implicit receiver:

SalesPerson.new.check_private_method_explicit_receiver
=> "failure accessing private method with explicit receiver"
SalesPerson.new.check_private_method_implicit_receiver
=> "private method OK with implicit receiver"

This also means you can do stuff like:

class Person
  def ==(other)
    protected_method == other.protected_method
  end
end

x = SalesPerson.new
y = Person.new
x == y
=> true

We’re accessing the protected_method of another class instance that shares our type here, specifying an explicit receiver. If you were to try to use private_method instead, a NoMethodError would be raised. You could also just call other.send("private_method") if you really wanted to, violating our encapsulation and angering the gods of object orientation. This is only a “little sin” though, and can be permissible if the situation calls for it (like, cough cough, my latest commit to DataMapper).

In summary, method visibility and access control can be a bit confusing at first, especially if you’re coming over to Ruby from some other OO language. If you’re still confused, there’s more information available here and here. Do yourself a favor and make sure you understand, cuz it’s important stuff!

Steinbeck on Ruby?

2007-11-21T00:00:00-05:00

“Syntax, my lad. It has been restored to the highest place in the republic.”

— John Steinbeck

Book Review: Practical Ruby Gems

2007-11-17T00:00:00-05:00

I’ve been meaning to start posting book reviews for some time now. I don’t really have a good excuse as to why I haven’t, so I’ll spare you the overly verbose excuses and get right to the good stuff.

The first book in my stack is David Berube’s Practical Ruby Gems. Before diving into it I should note that Dave is a friend of mine and that I’m currently working on a book with him for Apress. My opinions here are, of course, my own.

Practical Ruby Gems is a survey book, covering a number of 3rd party Ruby libraries as well as general usage of the Gems system itself. Although it’s a bit short on details in some places, the breadth over depth approach is really quite useful in that the book will doubtlessly introduce you to some libraries that you weren’t aware of before. This is particularly true if the majority of your Ruby experience has been within the context of Rails. A number of the chapters do make use of Rails (hey, it is a Gem after all), a few use the Camping web framework, but the majority of the examples are constructed as simple command line utilities.

The more popular Gems, such as hrpicot and rmagick are of course covered here, but the real (ahem) gems are the lesser known libraries such as multi, memoize, runt and cmdparse. Dave’s examples cover a wide variety of topics and use each Gem in an interesting way, going beyond the rdocs to show you how to combine and use these libraries in real applications. Using Fxruby and the YahooFinance Gem to create a graphical stock ticker is a good example of this. Another example is an RSS news archiving service built using ActiveRecord and FeedTools. Both practical and well-dissected in the text, this sort of thing is sure to help new Ruby developers grasp the concepts for re-use in their own developments.

The chapters on creating and distributing gems (with Rubyforge, gem_server, etc) are short and to the point. The one omission, from my point of view, is that Dr Nic’s New Gem Generator isn’t mentioned as a resource for bootstrapping gem structure. This is an invaluable tool for creating new gems.

In any case, if you’re looking to broaden your Ruby tool belt, Practical Ruby Gems is sure to give you exposure to a few new tools. It would be a particularly good ‘bridge book’ for Rails developers who are looking to explore the world of Ruby possibilities outside of the web framework.

Turn On Your Buzzword Filter

2007-11-13T00:00:00-05:00

BigLove [12:37am]: my eyes crossed from all the buzzwords zapnap
zapnap [12:38am]: turn on your buzzword filter. OMFG WHERE DID T EH INTERNETS GO?

Digital Comics, Unlimited

2007-11-13T00:00:00-05:00

I’m not ashamed to admit that I’m a bit of a comic book geek.

When I was a kid, I was a hardcore fanboy who spent pretty nearly all his paper route money on weekly trips to the local comic shop in Dover. I have no apology for that. As a technology geek also, I’ve built a social comic book pull list organizer that has yet to officially launch (we’re looking for someone who’s excited about comics and community building, no techie skills required, email me if you’re interested!) and I’ve done a little ancillary plugin work for the geeky folks over at Heavy Ink too.

These days I buy mostly graphic novels, but I’ve always loved the feel of a floppy, and back when I used to buy titles monthly, there was just something unspeakably awesome about ‘new comic book day’ and the excitement of pouring through the stacks in a local shop looking for that one key back issue…

Like most fans, I have mixed feelings about the digitization of comics. On one hand, I’d probably read a lot more of them if they were available (ahem, legally of course) through a cheap, easy to use digital distribution service like iTunes. On the other hand, I’m sort of glad this hasn’t happened, because it would kill a lot of the allure of it for me if the comics on paper were to become a thing of the past.

I imagine I’m not the only one who was both excited and, at the same time, just a little tiny bit bummed about the announcement of Marvel Comics Unlimited yesterday (NOTE: as of right now the site appears to be down for maintenance, coming soon). The basic premise is that Marvel will offer an online archive of over 2500 back issues online in high-resolution format, starting at about $5/mo. They’re also making a free sampler of 250 titles available to wet your appetites.

Marvel’s hedging their bets a little though, which is smart. New issues won’t appear on the Marvel Unlimited site until six months after their initial print publication. This is great for those of us who read graphic novels, and aren’t used to picking up books every week anyway, and it keeps the floppies in circulation. After a bit of consternation, I’ve decided that it’s pretty much a win/win. Of course, as it always is on the web, the user experience will determine the ultimate success or failure of the venture. The flash-based digital comics I’ve seen from Marvel up to this point haven’t exactly been the most pleasant things to read, so here’s to hoping this is an entirely new interface to the library.

Anyway, I’m looking forward to reading more about this, both as a comic book enthusiast and as a technologist. Welcome to the 21st century, comic fans. For better or for worse.

It’s about time, I guess!

OS X Leopard Upgrade Notes

2007-11-11T00:00:00-05:00

Starting this blog entry to document any possible gotchas I experience on my upgrade to OS X 10.5. So far everything has been relatively clean. My only problem as of this writing has been with SSH and MacPorts. I have SSH installed via MacPorts and I noticed when doing any SVN+SSH operations, I was getting the following error:

percent_expand: NULL replacement
svn: Connection closed unexpectedly

Hmm, looks like Leopard is expanding some SSH environmental variable to NULL. An easy fix is to add the following line to your ~/.ssh/config:

IdentityFile ~/.ssh/id_rsa

This overrides the default search for your private key, and therefore you don’t get the percent_expand error. If anyone has more information about this particular issue, please let me know. Thanks!

Links For 11.10.07

2007-11-10T00:00:00-05:00

FreeBSD 7.0 is is going to own scaling. Srsly. RC1 should be available this week.
Rails 2.0 RC1 is here. Have you fixed those deprecation warnings in 1.2.5 yet?
Heroku is coming next week. Holy crap those screencasts are cool. So the future of building and hosting webapps looks a lot like Seaside, eh?
More Heroku coverage and commentary by Giles Bowkett.
The Great Merb Speedup. Keep your eyes peeled for 0.4.1, things in this camp keep getting better and better.
Interesting critique of OpenSocial from Tim O’Reilly.
Google’s OpenSocial API Blog, because it’s the new hotness.
Using OpenSocial with Ruby on Rails, because hey, you’re curious, right?

NH Ruby Next Monday Night

2007-11-09T00:00:00-05:00

As Scott notes over on his blog, this month’s NH Ruby meeting will be off by a week and a day this time around, due to holiday stuff. Instead of the third Tuesday of the month, it’ll be the second Monday. Yessir, that’s this coming Monday.

My good friend Dave Berube will be the main speaker, and he’ll be discussing reporting techniques with Ruby and Rails. Dave is putting the finishing touches on a new book on the subject, so he knows of that which he speaks. It’s sure to be a good conversation and if you’re in the area, you should definitely check us out.

Flexible Payments With Rails & REST

2007-11-09T00:00:00-05:00

Anyone who’s been playing around with the original Rails version of the Amazon Flexible Payments Service sample application has probably spent a fair amount of time swearing and complaining about how incredibly un-idiomatic and ugly it is. I know I have. It’s not that we don’t appreciate Amazon wanting to play ball with us, it’s just that it’s… well… it’s damn ugly.

But wait, a few weeks ago, a new REST-based Rails sample app was posted. This time around it’s a far more basic “hello world”-ish app, but it’s much more idiomatic and clean, a far better starting place for anyone who wants to learn how to make pay calls with FPS using Ruby and Rails. It’s also thankfully devoid of soap4r dependencies.

Just thought I’d note that, in case you’re working with FPS and haven’t stumbled upon it yet.

In related news, there’s a RubyForge project for a library called Remit, which purports to be a proper Ruby API wrapper for FPS. Tyler Hunt is the developer who’s registered the project and is working on it. With no updates since early September though, and no files released, I wonder if the project hasn’t maybe been aborted? Tyler, if you’re out there, give a shout and let us know if you need a hand.

Merbivore!

2007-11-07T00:00:00-05:00

Merb 0.4 was released earlier today, and the men of Montreal were thus elated. For those that are unfamiliar with it, Merb is a Ruby MVC web framework not unlike Rails, but focused more on speed and minimalism. It’s a lot like a thread-safe closer-to-the-metal reimplementation of ActionPack. This also means it’s ORM agnostic (big, big win) and JavaScript library agnostic. Plugins are just gems (dependency management ftw), and it’s fast and easily extensible. If you haven’t used it before, now’s the time to get started!

gem install merb -y

The release announcement on Ezra’s blog has a nice summary to some of the more significant improvements, and links to more in-depth coverage. Along with the gem update comes a brand spankin new website, merbivore.com to boot. Congrats guys, on what looks like a huge leap forward. I can’t wait to dig in tomorrow.

Drop A PID For Monit

2007-11-06T00:00:00-05:00

If you ever need to drop a pid from a Ruby process it’s dead simple:

File.open('myapp.pid', 'w') { |f| f.write(Process.pid) }

Now you can use Monit to keep Sinatra alive, for instance ;-). Monit is great for monitoring UN*X processes and keeping them running under ideal conditions, and that means it’s great for Mongrel, and anything that runs through Mongrel. Monit can even check the memory consumption of your application and restart it if it seems to be leaking. Not that that ever happens, of course.

I Am Not A Freeloader

2007-11-06T00:00:00-05:00

So have you heard the new Radiohead album yet? What did you think? And more importantly, what did you pay for it? ComScore estimates that 2 out of 5 of you did. They released a study today suggesting that, during the month of October, 40% of visitors were willing to pay an average of $6.00 for the digital downloads. Click that link for the full details. It’s also interesting to note that US consumers were will to pay more, on average, than the rest of the world.

The press is having a field day with this, and opinions are mixed. The ‘glass is half empty’ point of view seems to be that, holy crap, there are a lot of freeloaders on the ’net.

No kidding, really?

On the other hand, the ‘glass is half full’ folks point out that, hey, people are actually willing to pay for stuff, and that music on the ’net still has a perceived value after all.

I’m siding with the latter camp. Official sales figures won’t be released until after the holidays, but shit, I think these initial estimates are fantastic. Moreover, I think they show tremendous potential for non-compulsory tipping for digital goods in the public space. Software and media piracy is only a problem because of how we perceive and hope to profit from selling media on the web. Labels don’t need a new type of DRM, they need a new approach to what they’re selling. It’s information, and once that information is out there, it’s free, regardless of how much you perceive it’s worth to be. Magazine publishers figured this out a while back, and make their money through online advertising.

What Radiohead has done is adapt, and prove that, at least to some extent, a donation-driven model can work here. Of course, public radio beat them to the punch by at least 50 years, and they’re not the first band to sell music online, but it certainly signals a big win for those of us who believe that all web users aren’t freeloading scum. Even if the average user is a freeloader, the point is that the band can make enough from their efforts such that producing art for public consumption is profitable.

Anyway, the average worldwide price for all downloads, including freeloaders, was $2.26. I’d love to know what the bands’ actual per-album net was on their previous album, 2003’s Hail To The Thief. I’d be shocked if it was much higher than, say, $6.00 (update: this article estimates that it was probably between $3 and $5 USD). Personally I paid about $7 USD.

Oh, and the album is pretty good too.

Clone Pastie in 15 Minutes with Sinatra & DataMapper

2007-11-05T00:00:00-05:00

Hey there, put on your tutorial hat. Today we’re going to learn how to write a dirt simple pastie clone using Sinatra and Datamapper. For those of you unfamiliar with pastie systems, they’re commonly used in IRC to paste bits of code to a globally-visible place outside of the channel. So you copy some code from your IDE, paste it into a web page, submit it, and the Pastie system fancies it up with some syntax highlighting or whatnot. You can then copy the resultant URL and paste it back into the channel so other people can view it.

Examples of this type of service include pastie.caboo.se and Nopaste @ rafb.net. Those sites do a lot of extra cool stuff, like allow you to select the language for different syntax highlighting, select themes for viewing, and so on. But the core concept itself isn’t a terribly complex one, and our example is going to be about as barebones as they come. The interesting thing isn’t the application we’re going to build here so much as it is the tools we’ll use. That is, we’ll be using the pastie example to introduce you to two cool new pieces of Ruby tech: Sinatra, a new web micro-framework, and the DataMapper ORM package.

Sinatra, on the surface, is a lot like Camping, another Ruby web all-in-one-file micro-framework. Camping hasn’t seen any active development in quite some time though, and the syntax can be a bit strange for new users. Sinatra is much more straight-forward and accessible. It’s really a kind of domain-specific language for writing simple web applications, used to define RESTful actions and how they should be handled. This makes it perfect for lightweight mini-apps. It’s also completely ORM-agnostic, instead of being married to ActiveRecord like both Rails and Camping are. For more information, check out the ‘official’ tutorial.

DataMapper is the new ORM package on the block, and an alternative to ActiveRecord (and Og and Sequel and so on). It just moved into town but it’s already sitting at the cool kid lunch table. Whereas AR implements the ActiveRecord Pattern, DataMapper (surprise!) implements the DataMapper pattern. There are a number of reasons why I prefer this approach, but that’s probably fodder for an entirely separate blog post, so I won’t get into that here. Besides, the team has already written a great summary of why DataMapper rocks. Read it. Oh, and performance kicks ass now too.

OK, anyway. Tutorial time. Found your plastic hat? Good. Let’s go. First let’s get the gems we’ll need. As of this writing, DM is at v0.2.3 and Sinatra is at v0.1.7. We’re also going to retrieve the Syntaxi gem, which we’ll use for syntax highlighting.

sudo gem install sinatra datamapper json syntaxi -y

Since DM uses the DataObjects.rb drivers, you’ll want to install them. They’re packaged with the distribution. For our purposes here we’re going to assume you’re on MySQL but all the standard drivers are there, so don’t fret. Change to your DM gem directory (mine is /opt/local/lib/ruby/gems/1.8/gems/datamapper-0.2.3) and issue the following command. Ignore any warnings that are generated. If you’re on OS X 10.5, you may want to check out Heimidal’s blog for instructions.

sudo rake dm:install:mysql

Now that our prerequisites are satisfied, let’s get started by creating the file toopaste.rb:

require 'rubygems'
require 'sinatra'
require 'data_mapper'
require 'syntaxi'

### SETUP

DataMapper::Database.setup({
  :adapter  => 'mysql',
  :host     => 'localhost',
  :username => 'root',
  :password => '',
  :database => 'toopaste_development'
})

### MODELS

class Snippet < DataMapper::Base
  property :body, :text
  property :created_at, :datetime
  property :updated_at, :datetime

  validates_presence_of :body
  validates_length_of :body, :minimum => 1

  Syntaxi.line_number_method = 'floating'

  def formatted_body
    html = Syntaxi.new("[code lang='ruby']#{self.body}[/code]").process
    "<div class=\"syntax syntax_ruby\">#{html}</div>"
  end
end

database.table_exists?(Snippet) or database.save(Snippet)

### CONTROLLER ACTIONS

layout 'default.erb'

# new
get '/' do
  erb :new, :layout => 'default.erb'
end

# create
post '/' do
  @snippet = Snippet.new(:body => params[:snippet_body])
  if @snippet.save
    redirect "/#{@snippet.id}"
  else
    redirect '/'
  end
end

# show
get '/:id' do
  @snippet = Snippet.find(params[:id])
  erb :show, :layout => 'default.erb'
end

Next we’ll dissect this code listing to give you a feel for how Sinatra and DataMapper work, and show the code listings for our views as we get to them.

First of all, we define our database connection for DataMapper. Looks pretty similar to its AR equivalent, eh? Before we can run this we’ll need to create the MySQL database mentioned in the source. You can create the toopaste_development database by issuing the following mysql command:

mysqladmin -u root -p create toopaste_development

We’re not going to define a migration here, as this is a very simple case, but DM does support migrations in case you’re curious. We next define our model, Snippet, which inherits from DataMapper::Base. The validators we’re specifying look familiar to anyone coming over from AR but the property declarations might look a little bit odd at first.. OMG I don’t have to put comments in my source file to remind me what attributes are available on my models?!

property :body, :text
property :created_at, :datetime
property :updated_at, :datetime

It’s like a little slice of heaven, isn’t it?

Skip over the formatted_body method for a moment and look at the line after the model class declaration that checks for pre-existence of the table. You’ll note that if it’s not found we call database.save with the model name as a parameter. This creates our table, with all the appropriate fields, as specified in the model.

database.table_exists?(Snippet) or database.save(Snippet)

The formatted_body method is simple. It just takes the body of our snippet (a property on the model) and wraps it in some code that gives us pretty syntax highlighting and line numbering. Syntaxi leverages Jamis Buck’s Syntax gem to mark up the specified code, wrapping CSS span tags around things that should be colored, adding line numbers, and some other goodies too. You’ll see the CSS in our layout shortly.

Another interesting DM optimization worth noting: by default, the text field (body) is lazily loaded. Text columns are expensive in databases, and by using lazy loading, we only access them when they’re needed. This speeds things up significantly in most cases. However, if you don’t like it, you can just pass a :lazy => false option in the text column property declaration.

Moving on to the controller actions, you’ll see that routes and actions are intimately married in Sinatra. Although this isn’t desirable for a larger application, it’s great for quickie one-off web apps like this pastie project. We only have three actions and they’re only ever available at these three URL patterns.

get '/' do
  erb :new, :layout => 'default.erb'
end

The first action displays a form to create a new paste, and it’s always available at ‘/’, your application root. Note that it’s a GET request. The body of this action renders the new.erb template, which should be in your views/ subdirectory. Instead of pulling in an external template, you could just stash your HTML inline here. This may work fine for dirt-simple applications but I prefer to keep it separate. Here’s that first view, /views/new.erb:

<div class="snippet">
  <form action="/" method="POST">
    <textarea name="snippet_body" id="snippet_body" rows="20"></textarea>
    <br/><input type="submit" value="Save"/>
  </form>
</div>

The next action is analogous to a #create action in RESTful Rails. The action is requested by a POST to the application root. Sinatra supports the standard GET and POST HTTP methods as well as PUT and DELETE, meaning that you can build RESTful applications with it.

post '/' do
  @snippet = Snippet.new(:body => params[:snippet_body])
  if @snippet.save
    redirect "/#{@snippet.id}"
  else
    redirect '/'
  end
end

Pretty standard stuff, right? We retrieve the parameter posted from the submit action in the new paste form, instantiate a new model and try to save it. If the validations pass, we redirect to the #show action equivalent. If not, we’re just going to dump you back to the #new form again. Since the only way the action will fail is if the body property is empty, we’re not going to bother with any sort of error message at this time. We’re not rendering anything here (merely redirecting), so no template is required.

If our post is successful, we’re going to be taken to the #show action, which lives at /:id, where :id is the primary key of the corresponding database record. This action will also get accessed directly when you paste that URL to the chat room, and people click to view your code.

get '/:id' do
  @snippet = Snippet.find(params[:id])
  erb :show, :layout => 'default.erb'
end

In the code listing above, we look up the particular snippet specified in params[:id] and set an instance variable. We then render an ERb template, which of course has access to that instance variable. Here’s the code you’ll want in /views/show.erb:

<div class="snippet">
  <div class="sbody" id="content"><%= @snippet.formatted_body %></div>
  <div class="sdate">Created on <%= @snippet.created_at.strftime("%B %d, %Y at %I:%M %p") %></div>
  <br/><a href="/">New Paste!</a>
</div>

If you’ve been paying attention you’ve noticed that both of our erb method calls (used to render an embedded ruby HTML view, you can also use haml) have specified a layout. That layout does the sorts of things a layout usually does; it sets up the page body, the title of the page, the styles, and so on. For completeness’ sake, we’ll list it here:

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <title><%= @title || 'Toopaste!' %></title>
  <style>
    html {
      background-color: #eee;
    }
    .snippet {
      margin: 5px;
    }
    .snippet textarea, .snippet .sbody {
      border: 5px dotted #eee;
      padding: 5px;
      width: 700px;
      color: #fff;
      background-color: #333;
    }
    .snippet textarea {
      padding: 20px;
    }
    .snippet input, .snippet .sdate {
      margin-top: 5px;
    }

    /* Syntax highlighting */
    #content .syntax_ruby .normal {}
    #content .syntax_ruby .comment { color: #CCC; font-style: italic; border: none; margin: none; }
    #content .syntax_ruby .keyword { color: #C60; font-weight: bold; }
    #content .syntax_ruby .method { color: #9FF; }
    #content .syntax_ruby .class { color: #074; }
    #content .syntax_ruby .module { color: #050; }
    #content .syntax_ruby .punct { color: #0D0; font-weight: bold; }
    #content .syntax_ruby .symbol { color: #099; }
    #content .syntax_ruby .string { color: #C03; }
    #content .syntax_ruby .char { color: #F07; }
    #content .syntax_ruby .ident { color: #0D0; }
    #content .syntax_ruby .constant { color: #07F; }
    #content .syntax_ruby .regex { color: #B66; }
    #content .syntax_ruby .number { color: #FF0; }
    #content .syntax_ruby .attribute { color: #7BB; }
    #content .syntax_ruby .global { color: #7FB; }
    #content .syntax_ruby .expr { color: #909; }
    #content .syntax_ruby .escape { color: #277; }
    #content .syntax {
      background-color: #333;
      padding: 2px;
      margin: 5px;
      margin-left: 1em;
      margin-bottom: 1em;
    }
    #content .syntax .line_number {
      text-align: right;
      font-family: monospace;
      padding-right: 1em;
      color: #999;
    }
  </style>
</head>
<body>
  <%= yield %>
</body>
</html>

Save that listing as views/default.erb. The rendered page content will be inserted into this layout where it yields. And that’s pretty much it. You can fire up your new Sinatra and DataMapper-powered application by issuing the following command:

ruby toopaste.rb
== Sinatra has taken the stage on port 4567!

Sinatra sits on top of Mongrel, making it super-easy to use (and thread-safe to boot!). If you open up a web browser and point it at http://localhost:4567 you’ll see the results. You now have a fully functional (albeit slightly retarded) pastie clone with syntax highlighting for Ruby code snippets. And the core logic is all contained in a single file, with a few external ERb templates for cleanliness.

If you like, you can play with the finished app or download the sources. Enjoy, and please comment if you have any problems or suggestions for improvement. This code was written and tested on OS X 10.4 and Debian Etch.

UPDATED 07/02/08: I finally got around to updating this tutorial for DataMapper 0.9.2. About time, eh? Click here to see the new version.

Blog Updates

2007-11-01T00:00:00-04:00

So I finally got around to migrating the blog site over to Mephisto. I’ve only been planning on doing that for like 9 months. Horray for progress!

Links For 10.30.07

2007-10-31T00:00:00-04:00

Not-so-random things you need to know about:

New Ruby Logo Unveiled
NetBeans 6.0 Beta 2 Released
Datamapper ORM (add Merb, stir, & bake at 300 for gooey goodness)
Git + Sinatra Web Framework (great screencast!)
Using MacPorts Ruby and Rails after Upgrading to OS X Leopard
Microplace (eBay-backed microfinance on Rails)
Google OpenSocial to Launch on Thursday?

Startupping Contests

2007-10-30T00:00:00-04:00

So Ty and I submitted our startup project’s pitch to the Amazon Startup Challenge last night. Wish us luck!

The idea (currently implemented as a working prototype, albeit with a number of rough edges) has to do with micropatronage, a concept that is near and dear to my heart. In a nutshell we believe that content authors should be rewarded for their efforts, and we think we’re on to a way to make that fun and rewarding for patrons too.

It’s something we’ve been developing on and off for months now, in between various other client gigs and open source initiatives. We have no illusions about being chosen (although it sure would be nice if we were!), but if nothing else the contest has given us the kick in the butt that we needed to get back on track with it and formalize a number of principles in writing. Writing things down, and trying to explain them to people whom you’ve never met before, always helps to clarify your vision. It’s quite amazing, really.

Anyway, I love seeing contests like this, even when I don’t win (which is most of the time). I thoroughly enjoyed my role as an organizer of the Rails Rumble event we ran in September, and I look forward to similarly-minded events like the upcoming BlitzWeekend (hi Heri!), and even the more VC-involved “contests” like Seedcamp and of course Y Combinator.

I particularly enjoy following startup contests and events where creativity is a key factor; where instead of just implementing a common spec to see who can do it fastest or “best”, teams are actually challenged to invent something totally new, implement it, throw it against a wall and see if it sticks. Hey, now that’s entrepreneurial; it’s brave, it’s somewhat reckless (in it’s purest form, anyway), and it’s a great way to hatch new disruptive ideas in front of a live audience.

Some of the projects will be great, most of them will suck, but everyone will learn something. It’s important to remember, too, that the “winning” team won’t necessarily be the long term winner — it’s a distance running event, not a short sprint. In the end, it’s all about development — and I mean that in the personal growth sense, not in the geeks-behind-glass sense.

Of course, you don’t need a contest or money or really anything at all to go invent something new, especially these days when launching a company doesn’t cost anything more than the skills, free time, and a VPS. But sometimes a little extra motivation goes a long way.

JQueryCamp Is Tomorrow!

2007-10-26T00:00:00-04:00

For anyone who’s registered (and presumably in or around the greater Boston area), don’t forget that JQueryCamp is tomorrow! I’ll be there, and looking forward to talks by John Resig, Yehuda Katz (whom I probably owe a beer), and many others.

Git Your Learn On

2007-10-22T00:00:00-04:00

Any post about Git pretty much mandates the use of some lame pun in the title, and this blog entry is no exception. For those of you who are as-of-yet unfamiliar with it, Git is a distributed version control system created by Linus Torvalds. It’s been around and usable for about a year now, but I’d only been peripherally aware of it until recently.

In the past I’ve just used it to check out and occaisionally toy with the latest Rubinius sources but now that the Offtrac project is using it, it finally looks like I’m going to have to start familiarizing myself with it beyond installation and cloning a remote repository. If that sounds negative it isn’t meant to be; I enjoy being forced to learn new things every once in a while. Srsly.

[To be honest I’m still relatively happy with Subversion, but hey, when I started using Subversion I was still at least relatively happy with CVS too. No wait, scratch that, I hated CVS.]

Anyway, for those of you out there like me who are just getting acquainted with Git and particularly those who are stumbling over the implications of the distributed part of distributed version control, Carl Worth has written a useful getting started guide that you should definitely check out. Of course there’s the official user guide too.

In practice, normal usage really isn’t as different as it seems, and the concept of a distributed repository is a truly powerful one. Everyone has commit access to their own local branch, which means most operations are fast, and the centralized who-gets-commit-rights question becomes a total non-issue. That’s very very cool. Oh, and no .svn folders littered in every folder is another nicety. The jury’s still out for me as of right now, which is to say I’m not rushing to switch all my existing Subversion projects over just yet. But I have to say, I’m very intrigued so far.

718-123-2083

2007-10-22T00:00:00-04:00

Someone rings my cell phone at 7AM this morning and asks “is this Nicholas”? I answer “yes”, because well, that’s my name. Then they hang up.

Apparently I’m not the only one this has happened to. Isn’t it good to know that there are communities for just about everything on teh Interwebs, including strange paranoia-inducing phone spam? But just who the fsck are these people anyway, and what in the world was the purpose of that? Sigh.

In unrelated but positive news, the Sox destroyed the Indians last night 11 to 2, winning the ALCS. Yes, I am a fair weather fan.

Where's Nap?

2007-10-12T00:00:00-04:00

Things have been kind of crazy lately, and blog updates have been few and far between. Sorry about that, it’s not that I’ve run out of things to say. Honest.

The truth of the matter is I’ve just been really busy with a couple client projects, and some other goodies that I’ll (hopefully) be writing about soon. And oh, yeah, I’m getting married this weekend too ;-).

So actually, the answer to the titular question is Martha’s Vineyard, where my lovely wife-to-be and I are renting a house for the week. It’s great to get away from (almost) everything for a little while.

Rails 2.0 Preview Release Available

2007-10-01T00:00:00-04:00

Check it out: a Preview Release of Rails 2.0 was made available yesterday. Things are “almost finished” and this is an opportunity for folks (who haven’t been following edge closely) to get a taste of what’s new before the final release. To install the gem:

gem install rails --source http://gems.rubyonrails.org

Or you can freeze edge using the tag “rel_2-0-0_PR”. Make sure to check out that post (linked above) to read about all the good stuff.

Note that 1.2.4 will also be released prior to 2.0 and will include a variety of bugfixes as well as the final deprecation warnings for upgrading an application to 2.0. Big thanks to the whole core team (and all the contributors) for their excellent work.

Presenting @ Ruby East

2007-09-28T00:00:00-04:00

I’m going to be at Ruby East on — oh wow, I’m already here. Hrmm, well nevermind then. Obviously things have been much too busy for pro-active blog entries lately. Sorry about that.

In any case, if you’re here, make sure to hang around until the end to see my Rails Rumble talk, which will include announcing the winners. We’ll also be showing some of the team screencasts, in order to demonstrate just how much you can accomplish with Ruby in a very short amount of time. Should be a fun way to close out the event.

If you’re not lucky enough to be attending this great little regional conference, the winning teams will also be announced on the Rumble Blog sometime later today. Great work everyone.

NetBeans 6.0 Beta 1 Available

2007-09-19T00:00:00-04:00

NetBeans 6.0 Beta 1 is out and ready for download, including a slimmed-down Ruby-only version for those of you who don’t want all the extras. Personally I like having one IDE for both Java and Ruby but hey, I’m special. As I’ve written about before, I’m quite smitten with NetBeans and this latest release is the best yet. If you’re curious about why I’m gushing over it, read here, here, and here.

So yeah, it’s nice. Go download 6.0 Beta 1 and give it a try. It’s packaged with JRuby 1.0.1 and Glassfish v2, which is starting to look more and more attractive as a serious deployment option for Rails.

PS: those of you who are frustrated with Goldspike may want to take a look at Nick Sieger’s Warbler, an alternative for packaging up your WAR files.

PPS: you don’t have to use JRuby as your interpreter of course. Just go to preferences → Ruby and point it at MRI (/usr/bin/ruby or whatever) if you don’t want / need / like JRuby. And then you can use the fast debugger too. Inline Ruby debugging rocks.

Rock The (Rumble) Vote

2007-09-15T00:00:00-04:00

We launched the Voting portion of the Rails Rumble on Thursday evening, and so far it’s been a tremendous hit. Almost 4000 unique votes have been recorded in less than two days. If you check out vote.railsrumble.com you can view the current top 10 ranked applications as well as a smattering of random entries.

I want to reiterate once again that I’ve been overwhelmed with the creativity and polish that are reflected in a lot of these entries. Many of them look like the teams spent two months instead of two days. I’m not going to name any names, but I definitely have my list of favorites.

So anyway, get off your butt, register to vote, and help the community choose the best 48-hour app! You don’t even have to go down to the local high school or anything. Woot! The voting period lasts two weeks, and wraps up on the 27th, after which winners will be announced at the Ruby East conference. Maybe I’ll see you there?

Overlooking The Obvious

2007-09-14T00:00:00-04:00

Sometimes we overlook the obvious. This had me scratching my head for a good 15 minutes yesterday. I’ll blame it on the plague (aka nasty cold) that I seem to have contracted.

>> format = "%A, %B %d %Y"
=> "%A, %B %d %Y"
>> monday = Time.now.beginning_of_week
=> Mon Sep 10 00:00:00 -0400 2007
>> monday.strftime(format)
=> "Monday, September 10 2007"
>> (monday+6.weeks).strftime(format)
=> "Monday, October 22 2007"
>> (monday+12.weeks).strftime(format)
=> "Sunday, December 02 2007"

Huh? Exactly 12 weeks from Monday is Sunday? WTF?

>> monday + 12.weeks
=> Sun Dec 02 23:00:00 -0500 2007
>> (monday + 12.weeks).dst?
=> false
>> monday.dst?
=> true

Three letters: <a href="http://en.wikipedia.org/wiki/Daylight_savings_time">D S T</a>. Heh.

Can You Feel The Rumble?

2007-09-08T00:00:00-04:00

So the Rails Rumble is on! We’ve worked pretty hard to hook this up and it’s great to see it alive and breathing, and #railsrumble buzzing with activity. There were some capacity issues at first (ouch!) but things seem to be going pretty smoothly now.

Greets to Carter Parks, Rodrigo Kochenburger, and Erin & Tommy Shine, who all poured a lot of precious blood into this beastie. And our friends Chris Aker and Tom Asaro at Linode. And our other sponsors too, of course. Oh, and best of luck to all the Rumblers. Launch some cool-ass web properties and win some swag, guys! Hope you’ve got plenty of Red Bull to keep you caffeinated.

Me? I’m going to bed. See you tomorrow in IRC.

Moving to Nginx and Cap2.0

2007-08-27T00:00:00-04:00

So a few months back I started using nginx on my staging server, front-ending for Mongrel, and just recently I’ve stated migrating some production stuff over to it. It’s pretty great as a lightweight Apache replacement. Incredibly simple syntax, very quick and close to the bone. Most of my production stuff still runs on Apache, but that may soon be changing. I also finally made the leap to Capistrano 2.0. Loving the new namespaced task hierarchy.

Anyway, here’s a simple alternative maintenance page recipe for Capistrano’s deploy:web:disable target and the corresponding Nginx config to make use of it. In case you’re unfamiliar with it, the disable web task basically redirects all requests to a maintenance page until deploy:web:enable is run, which returns things to normal. This recipe assumes you’ve created your own (static) maintenance.html page in public/maintenance.html and that it makes use of existing stylesheets and images — meaning that you don’t want to rewrite those requests.

in config/deploy.rb:

namespace :deploy do
  desc "Disable requests to the app, show maintenance page"
  web.task :disable, :roles => :web do
    run "cp #{current_path}/public/maintenance.html  #{shared_path}/system/maintenance.html"
  end

  desc "Re-enable the web server by deleting any maintenance file"
  web.task :enable, :roles => :web do
    run "rm #{shared_path}/system/maintenance.html"
  end
end

in nginx.conf (within your server block definition):

# allow requests for images, js, css, and icons to go through
# even if cap has been used to disable the site
if ($request_filename ~* /(images|javascripts|stylehseets)/) { break; }
if ($request_filename ~* \.ico$) { break; }

# for cap's deploy:web:disable task
if (-f $document_root/system/maintenance.html) {
    rewrite ^(.*)$ /system/maintenance.html last;
    break;
}

NHRuby: Shoes. And Belts. And You!

2007-08-21T00:00:00-04:00

If you’re in the greater NH/Maine/Mass seacoast area, don’t forget to check out tomorrow’s NHRuby group. Sir Brian DeLacey will be visiting us from Boston and talking about Shoes, the Ruby desktop UI toolkit from the ever-enigmatic _why.

If there’s time left to spare, I’ll probably spend some time blathering on about how you should participate in the upcoming Rails Rumble. Believe me, after seeing some of the prizes, you’re going to want to get in on the action. I was dead f**king serious about that championship belt. You’ll see.

NetBeans Rocks

2007-08-17T00:00:00-04:00

NetBeans really is the BOMB, as Charles Nutter notes over on his blog. Check out that link. I wanted to make sure I echoed his thoughts here, because for me, NetBeans really is the best Rails IDE on the planet. I switched over from IntelliJ some time ago and haven’t regretted it even briefly.

I really can’t say enough things about NetBeans. What other IDE makes it painless to debug (yes debug, within the IDE), refactor, and test your Ruby applications? Plus, the syntax highlighting is rockin and you get all the standard NetBeans goodness out of the box. Don’t want a huge download? No big deal, there’s a slimmed-down Ruby-only version available. Give it a shot. Even if you’re a hardcore Textmate geek, I think you’ll at least be able to see why I’m raving about it.

Get Ready To Rumble

2007-08-10T00:00:00-04:00

So like everyone else, you probably have a killer web app idea you’ve been sitting on. Maybe you’ve thought about building it, maybe you’ve even drawn out some diagrams on the back of a napkin, but you just haven’t found the time to execute it. The unfortunate reality is that sometimes you just need an excuse, or a little push, to get something awesome started.

Sound about right? Then this one’s for you. Enter the Rails Rumble, September 8-9, and consider yourself pushed.

Ruby, Rails, Micropayments, and Amazon FPS

2007-08-08T00:00:00-04:00

Last week Amazon unveiled a beta of their new Flexible Payments Service, a potential Paypal-killer and Google Checkout-killer, among other things. At first glance, FPS seems to be everything that Paypal isn’t: well designed, API-centric, and built with developers in mind.

While everyone is busy barking about how Amazon is going to go head to head with Google Checkout and Paypal for purchases, they seem to be missing the more interesting development here. I’m talking about something that neither Paypal or Google are even attempting to do, as far as I know: micropayments.

Ty, Steve, and I spent some serious time putting together a few different iterations of an idea/prototype earlier this year, that involves micropayments and the street performer protocol. And some other stuff, too :-). Unfortunately, when it came time to tie it into a payment gateway, it became painfully obvious that what we needed didn’t really exist, so we compromised. And that compromise led to a bunch of problems and eventually what we felt was an unworkable solution. So it’s been in mothballs since. This looks like it could be what we were maybe waiting for.

If you check out Amazon’s rate schedule you can see why I’m excited:

For Amazon Payments balance transfers < $0.05:
20% of the transaction amount, with a minimum fee of $0.0025

OK, OK, so 20% is a hefty fee but not when we’re talking about the alternative being somewhere in the neighborhood of $0.30 USD + 2-3%. So yeah, pfft. This is HUGE. And yes, it does look like these micropayments only work when you’re using Amazon payments (as opposed to using a credit card, etc) but so what? I’m not so sure that’s an obstacle.

Another reason it’s so interesting to me is that they’ve decided to support three languages/platforms in their initial beta rollout: Java, PHP, and yes, my friends, Ruby. Oh, and the sample app? Yep. Rails.

Why aren’t we more excited about this?

Impressed With Comatose CMS

2007-07-24T00:00:00-04:00

Often after I’m finished building the bulk of a web app, I find there are some secondary pages that need to be built. These pages are largely informational, such as an about page, a contact page, an FAQ, etc. They’re relatively static in terms of the content, but it’s always nice if we can supply our client (or ourselves) with a nice CMS-style interface to make updating them easy, and within the context of our existing application layouts. Keep it simple, keep it DRY.

The obvious thing is to cook up some sort of PagesController from scratch. This is nice because it’ll make use of your existing facilities, your authentication/authorization system, layouts, etc. It is custom, after all, and a custom fit is almost always the best fit. But it’s a fair bit of work for something that’s probably not ‘core’ to the application, and takes cycles away from other places they could be better spent.

On the other hand, you can integrate with a 3rd-party CMS or blogging package like Typo, Radiant CMS, or Mephisto. They’re all great packages and do what they do really well. The downside is you’ve got to write a fair amount of glue to hook everything together and make it look (and feel) uniform.

Another option is to use Matt McCray’s Comatose plugin, a micro CMS. It’s got all the basic functionality you want for this sort of stuff out of the box and it couldn’t be much easier to use. The real bonus is integration is almost completely seemless, which makes it (imho) the best of both worlds for this sort of project.

Installing the plugin gets you a ComatoseController and a ComatoseAdminController. You add an entry (or multiple entries, if you like) in your routes file to tell your application when to invoke the ComatoseController. You might prefer a scheme where all URLs starting with /pages are passed to Comatose, for example. Then you log into the admin controller (which also needs an entry in routes) to create the pages. All the basic management tools we need are here; pages are organized hierarchically and can be edited with great ease, using a variety of markup filters. Each page gets a number of attributes, including a title, keywords, author, etc.

Basically it’s everything we need for the bare-minimum no-frills CMS experience and nothing we don’t. Which is just the way I like it. Check it out for your next project.

UPDATE

Anyone having issues with Comatose and authentication should check out this bug report. If you’re specifying an alternate session key, you should put it in environment.rb instead of ApplicationController.

ActionController::Base.session_options[:session_key] = "_your_custom_session_id"

Comatose controllers inherit directly from ActionController::Base instead of from your application controller. So if you specify the session key in application.rb, the Comatose-driven sections of your app will be blissfully unaware of it. This means a method like logged_in? (which checks the session for your login status) will always report back as false.

Sidebar Login Box Recipe (restful_auth)

2007-07-13T00:00:00-04:00

One of the nice features of Rick Olson’s excellent restful_authentication plugin is the store_location facility. If you set up a :login_required before filter in your controller, the access_denied method will get called if the user isn’t logged in. The requested URL will be stored in the session and the user will be redirected to the login page. After logging in, redirect_back_or_default is called by SessionController#create, which pulls the location out of the session and redirects the user back to where they intended to go in the first place. Very slick.

However, if you’ve built an application which has a login box in the sidebar (I recommend simple_sidebar), restful_auth has no idea where you were coming from before the post to the create action. So you get redirected to the default (usually ‘/’) specified as a parameter to redirect_back_or_default. This isn’t usually what the user expects. They expect to be returned to the page they were looking at before if they log in from the sidebar. Oh noes!

Here’s a little recipe you can use to provide that…

First, a simple change to authenticated_system.rb in your lib/ directory (this file is created by the authenticated generator). Change the store_location method to this:

def store_location(location = request.request_uri)
  session[:return_to] = location
end

Before this change, store_location took 0 parameters and always set the return_to location to the current request URI. Now, we’ve modified it so it can (optionally) take the location to store as a parameter. If this parameter isn’t supplied, it defaults to the old behavior.

Next, change the create method in your session controller so it checks the HTTP referer. Just add one tiny little line to the top of the method:

def create
  check_referer
  ...
end

Now let’s write that check_referer method (it should be protected, not public):

def check_referer
  referer = request.env['HTTP_REFERER'] || ""
  if referer.match(request.domain) &&
    !referer.match(session_url) &&
    !referer.match(login_url)
      store_location(request.env['HTTP_REFERER'])
  end
end

What this little utility method does is check the HTTP referer. If the referer is from the current domain, and isn’t the session#create URL or ‘/login’ (in my application, there’s a login_path named route), we go ahead and store the location of the referer. This will later be plucked out by redirect_back_or_default. Note that you’ll need to regex match to make sure the referer value isn’t anything you don’t want to store. For instance, if the user navigates to the login page directly and logs in from there, you don’t want to redirect back to the login page on success. You probably want to redirect to the default page, which is whatever you’re specifying as the default with redirect_back_or_default.

So that’s it! An easy way to handle redirects from sidebar login blocks, without muddying the already elegantly designed redirects that happen when access is denied.

If you want to write a functional test for this, try something like this:

def test_redirect_to_referer # for login sidebar
  location = url_for(:controller => 'foo', :action => 'index')
  @request.env['HTTP_REFERER'] = location
  post :create, :login => 'quentin', :password => 'test'
  assert_response :redirect
  assert_redirected_to location
end

Swing Reduction Sauce

2007-07-12T00:00:00-04:00

JRuby continues to develop in interesting ways. Earlier today, Zed Shaw (Mongrel’s dad) announced the release of Profligacy 1.0, which you should take a look at if you’ve got a thing for building cross-platform desktop apps in Ruby. It’s pretty cool.

Profligacy is a (wildly extravagant?) library that purports to take the pain out of using Swing components with JRuby. It uses LEL, Layout Expression Language, to bring a sort of wiki-ish flavor to component layout. This is truly bizarre at first glance, but damn cool at the same time. Basically the Ascii art you lay out with LEL translates into a Swing GroupLayout. Ah-wha? Yep. Check out some examples. I told you it was cool.

It also does some other neat stuff like auto-converting procs to Listener interfaces, but I won’t go on about that, as you can go check the release notes instead. If you’ve ever worked in Swing before, you know how painful it can be. Profligacy makes it significantly less bitter to swallow. Now stop reading blogs and go build your first cross-platform Ruby desktop app. You know you want to.

An Introduction to Scraping with Hpricot

2007-06-30T00:00:00-04:00

For one of my hobby projects, I’ve been building a comic book release schedule webapp in Ruby. Obviously, a large part of that involves locating data sources for comic book publishers and importing those sources. Unfortunately, none of the major publishers have seen fit to make their release schedules available in RSS or Atom or an other structured format for that matter. Sigh.

Fortunately, all is not lost. With the Hpricot gem and a little scraping know-how, we can overcome almost any parsing obstacle, as long as the data is in a somewhat predictably arranged state. Let’s see how it works…

For our example, we’ll consider DC Comics, home of Superman, Batman, Aquaman, and… Super-Chief (Apache Chief? No, he’s different). DC makes their weekly release schedule available through their website at this URL. That’s nice and convenient. But it’d certainly be more convenient if they had a feed available. (If they do have a feed available, hidden deep within their website, and I haven’t found it, please let me know!)

As we click through to next/previous weeks and it becomes pretty clear that passing the dat= parameter gives you the appropriate listing. Note that they display a month at a time, so all you really have to do is ask for dat=01 every time. We’re going to build a little scraper that just grabs the current months’ books, but armed with the knowledge of how this works, you should find grabbing 3-4 months worth of books at a time to be no challenge whatsoever (comic book publishers usually solicit about 3 months in advance).

OK. So now let’s take a peep at the structure of the document itself. We can do this by just viewing source in a browser. It seems that every comic listed in the release schedule has a link to a full description of the issue, with a cover art previews, a short synopsis, writers/artists listed, etc. And every one of those links seems to have a CSS class of ‘contentLink’. Oh, lucky day.

This is certainly starting to smell like a job for Hpricot, the super fast (and delightful!) HTML parser for Ruby, written by the enigmatic why the lucky stiff. Gem install that sucker!

gem install hpricot

Now let’s fire up IRb and chew on some delicious Ruby syntax:

require 'hpricot'
require 'open-uri'

URL_DC = "http://www.dccomics.com/comics/"

doc = Hpricot(open("#{URL_DC}?dat=#{Time.now.strftime('%y%m01')}"))
books = (doc/"a.contentLink")
books.each { |book| read\_comic(book.innerHTML.strip, 
  "#{URL_DC}#{book.attributes['href']}") }

def read\_comic(title, url)
  puts "#{title} - #{url}"
end

Run that, and you’ll get a list of stuff that looks like this:

THE ALL-NEW ATOM #12 – http://www.dccomics.com/comics/?cm=7447
BATMAN: TURNING POINTS – http://www.dccomics.com/comics/?cm=7251

Each output line lists a title with a URL, for each comic solicited in a given month. How does it work? Well, first we open the URL and feed it into Hpricot. Then the line books = (doc/“a.contentLink”) uses a CSS selector to yank out just the elements that match the selector. We could have also used XPath-style syntax to accomplish the same thing. Anyway, those elements we’re selecting are all the links to comics being released this month. Hpricot hands us an array of these elements, and then we iterate over them, calling the read_comic function and passing it the title (the innerHTML of the link, stripped of excess whitespace), and the URL (an absolute link to the href attribute of the link).

Next, let’s beef up the read_comic function to do something useful. We’ll have it make another remote connection, this time to the URL specified for the detailed comic description, parse out the talent, description, and some other information about the issue and stuff it into a model object. But first let’s examine the source of one of those pages. The Trials of Shazam! #7 should do nicely.

We note in our examination of the page source that the data we want to scrape is all contained in tags, with different classes, as listed below. Note that this time we’ve chosen to use XPath-style syntax for the selectors. Note also that the span tag with class=“display\_copy” appears twice. The first time, it contains what appears to be the description of the issue, and the second time it lists the publication date. So instead of returning a single element, display\_copy gets an Array of 2 (or possibly more) elements.

def read\_comic(title, url)
  doc = Hpricot(open(url))
  display\_talent = (doc/"span[@class=display\_talent]").innerHTML
  display\_copy = (doc/"span[@class=display\_copy]") # 2 elements
  puts "====="
  puts "title: #{title}"
  puts "talent: #{display\_talent}"
  puts "copy (0): #{display\_copy[0].innerHTML}
  puts "copy (1): #{display\_copy[1].innerHTML}
end

Now we’re iterating through each book from the remote source, and dumping out it’s title, the writer and artist responsible for it, a quick synopsis, and some other information (publication date, etc). Alright. If we just had a Comic model in our application, we could be somewhere!

So let’s make one. In fact, let’s do it in Ruby, with ActiveRecord. First the schema:

DROP DATABASE IF EXISTS comics;
CREATE DATABASE comics;
USE comics;

CREATE TABLE comics (
  id int(11) NOT NULL AUTO\_INCREMENT,
  name VARCHAR(255),
  publisher VARCHAR(255),
  talent VARCHAR(255),
  description TEXT,
  published\_on DATETIME,
  PRIMARY KEY (id)
);

Load this up and then add the following code to the top of your comics scraper. In fact, put it in a file called comics.rb so you can execute it on the command line.

require 'active\_record'

ActiveRecord::Base.establish\_connection(
  :adapter  => 'mysql',
  :host     => 'localhost',
  :username => 'root',
  :password => '',
  :database => 'comics')

class Comic < ActiveRecord::Base
end

Now we’ve established a connection to the database via ActiveRecord and defined a Comic model that inherits from ActiveRecord::Base, thus wrapping our database schema and giving us some handy getters and setters. Our next step will be to trade in the read_comic function in favor of an import class method on the Comic model.

class Comic < ActiveRecord::Base
  def self.import(title, url)
    doc = Hpricot(open(url))
    display\_talent = (doc/"span[@class=display\_talent]").innerHTML
    display\_copy = (doc/"span[@class=display\_copy]") # 2 elements

    comic = Comic.new(:name => title)
    comic.publisher = "DC"
    comic.talent = display\_talent
    comic.description = display\_copy[0].innerHTML
    comic.published\_on = Date.parse(display\_copy[1].innerHTML.
      sub('on sale', ''))

    comic
  end
end

When Comic.import receives a title and a URL it makes a connection to the URL specified and fires up Hpricot. It uses Hpricot to parse out the information we’re looking for, and then instantiates an instance of the Comic class. We set the talent, the description (the first of the display\copy spans) and then parse the date out from the second display\copy span.

We’ll remove all the output from there and put it in the book loop, since it’s clearly not the job of the model code to be rendering a view of any sort. Our new book loop will use Comic.import on each element of the books Array, creating the model, saving it, and then printing out some attributes. Here’s the final code for comics.rb:

require 'rubygems'
require 'active\_record'
require 'open-uri'
require 'hpricot'

ActiveRecord::Base.establish\_connection(
  :adapter  => 'mysql',
  :host     => 'localhost',
  :username => 'root',
  :password => '',
  :database => 'comics')

URL_DC = "http://www.dccomics.com/comics/"

class Comic < ActiveRecord::Base
  def self.import(title, url)
    doc = Hpricot(open(url))
    display\_talent = (doc/"span[@class=display\_talent]").innerHTML
    display\_copy = (doc/"span[@class=display\_copy]") # 2 elements?

    comic = Comic.new(:name => title)
    comic.publisher = "DC"
    comic.talent = display\_talent
    comic.description = display_copy[0].innerHTML
    comic.published\_on = Date.parse(display\_copy[1].innerHTML.
      sub('on sale', ''))

    comic
  end
end

doc = Hpricot(open("#{URL_DC}?dat=#{Time.now.strftime('%y%m01')}"))
books = (doc/"a.contentLink")
books.each do |book|
  comic = Comic.import(book.innerHTML.strip, 
    "#{URL_DC}#{book.attributes['href']}")
  if comic.save
    puts "====="
    puts "name: #{comic.name}"
    puts "description: #{comic.description}"
    puts "release date: #{comic.published\_on}"
  else
    puts "uh-oh! we should handle errors!"
  end
end

And here’s the final result:

name: TRIALS OF SHAZAM! #7 (OF 12)
description: Freddy must find Hercules for his next trial,
which is considerably more difficult than he expected,
since Herc is behind bars!
release date: 2007-06-13

Obviously we can do a lot more with this. We can build a series model, that has_many issues or episodes. We can build a publisher model. We can suck in the images and use RMagick to generate thumbnails. We can discriminate between graphic novels, trade paperbacks, and issues of a standard series book. We can roll this into a Rails application, and allow the results to be browsable, users to add comics to their pull lists, create collections, comment on them, rate them, and so on. Actually, that’s exactly what I’m working on for my hobby project (if you’re interested, email me and I’ll let you take a look — I’m hoping to release it relatively soon-ish).

To go further with scraping, we’ll need to pay particular attention to handling errors, because it’s an inexact science and, since we have no hard format, things are subject to change or break in weird ways. That’s the obvious downside to scraping. But when you have no other alternative for automating mass import of data like in this scenario, it’s certainly a good thing to know how to do.

If you want to learn more, \_why’s Hpricot site is chock full of useful information, and you may also want to check out scRUBYt, which combines Hpricot and WWW::Mechanize into a full-on web scraping “toolkit”.

Thanks Akismet!

2007-06-22T00:00:00-04:00

I’m probably a bit behind the game on this one, but huge props are due to Akismet for making my blog life just a bit more pleasant. Before it was installed last week, I was deleting hoards of comment spam every day. Today, none.

In other blog-related news, I’m still planning on moving productions over to Mephisto, but have been hard pressed for time lately. Fortunately (when I get around to it), it has Akismet support baked right in.

UPDATE: finally moved over to a new blogging platform! About time, eh?

Tumbleranting

2007-06-18T00:00:00-04:00

Seth Godin is a nicer guy than I am (he’s probably better dressed, too): I would have ballparked his quote a little higher. Explanation: there’s a “don’t waste my time” fee.

As a freelancer, this happens to me all the time and it’s muy frustrating. I like hearing ideas, I like helping you structure your approach, I love developing solutions, applications, tools for you. I don’t even mind giving estimates and free advice. But in order to do that, you need to tell me what it is you want.

And no, “just like digg but with/for xxx” isn’t what I’m talking about :-).

JRuby / Goldspike / Glassfish Deployment Diary

2007-06-11T00:00:00-04:00

Robert Dempsey has written a pretty solid little tutorial on deploying your first JRuby on Rails app with Glassfish. It’s powerful stuff. Go read it now, damnit!

The process can still be a bit tricky the first time, especially if you have additional gem dependencies, etc. But once you get it running you’ll be blown away by how simple it is to create a .war and deploy it to any of numerous pre-existing Java application servers (Glassfish).

I had a few issues initially (particularly with openssl support), so I figured I’d document them as an addenum to Robert’s tutorial in case you’re interested. Read on to see my notes…

Make sure to set JRUBY_HOME in your environment. It’s used by Goldspike.
If both ruby and jruby are in your path, you can specify the ‘version’ of rake to use by doing: jruby -S rake. This will run the specific command in the JRUBY_HOME/bin directory.
Edit the goldspike lib/war_config.rb and change the line that reference jruby-complete version 0.99 to read:

add_java_library(maven_library ('org.jruby', 'jruby-complete', '1.0'))

This will look for JRuby 1.0 instead of 0.9.9. As of this writing you’ll also have to manually retrieve jruby-complete-1.0.jar as the remote sources don’t seem to have it yet. Put it in JRUBY_HOME/lib.

I happen to be using SSL in my app, so I had to gem install it into the JRuby environment using jruby -S gem install jruby-openssl Make sure the gem ends up in your JRUBY_HOME/lib/ruby/gems hierarchy. Tell goldspike it needs to add this gem with the following line: add_gem(‘jruby-openssl’)

If you’re doing the jruby-openssl thing you’ll also have to retrieve the latest version of the Bouncy Castle Crypto APIs package for whatever version of Java you’re using (I’m on OS X, Java 1.5). Put this in your JRUBY_HOME/lib directory and then add the library to your war_config.rb file:

add_java_library(maven_library('bouncycastle', 'bcprov-jdk15', '136'))

UPDATES:

Make sure to copy jdbc_databases.rake from ActiveRecord-JDBC to your lib/tasks directory (for ActiveRecord-related rake tasks). Thanks to Ola Bini for pointing me in the right direction there.

Include the following in environment.rb:

if RUBY_PLATFORM =~ /java/
  require 'rubygems'
  RAILS_CONNECTION_ADAPTERS = %w(jdbc)
end

JRuby Reaches 1.0

2007-06-10T00:00:00-04:00

JRuby 1.0 has been officially released. This is huge news. Complete compatibility with Ruby 1.8 is pretty much a done deal. Rails apps run. You can deploy your Rails apps in Glassfish. I mean, how cool is that?

You should check out team member Charles Nutter’s blog for more details. In a nutshell, the future looks like tighter integration with Java as an application platform, and a major focus on optimizing performance. Also a lot of interest in Ruby 1.9/2.0. If you attended Railsconf this year, you most likely got pretty excited about JRuby, and for good reason.

If you’ve never tried it out before, Atlantic Dominion Solutions has put together a great tutorial on getting started with JRuby on OS X. Or, even easier, go get yourself a copy of NetBeans 6.0 M9, which comes bundled with JRuby as the default interpreter for in-IDE development.

NHRuby Meeting Tuesday 06.12

2007-06-08T00:00:00-04:00

Usually the NHRuby meets are scheduled for the third Tuesday of the month, but we had to change it up this time due to some schedule conflicts.

I’ll be speaking about integrating a Flash widget with Rails-based RESTful web services and also giving a brief overview of how to contribute to Rails and other open source projects (I guess you could say Josh Susser’s talk at Railsconf inspired me). Scott will be doing an overview of the tabnav plugin and… something else, too.

More information and directions can be found at the NHRuby Wiki. Also, many thanks to our new host/sponsor for the meetings, RMC Research.

LOLCODE

2007-06-06T00:00:00-04:00

[3:44pm] strager: BUKKIT is the array type. [3:44pm] zapnap: O RLY?

has_much :confusion, :about => "string #{interpolation}"

2007-06-05T00:00:00-04:00

No matter how flexible ActiveRecord’s associations become, there’s always going to be a time when you want to override it’s baked-in smarts with your own custom SQL query. Fortunately, we can do just that with the :finder\_sql option. Use it to manually specify the association that should be returned.

There’s one gotcha to be aware of though: if you need to do any variable interpolation in the string (and you most likely will), make sure to use single quotes instead of the usual doubles:

has_many :transfers, :finder_sql => 
  'SELECT * FROM transfers ' +
  'WHERE sender_id = #{id} or receiver_id = #{id}'

When you use double quotes, the string interpolation happens immediately (when the class is first loaded), thus obtaining the object ID of the class in memory. Using single quotes, the interpolation occurs within the context of your object instance, which is what you’re expecting.

Caught In The Act

2007-05-31T00:00:00-04:00

Wow, Google Street View is totally great. And, as expected, some funny shit gets frozen in time at street level. Google is watching! Be cautious where you go, what you do! Try to remain calm, don’t lose your head over it.

ActiveRecord Delegation Pitfalls

2007-05-30T00:00:00-04:00

Delegation is a powerful concept. And it’s a useful Ruby mixin, too. You can use the delegation mixin to easily expose related objects’ methods as your own, which makes for much cleaner code than defining those methods by hand. However, there are some pitfalls to be aware of when dealing with delegation and the ActiveRecord lifecycle.

Here’s a simple example of delegation in action:

class User < ActiveRecord::Base
  has_one :homepage, :class_name => "Article"
  delegate :url, :to => :homepage
end

my_user.url => url of the home page article for this user

Yes, we could just call my_user.homepage.url here too. But there are definitely some situations where you’d prefer not to do this. I won’t attempt to relate my present situation to yours, as it’s outside the scope of this discussion. Anyway, the point is that delegation can be used to make your life easier.

Here’s where we get into trouble:

new_user = User.new
new_user.url

NoMethodError: You have a nil object when you didn't expect it!
The error occurred while evaluating nil.url

O NOES! What happened?

In a nutshell, when we use it in our model, the delegate class method defines a bunch of new instance methods on our User object. These methods simply forward their queries onto the target (:to) object. If the target object, at the present stage in the AR model lifecycle, happens to be nil, then we’re trying to call a method on nil. The nil object doesn’t have a url method, so we’re toast.

def #{method}(*args, &block)
  #{to}.__send__(#{method.inspect}, *args, &block)
end

How can we get around this? Well, court3nay opened a ticket to address this a while back. It was recently closed due to inactivity. I just reopened it, and added a small patch. Here’s the difference in the way the mixin creates the delegated methods:

-  #{to}.__send__(#{method.inspect}, *args, &block)
+  #{to}.__send__("nil?") ? nil : #{to}.__send__(#{method.inspect}, *args, &block)

Pretty simple really. We just test the delegation target to see if it’s nil first. If it is, we return nil instead of trying to send it a message. Otherwise, we call the method on the target object and let the receiver worry about it.

Huzzah, we’ve successfully delegated the task of dealing with nil delegation targets! Way special, eh?

Sometimes It's The Little Things, pt 2

2007-05-26T00:00:00-04:00

So my first patch to Rails core was accepted yesterday. It’s a tiny, tiny patch. All it does is add a :method parameter to the auto_complete_field helper so you can do RESTful autocompletion (the filter query should be submitted with a GET, not a POST, if you want to follow the REST conventions).

No big deal really, but it feels good to finally be able to “give back” to the community in a way other than blogging and IRC help. You know, with like, actual code that benefits people other than just me. I’ve contributed to a handful of Java and PHP-based OSS projects over the years, but this is officially my first contribution to a Ruby-based project, and that certainly feels like a step in the right direction.

Railsconf 2007 FTW

2007-05-21T00:00:00-04:00

Had a great time at Railsconf 2007! Just got back. A little jetlagged, and in need of (another) nap. In summary: lots of good presentations, superb microbrews, a hilarious zefrank performance, and a number of lurking lolcats.

Highlights for me included DHH’s keynote, the Rails way ‘live’ performance by Jamis and Koz (although I have to politely disagree with them on the need for private ActiveRecord attributes), Ezra’s deployment and scaling session, and the homesteading talk by Matthew Bass. Thanks to everyone who helped make it happen.

Also got to meet some fellow IRC peeps in person. Now ur tru idinty is nown to me, bewar!

Oregon

2007-05-16T00:00:00-04:00

So here I am in sunny Oregon. Around 1PM I hop on a train headed to Portland for RailsConf 07. Came out a few days early to catch up with my good buddy Ty in Eugene and work on the startup idea we’ve been banging around. And do some hiking, drinking, and dissecting of Heroes too, of course.

I kind of love being out here and yet still having my internal clock set to east coast time. I wake up “early” for a change, and bang out a nasty chunk of work before anyone else here is even awake yet. Otoh, I feel like an old man when I begin to falter around 11PM. Heh.

Anyway, I’m looking forward to the conference. I’ll be attending the tutorials day tomorrow, specifically the scaling session with Joyent’s Jason Hoffman as well as David Black’s ‘Routing Roundup’. If you see me, say hi.

Deconstructing date_select

2007-05-09T00:00:00-04:00

date_select and it’s friend datetime_select are handy little helpers for rendering date selection widgets in your form, but what they hand back to your controller is a little bit unintuitive. If you’re just going to go ahead and use update_attributes on your model, then ActiveRecord magically takes care of converting these to an appropriate Date or Time object for you. However, if you’re not doing that, you’ll find yourself staring at keys in your hash named odd things like “attribute(1i)”.

Here’s a handy little helper method, in case you ever need to manually reconstruct a Date object from the params:

# Reconstruct a date object from date_select helper form params
def build_date_from_params(field_name, params)
  Date.new(params["#{field_name.to_s}(1i)"].to_i, 
           params["#{field_name.to_s}(2i)"].to_i, 
           params["#{field_name.to_s}(3i)"].to_i)
end

date = build_date_from_params(:published_at, params[:article])

Put this in your ApplicationController so inherited controller classes can access it, or (better yet) put it in a suite of helper methods to mix in to application.rb. Not exactly brain surgery here, but I’m a little surprised that there isn’t something already baked into the helpers to do this.

MyConfPlan: Check Me Out

2007-04-27T00:00:00-04:00

Dr Nic Williams wrote a nice little app to allow folks to plot out the sessions they’ll be attending at Railsconf (or any conference, for that matter) and share them with others. In case you’re curious, check out my tentative session list.

Some of those decisions are tough ones! In particular, I’d like to see both Nutter’s JRuby talk as well as Dan Webb’s javascript-fu presentation. I’d also like to attend both Matthew Bass’ homesteading talk as well as Brian Leonard’s Tooling/NetBeans session. Sigh, decisions decisions.

Also of note: Dr Nic built MyConfPlan in Hobo, which seems to have come a long way since I last checked it out. Very cool stuff.

REST vs AutoComplete

2007-04-18T00:00:00-04:00

After struggling with it probably a little bit more than I should have, I’ve totally come around to the REST way of looking at things. It seems clean and nice, and I’m 100% behind it. That said, I’ve found that once you adopt the mentality, things that don’t gel with it start to stick out like the guy in the fur coat at the PETA meeting.

Case in point: the ever-popular Rails auto_complete_field helper. To back up my accusation here, let’s walk through an example scenario with a REST app, and examine the issues that arise…

Imagine a really simple web application which consists of a collection of Articles. The only user interaction is that guests can comment on articles and tag them with keywords. So in a RESTful world, we have an Articles resource, and a Tags resource. Tags are also nested on Articles such that when you ask for /articles/:article_id/tags you’re asking for the subset of tags which have been applied to article_id. We might present these as a tab you can click on when viewing an article resource in a browser.

Now let’s say that there’s a form somewhere (maybe the #new action on an ArticleCommentsController), which can be used to apply new tags to a given article. There’s an auto_complete_field in that form, that will suggest tags to apply to an article, based on the tags that have already been applied. Dumb example, I know, but hear me out.

So, given this scenario, it would make sense to point our auto_complete_field helper at article_tags_path(article_id). This is about as RESTful as it gets — we’ve become a client of our own API. Nice! Our #index action on ArticleTagsController, in a perfect world, would do a couple things above and beyond just displaying the pretty HTML list of tags on the article:

It would have a respond_to block. if a browser client is asking for XHTML, we probably want to render a nice paginated view of the relevant tags, ordered by weight, with a nice layout. On the other hand, if we’re asking for XML or JSON, it just returns no-frills data in the appropriate format.

it would optionally check for a filter query string. perhaps we set params[:filter] = :attribute_name and then make the actual string filter value (the thing we’re trying to help auto-complete) available via params[:attribute_name]. in the case of our tags example, we’d end up with a params hash that has filter=name and name=zer (or some other text string). If a filter parameter is found, we’d filter the results by the pattern specified. This could all be wrapped up in a nice little helper.

This proposal raises a couple issues. First, the auto_complete_field helper as it exists today expects us to return some HTML from the AJAX call that we can plug into an appropriately named DIV. This is simple and works well, but if we’re really consuming our own web service, we should probably be talking to it via JSON or XML and have a JavaScript handler to process the results, converting them into list format or whatever it is that we desire. But I have to admit that this convenient hack works nicely.

More importantly, if the auto-complete filter is being applied to the collection of resources, that means it maps to the #index action by way of a GET request. So our parameters end up encoded in the URL with a query string like ?filter=name&name=zer. Obviously, GET params are a little more limiting than POST params in terms of length and (perceived) security. But for simple filter strings that take a short sequence of characters, I don’t see this as being an issue. And this is always the case when doing an auto-complete, as far as I can figure.

Note that the auto_complete_field JavaScript helper doesn’t actually allow you to specify an HTTP verb other than POST, although that’s easy enough to change. Surely the core team would accept the one-line fix required to support a :method => :get option if it’s the “right thing to do”. The real problem is more of a philosophical one: are we, as a community, really going to embrace REST 100% or is it acceptable to add small bits of cruftiness in places where it seems inconvenient?

A perfectly legitimate half-way solution is to define a standard #autocomplete action for any resource you want to use in this manner. The advantage to this is that you can easily use a POST against a custom :collection method on the resource. That way, we continue to work inside the existing box of conventions. But I ask you, is that really RESTful?! What do you think?

NH Ruby UG Lightening Talks Tonight!

2007-04-17T00:00:00-04:00

Join us tonight at the Portsmouth Public Library for a bunch of lightening talks on Ruby-related subjects. I’ll be speaking on REST, Rake, and RMagick (if I can manage to put together a preso and demo app in time). Scott will be presenting a demo of his Rails-based ProgressPuppy task manager. And there will be other stuff, too.

Note that we’re still doing the meeting, despite aftereffects of the nasty coastal flooding. Hardcore, eh? As always, more information (including directions) can be found at the NHRuby Wiki.

RailRoad Class Visualization

2007-04-10T00:00:00-04:00

Just saw this InfoQ article about RailRoad and had to check it out. Gotta say, this is by far the best class visualization tool for RoR I’ve seen yet. Set your options, generate those DOT files, and then run them through GraphViz to export your image format of choice. Couldn’t be easier.

Check out some of the examples on the RailRoad RubyForge site, including the diagrams of the popular Depot example app and the much more complex Typo blog package. The latter is a good illustration of why the brief option is provided, heh. If you’re in the UML camp, you might be a little disappointed as the diagrams it produces are closer to BON, but personally I think they’re very straightforward and natural.

Whatever your modeling language preference is, I think we can agree that tools like this go a long way towards legitimizing Rails use in large multi-person projects and are, well, just plain helpful. Big thumbs up.

Paginating Associations

2007-04-10T00:00:00-04:00

It’s no real secret that the default Rails pagination helpers are kind of awful. Sure, you can use them, but I wouldn’t recommend it if you expect to scale. Instead, go snag yourself the wonderful paginating_find plugin. And then, if you’re going to be using them with your model associations, whip up an association extension like this:

module PaginationExtension
  def paginate(current = 1, size = 10, options = {})
    options[:page] = {:current => current, :size => size}
    find(:all, options)
  end
end

Now just extend the has_many association on your City class and you can call city.bars.paginate(2) to get the second 10-element page of bars associated with your city.

class City < ActiveRecord::Base
  has_many :bars, :extend => PaginationExtension
end

city.bars.paginate(2)

The good bars are all on the first page though, so consider yourself warned.

Rake: Ant Be Gone!

2007-04-02T00:00:00-04:00

I spent the better part of my morning today writing some code to do sample data generation within the framework we’re building. I’d originally packaged it as a standalone utility class to be run with the script/runner facility until I realized that it was a perfect candidate for a custom Rake task. And a perfect topic for a blog entry — two for the win!

If you’ve never written a Rake task before and are a Ruby pseudo-noob, fear not. If you’ve written Ant or Make scripts before, and have the requisite passing familiarity with Ruby, it’ll be old hat. Of course, the big win with Rake is that you get to write your tasks in Ruby. Sweet, sweet Ruby. No crufty XML here.

What follows is pretty minimalist, but I wanted to record it for posterity. Also, many of the tutorials I looked at didn’t deal with handling parameters, so I figured it might be useful to someone else out there…

namespace :foo do
  desc "Generate sample data for the app"
  task :sample_data => [:environment] do |t|
    require 'db/script/sample_data.rb'

    num_users = ENV.include?('NUM_USERS') ? ENV['NUM_USERS'] : 5
    SampleData.generate(num_users.to_i)
  end
end

What we’re doing here is defining a task named sample_data within the foo namespace. We declare a dependency on the Rails :environment, which is a little gift from the Rails team allowing you to write code in your tasks that lives within your app’s pre-existing environment. The desc line serves as a comment about what the task does, and will appear alongside the task name when you query it with the —tasks parameter.

Within the body of the task we simply require the script we’re going to run, in this case my virtually unmodified utility class, and then we check to see if a parameter named NUM_USERS was passed in. If it was, we use that value to determine the number of users to create. If it wasn’t, we default to 5.

Because Rails is smart, and talented in the mystical arts, it auto-loads any files in lib/tasks that have a .rake extension. So just plop this file in that directory and you can then check the available Rake tasks from the top level of your project. You should see our new task definition there:

$ rake --tasks | grep sample
rake foo:sample_data              # Generate sample data for the app

Rockin. So let’s run it. As you can see from the output below, it calls the utility calss, creating 10 sample users (and a bunch of other stuff I’ve excluded). Couldn’t be easier.

rake foo:sample_data NUM_USERS=10
SampleData: generating 10 users, blah blah blah...

I hope this has been helpful, and if you’re looking for more information, make sure to check out Martin Fowler’s seemingly definitive reference.

Sometimes It's The Little Things...

2007-03-29T00:00:00-04:00

With this latest RoR project, we decided for the first time to take a RESTful approach. It’s taken me much longer than it should have to come to terms with what that actually meant, but after suffering through the change of mindset, I really do have to say that it feels right. I’m down, you’ve won me over.

That said, there are always little implementation details that annoy the hell out of you. Little, trivial, stupid things. Things that you know you shouldn’t waste precious breath complaining about, things that you annoy your friends about until they ignore you. Things like the use of the damn semi-colon to delimit custom actions for resources in a URI, instead of our old friend the slash.

And then came Changeset 6485, which made everything once again right with the world. Thank gawd that’s over. Now I can get back to being productive :-).

NH Ruby UG Meeting.003 Tonight!

2007-03-20T00:00:00-04:00

If you’re in the seacoast New Hampshire area, don’t forget to attend tonight’s NH Ruby User Group meeting. Click on the link for directions.

Brian DeLacey will be speaking on Security and Cryptography in Ruby on Rails, and there will be some free book giveaways from O Reilly.

AR Model Initialization Notes

2007-03-16T00:00:00-04:00

If you’re new to Rails but not to Ruby, you might be surprised to learn that Rails doesn’t use the standard Ruby initialize() method when Model.new is invoked or when a model instance is returned from a find.

If you need to add some initialization code to an ActiveRecord model, use the after_initialze callback instead:

def after_initialize
  @thing = SomethingElse.new(self)
  @foo = 'bar'
end

March Reading List

2007-03-12T00:00:00-04:00

We’ve been hard at work lately, so blog updates have been a little more infrequent than I’d like. But in the meantime, I thought I’d post some books I’ve been reading. All come highly recommended.

David A Black’s Ruby For Rails – Essential Ruby/Rails reading. How did I get this far without it?
Founders At Work – Working on a startup? You should be.
Seth Godin’s Small Is the New Big – Learn how to be remarkable. Or at least, how to market your remarkability.
Y the Last Man – Damn, Brian K Vaughn rules. Plus, he likes The Eels. And he’s writing for Lost now, too. Read this, even if you don’t read comics.

Tweaking The Rails Logger

2007-03-05T00:00:00-05:00

The Ruby Logger is a simple but pretty flexible tool — hopefully you’re already using it. If not, you should be. The default logger message format is pretty barebones though, so I thought I’d take a few minutes to talk about how to make it more useful by monkey patching format_message.

First, make sure to check out TopFunky’s ‘Hodel 3000 compliant logger’ article, posted a couple months ago. Geoffrey’s syslog-friendly modification works great when running in production mode. Customized log messages are just as important in the development environment, where we’ve made our own simple modifications to include the name and line number of the file:

class Logger
  def format_message(severity, timestamp, msg, progname)
    "#{Kernel.caller[2]}: #{severity.upcase}: #{progname.gsub(/\n/, '').lstrip}\n"
  end
end

This little snippet is especially handy if you’re using an IDE like IntelliJ that’s smart enough to hyperlink the file path. Got an error being logged in users_controller.rb on line 91? Click on the hyperlink and you’re there.

It works by accessing the execution stack Array returned by Kernel.caller. caller⁰ will refer to the line in Logger#add where format_message is called. caller¹ is most likely going to point to one of the Logger# methods, one of [ debug, info, warn, error, fatal ]. This is the next level down in the stack, where the add method was called from. In most “application-level” code (code we actually write in our application, exterior to the benchmarking messages and such that Rails gives us for free), caller² is going to be something in our application code itself, some place that we called logger.info, or logger.error, or whatever, from.

To get this installed in our environment we create a file development_logger.rb, containing the source above. Then, in development.rb (or the initializer block of environment.rb):

require 'development_logger.rb'

This will “monkey patch” the Rails Logger, effectively overriding it’s format_message method with our own mojo. Sure, it’s not perfect. But it works great for development purposes. A more elegant way to do the same thing would be to subclass Logger and then do something like:

config.logger = DevelopmentLogger.new(config.log_path)

However, this just doesn’t seem to have any effect when running script/server, which proceeds as if config.logger is set to the standard (unmodified) Rails Logger. I’m at a bit of a loss as to why. If anyone can explain why setting config.logger seems to have no effect, please (please!) let me know.

New Ruby/Rails IDE Comparison

2007-03-03T00:00:00-05:00

Oh, what an IDE snob I’ve become over the past couple years. I was an advocate of lightweight text editors for dev work for a long time, and was only truly bitten by the “heavyweight” environment bug once I was introduced to IntelliJ, which I can’t say enough nice things about. I was obviously pretty psyched when I found out that the Jetbrains team has decided to put some serious effort into a Ruby plugin. It’s become very usable in a very short amount of time, and I’m very happy with it, but it’s still relatively new and lacking some features.

This new comparison of Ruby / Rails IDEs does a great job summarizing the features in the three leading “heavyweight” IDEs for Ruby / Rails. Definitely check it out if you’re in the market for a good IDE. Interestingly, it seems like NetBeans is really giving both IntelliJ and RadRails a real run for their money, being the first of The Big Three to get a reasonable level of code completion working, amongst a plethora of other features.

Although I’ll probably download it and take a test drive, I’m pretty committed to IntelliJ at this point, so I’ll probably stick it out. But hopefully a little competition will keep things moving along at a good clip :-).

UPDATE: Switched over to NetBeans months ago and loving it! Nice work guys.

attr_readonly

2007-02-27T00:00:00-05:00

I was really shocked yesterday to discover that there’s literally no baked-in way to declare an ActiveRecord attribute as private or protected. Sometimes I don’t want publicly-accessible ActiveRecord attribute methods. Sorry, but not every field in my database should have a corresponding public mutator.

Consider an IP address field on a User model, that’s used to record the last IP the user logged in from. This is something that, although clients outside of the model should be able to access the value, they certainly shouldn’t be able to set it. Only the model itself should be able to update that field in the database. It’s private!

As another example, consider the case where a database field is just a cache of calculated relationship data. That cached value should never be set directly via a public instance method. One example is an average_rating as calculated from a bunch of user ratings on an article. Why would you want to expose a mechanism to set this directly? It should only be set through some sort of recalculate_average_rating public method that lives on your article model and fires as an after_save filter on a new rating object.

It turns out that counter_cache itself suffers from this same problem. Ticket #6896 in the Rails Trac points out this exact issue and proposes a solution in the form of attr_readonly. This is a solid solution, and would go a long ways towards enforcing proper encapsulation in AR.

I ranted about this yesterday in freenode and got yelled at a little bit. Yes, I was probably being a bit obnoxious, but I also don’t want the importance of this to be overlooked. The bottom line is that, like it or not, people are largely stupid. Programmers are not excluded from this. Even Ruby programmers, who admittedly are more self-conscious than most. If you give someone the opportunity to do something stupid, be it at the user level in your app, within your API, or right within the rest of your code base, they’ll do it. If we’re writing for an audience > 1, we should be writing code like we design user interfaces — the public methods available on our classes shouldn’t include things that give our audience permission to twiddle with the guts of that thing. This is a cornerstone of encapsulation and good OO design.

So how do you feel about all this? Is it not A Big Deal to you? To me, it’s a significant limiting factor when it comes to organizing large code bases amongst multiple programmers. If you’re the only guy working on a hobby app, then fine, I guess you can police yourself. Go somewhere and do your thing. But if you’re part of a larger team, or hope to build the foundation for something that can grow into a real enterprise-class app, then proper encapsulation is mandatory.

I really hope that patch gets committed, or that someone puts together a plugin that delivers the same functionality. In the meantime, sure, there are some things you can do that are better than nothing at all. Try declaring a public mutator in your class to override the AR attribute method of the same name and raise NoMethodError, or write a before_save filter that loads up the model into another variable and replaces the current field with it’s previous value. But just describing those “solutions” makes me feel somewhat ill. Rails is such a clean, elegant platform, and it needs a clean, elegant way to provide non-public methods for AR attributes. Let’s get that patch committed :-).

Axiom Of The Empty Set

2007-02-23T00:00:00-05:00

A list without any items in it is still a list, I must insist. Just like a box without anything in it is still a box, or a Smurf village without any Smurfs (Smurves?) is still a frickin Smurf villiage..

But not according to the W3C, apparently. File this one under Rant Of The Day: none of the standard XHTML doctypes acknowledge the existance of the empty list.

<!ELEMENT ul (li)+>

That is, neither the <ul></ul> or the <ul/> representations are valid XHTML. This seems pretty broken to me at first glance, although I’m certianly willing to hear a rebuttal if anyone has one. Even if you don’t think it’s busted, it certainly adds complication to a very common web dev scenario…

So we have a list of resources in our view and there’s a good possibility that our list is empty. We want to be able to display that list, and have a button on the page that lets me add new items to the list with a little Ajax love so that we don’t have to reload the page. If we can represent an empty list in the page, it’s simple: we can just render :update in Rails…

render :update do |page|
  page.insert_html(:bottom, :my_list, "<li>#{item}</li>")
end

The code above assumes that there’s a DOM ID ‘my\_list’ that has 0 or more elements. But since XHTML won’t let us represent a 0-element list, the obvious thing to do is to bake some extra smarts into the update code.

Now it’s the job of the update to determine if a list exists, and if not to create it, but only for the special one-off case of the zero element list? Yuck, bleh. No thanks. This is probably what most people do, but it just strikes me as putting too much intelligence into something that’s supposed to be pretty dumb.

The alternate solution listed here also qualifies as a hack, no bones about it. But, at least in my opinion, it’s a somewhat more elegant hack than what was described above. File under simple Workaround Of The Day:

<ul id="list_things">
  <li class="invisible" style="display: none"/>
</ul>

Note that the W3C does support empty list item elements :-). Thanks to azta for the suggestion.

Super Mathematics

2007-02-20T00:00:00-05:00

Do the math. No matter what you think, nobody’s perfect.

NH Ruby UG Meeting.002 Tuesday

2007-02-19T00:00:00-05:00

If you’re a Ruby developer (or just an interested outsider) living in southern Maine/NH or the northern Mass area, don’t forget to attend the next meeting of the NH Ruby/Rails User Group. Discussion topic this week is RJS and Ajax. Come hang out with us in Portsmouth tomorrow and make sure to stick around afterwards for drinks, discussion, and merriment.

Oh yeah, and Scott has some free stuff to give away at the gathering too. You like free stuff, don’t you?

8.5 Minutes

2007-02-17T00:00:00-05:00

What were you doing for those eight and a half minutes?
Was it mean, was it petty, or did you realize you were sorry
And that you love them?

It’d be nice to think we could get it right down here just once.
G*d bless the Plan.

Inheritance vs Relational Databases in RoR

2007-02-16T00:00:00-05:00

There are three patterns in common use that deal with mapping object inheritance to relational databases. We didn’t discuss any of them in my graduate databases course (sigh), and our friend ActiveRecord implements only one of them: Single Table Inheritance (STI).

STI is what you use when you want to represent an object hierarchy by mapping the union of all attributes found in that class hierarchy to a single underlying database table. Yup, it’s a mouthful. And it works great if the attributes available on the subclasses all tend to be very similar. It’s very fast (comparatively), but makes poor use of space since unused fields are just left null. ActiveRecord’s implementation uses a type field in the database to identify the subclass that the row belongs to.

So what about alternative approaches? There are a couple…

First up is Concrete Table Inheritance, in which there are n database tables for n concrete classes in the hierarchy. Although I’m sure there are cases where this must be useful, I can’t think of a single one. The problem is the silly amount of replication that happens here — fields common to classes will get replicated across tables. This means a lot of replication, more and more as the object hierarchy gets deeper, and a lot of difficulty when it gets to be refactoring time. Bleh, no thanks.

Class Table Inheritance, by contrast, has a table for each class, including interior nodes in the hierarchy (classes that have derivations). A subclass is represented at the database layer as a table that has some number of additive fields plus a foreign key to it’s parent class, which contains the fields that are common to all ancestors.

Conceptually, this seems like the cleanest strategy to me, and the most “OO” of the approaches. However, when we think about the implementation, we realize that performance is going to be a big issue: the class-table strategy is going to require n joins for an object nested n levels into a class hierarchy. Ouch.

Despite that admittedly ugly problem, there has been some interest in implementing Class Table Inheritance in ActiveRecord. In fact there’s some contributed code on the Rails wiki that should allow you to use it as an alternative to STI in Rails. Someone should plugin-ize it, perhaps.

I initially set out to look at alternative DB/object mappings because I was frustrated by the fact that STI wasn’t “accommodating” enough for me. At one point I thought that Class Table Inheritance might be a better match for a specific problem we were looking to solve. It turns out that wasn’t really the case at all; The problem wasn’t STI, it was the way our object hierarchy was structured.

My Lesson Of The Day for February 16th, 2007: If your object hierarchy is relatively shallow, and the single table strategy produces ugly results for you (lots of null fields on subclasses), take another look at the relationships between your objects. STI is a great fit for things that are very closely related to the parent class and require few extra attributes to express that. It’s a lousy fit, otoh, for object relations that aren’t tight like rockstar pants. If both CarPart and DogLeash share the parent class Purchase, they’re probably not good candidates for STI (wink, wink).

Embarrassed as I am to admit it, that was sort of the problem. More on that later, maybe.

Going Solo: Resources Without The 'S'

2007-02-13T00:00:00-05:00

In case you missed it in the release announcement for Rails 1.2.2 last week, singular resources are now available in ActionController. You can use them to model singleton resources in your application.

So we’re using technoweenie’s restful_authentication plugin to handle all things authentication-related in our current project, and decided that a singular resource was a good fit for a Session (login, logout) and Account Controller.

Here’s a dumbass-simple example:

map.resource :account, :member => { :activate => :any }

Note the missing ‘s’. No collections for us here, no sir. But what do we get?

GET /account => AccountController#show
GET /account/new => AccountController#new
POST /account => AccountController#create
GET /account;edit => AccountController#edit
PUT /account => AccountController#update
DELETE /account => AccountController#delete
(ANY) /account;activate => AccountController#activate

Hey, that’s just what I needed. And of course we get the standard named routes for the resource like account_url, account_path, etc. Yay for Resources. Yay for REST.

ActiveRecord Association Extensions

2007-02-08T00:00:00-05:00

So this is probably old hat to a lot of you, but for those that don’t know, ActiveRecord Association Extensions are a seriously useful widget to have in your Batman Fantasy Camp utility belt.

You’ve no doubt noticed that when you define an association between models, you get a bunch of nifty methods on the resultant collection like push, delete, count, uniq, and so on. But what if you want some bit of functionality defined on an association that isn’t already baked in?

Why we can extend our associations to define our own methods, of course. Let’s see how…

Okay, so we have a relationship defined between two models: articles and opinions. An article has_many opinions. An opinion has a score on it, which is an integer between 1 and 10 representing how a user felt about the article.

Using Association Extensions we can define our own method on the association itself, called total_score:

class Article < ActiveRecord::Base
  has_many :opinions do
    def total_score
      sum(:score)
    end
  end
end

Now you can access this information by writing something like:

article.opinions.total_score

Damn, that’s intuitive. Maybe we want to add another method on the association to retrieve the average opinion of users who voted on this article today:

has_many :opinions do
  def average_opinion_today
    find(:all, :conditions => ["created_at >= current_date()"]).average
  end
end

article.opinions.average_opinion_today

And it gets better. If we find ourselves using the same extensions in more than one place, in true DRY spirit we can build a module and reuse it. When we use the :extend option in an association, we get all the methods in that module mixed in.

module MiscellaneousExtensions
  def average_opinion_today
    find(:all, :condition => ["created_at >= current_date()"]).average
  end

  def total_score
    sum(:score)
  end
end

class Article < ActiveRecord::Base
  has_many :opinions, :extend => MiscellaneousExtensions
end

I put this module in a subdirectory of lib called extensions. You’ll have to add that path to the config.load_paths in environment.rb in order for it to be recognized.

Using these sorts of extensions on my own project earlier today really helped me clean up some troublesome model code. I was just so amped up about it that I had to share.

For more information, see the ActiveRecord::Associations API Reference. Oh and a big shout out to Brian Hogan for pointing me in the right direction.

Blog Package Ponderings

2007-01-28T00:00:00-05:00

Drupal has served me pretty well for a number of projects in the past. But as we shift our development focus towards Ruby-based projects, it seems like an ideal time to consider migrating my own blogging platform to something Rails-driven. Nothing against Drupal itself of course. Hell, for a PHP project it’s pretty slick.

But it still just leaves me feeling like I’m flirting with an old (and somewhat unattractive) ex-girlfriend. It’s not you, it’s me.

The obvious candidates seem to be Typo and Mephisto. Another option would be to, of course, roll my own. But does the world really need another half-baked blogging engine? Probably not. If anyone has other recommendations let me know. Looks like I’m leaning towards Mephisto at this point.

Markaby vs Haml vs ERB for Page Templates

2007-01-25T00:00:00-05:00

I’ve been spending some time lately looking at different templating packages for Rails, in hopes of finding something cleaner and sexier than the standard ERB (rhtml) recipe, that also helps avoid common HTML pitfalls that cause pages not to validate.

My search has pretty much boiled down to two candidates at this point. The first is Markaby, which has been around for a while now and lets us represent our XHTML in Ruby code. The other candidate is the new kid on the block, Haml, which just reached a 1.0 last week and has it’s own proprietary CSS-ish syntax. Let’s take a look at brief look at both of them…

Here’s some ERB:

<div class="column" id="content">
  <h2 class="entry_title"><%= h @thing.name %></h2>
  <div class="entry_link"><%= link_to('link', @thing.link) %></div>
</div>

This is probably what we’re all used to and there’s no arguing that it works well enough, but… Well, it’s kind of ugly, isn’t it? To represent this same thing in Markaby, we install the plugin and create a template with a .mab extension and stick this in it:

div.column.content! {
  h2.entry_title @thing.name
  div.entry_link link_to 'link', @thing.link
}

That sure looks better to me. Nice and compact, clean. The best part is that Markaby is actually valid Ruby syntax. This buys us a couple things: first of all, it means that our view won’t run at all if we end up with a syntax error in it, which in turn means that it’s valid XHTML. Slick.

The downside is, of course, performance. It requires rendering for every single tag and property, which makes it slow in comparison to ERB, since just the inline Ruby snippets in the rhtml file have to be processed and inserted into a mostly pre-rendered HTML template. I also have some minor gripes about the use of bang instead of pound for representing element IDs, and the fact that it blows up when I put a yield in my Markaby layout code (I have to use @content_for_layout, which is deprecated now).

Anyway, enough about that. Let’s talk about Haml for a second. Install the plugin, and create a view with a .haml extension. Here’s the same chunk of code we saw before written in Haml:

.column#content
  %h2.entry_title= @thing.name
  .entry_link= link_to('link', @thing.link)

Haml defines it’s own syntax, which borrows from familiar CSS markup, and takes advantage of whitespace sensitivity for nesting. This latter bit is great news if you’re one of those undercover Python people hiding amongst us (I’m not one of you, now go away). It generates really nice clean appropriately nested HTML for output too.

Although it’s fairly easy to read and satisfies our cleanliness criteria, there are some immediate downsides to the fact that the markup is proprietary. Firstly, it means the files still have to be parsed and re-rendered by Rails, for a performance hit — same as we’d get with Markaby or any other higher-level template language for that matter. It also means that your editor isn’t going to be able to help you with syntax highlighting unless it has explicit support through a plugin.

I can see why people like Haml, it’s compact and kind of fun (see the tutorial for more). But all things considered, I really can’t see any reason I’d use it instead of Markaby, which feels much more natural to me and has the added benefit of Ruby syntax validation. Perhaps if it were to represent a significant performance increase — this seems doubtful — but I haven’t seen any real benchmarks. In any case, I don’t think I’ll be using it any time soon.

If I were to choose one of these two, I’d have to go with Markaby. I’m quite smitten by the idea of writing template code in pure Ruby, and the syntax validation enforcement is extremely desirable. As bizarre as it may seem, I love the idea of a page failing to run because of a syntax error in my “HTML” markup. Still, the performance issues give me pause. An even bigger issue is that of fragment caching, which sadly seems to be currently busted in Markaby. So, all things considered, I guess I’m sticking with ERB in my view templates, coupled with assert_valid_markup for my validation testing needs. At least for now. Even thought it makes me cringe a bit.

If I’ve missed anything worth considering about either of these templates, or if there are other options, please drop me a line. I’d love to hear what the rest of the community is using for their high-volume web apps…

IntelliJ Ruby Plugin 0.1 Beta Released

2007-01-22T00:00:00-05:00

The kind folks over at JetBrains have finally got around to releasing a 0.1 Beta of their Ruby Plugin to the IDEA Repository. If you’re an IntelliJ user, it’s now as easy as going to the plugin manager in Preferences and selecting the Ruby plugin for installation. The workflow is the same as I described earlier but this release brings some important bugfixes; console output is now available, starting/stopping the WEBrick server now works as expected, etc.

In case you haven’t checked it out, the integrated Rails generators and Rake tasks rock, there’s an RDoc toolbar with lookup, goto class functionality, code formatting, and a bunch of other goodies, all detailed in the Release Notes. I got all excited when I saw keyword completion in the list; but it turns out that it’s really just that — although a ticket for proper code completion is listed in the issue tracker it looks like it’ll still be awhile before we get to feel that love. Syntax highlighting in rhtml/builder templates will be huge also (in the roadmap).

I’ve been using RadRails as my RoR IDE so far, but now that the IntelliJ plugin is mature enough to work with I’ll probably start migrating over. Don’t get me wrong; RadRails is a great project (and free!), but IntelliJ is my IDE of choice for Java dev, and I’m psyched to see it evolving into a platform for Ruby development too.

Rails 1.2.1, Prototype 1.5, Other Goodies...

2007-01-19T00:00:00-05:00

Wow what a big day. Immediately after the release of Rails 1.2.0, we get a quickie bugfix bump to 1.2.1 and a great post by DHH summarizing the features in the release. On top of this, we get Prototype 1.5.0, complete with a new web presence and some surprisingly good documentation.

Rails 1.2 Released

2007-01-18T00:00:00-05:00

Looks like 1.2 has been officially released. I’m sure that I’m not the first to notice :-p. To update your gems:

gem update rails --source http://gems.rubyonrails.org --include-dependencies

Enjoy!

Seacoast Ruby UG First Meeting Tonight!

2007-01-16T00:00:00-05:00

If you’re in the seacoast NH area (north of Boston), don’t forget to attend the first meeting of the Seacoast Ruby/Rails User Group tonight from 7-9 at the UNH campus. Apparently there was such an overwhelming response that Scott had to move the location to Morse Hall in order to accommodate the additional heads. Wow, cool. More information and directions are on Scott’s blog. See you there!

FreeBSD 6.2 Released

2007-01-15T00:00:00-05:00

FreeBSD 6.2 was released this morning. Lots of bugfixes and new features, including official support for binary updates with freebsd-update. Cvsup away!

RailsConf 2007 Registration Opens 1st Week Of February

2007-01-14T00:00:00-05:00

This time around the event runs from May 17th to the 20th. Am I gonna go? I’m debating. It seems like a great opportunity to hear a bunch of great speakers, absorb some mad knoweldge, and meet like-minded Rubyists. Plus it’s in Portland Oregon (the other Portland), a city I’ve always wanted to visit, and a mere 2 hours from a good friend of mine in Eugene.

The thing that gives me pause is, of course, the cost. Registration is rumored to be a whopping $800 for the 4-day event this year, roughly double the 2006 event price. Ouch. Does this dramatic price hike reflect significantly increased offerings, or is it just because Rails has moved a bit closer to the mainstream — meaning that more corporate entities are capable of coughing up the usual exorbitant conference fees to send employees? Sigh. In either case, as a self-employed developer type that’s painful. Only half as painful as WWDC. But still, painful.

Of course, if you have the time and the skills, CD Baby is sponsoring a HackFest to send the top 20 patch contributors free of charge (inc hotel). You’ve got until the 22nd to make your impact as measured here. And yes, I’m a bit late in posting that news.

Stupid JavaScript Hacks

2007-01-07T00:00:00-05:00

I’m usually not prone to MLP (mindless link propagation) but sometimes I just can’t help it. Case in point: this cool l’il bit of JavaScript. Good for a quick chuckle.

New Years Resolutions

2007-01-03T00:00:00-05:00

Back from my requisite holiday visitations and feeling refreshed. Now it’s time to get back to work. Here’s some tentative goals for the new year:

Get up earlier in the morning. Start work earlier in the morning. Finish work earlier in the evening.
Focus more on Ruby this year, less on Java. Delete PHP from resume.
Get a gym membership and actually go on a regular basis.
Take a break from client (ie paid) work for a change and get one of my own ideas off the ground before summer.
Print some damn business cards. Stop coming up with cute excuses about why they’re lame and learn to conform. Just a little.
Go to at least one conference. Go to at least one UG semi-regularly.
Bathe the dog more often. He is a stank factory.

NH Seacoast Ruby/Rails UG

2006-12-28T00:00:00-05:00

I just got word that there’s a Ruby on Rails user group starting up in my area. It’s being organized by Scott Garman and the first meeting will be January 16th at the UNH Library in Durham, NH. More details at Scott’s Blog. It’ll be great to meet some other local Ruby dorks — most of my contract work is non-local and the other devs I know in the Portsmouth area have sadly yet to be bitten by the bug. I’m psyched that someone has taken the initiative to set this up. Thanks Scott!

On completely unrelated news, I’ll be afk for a few days. Heading northbound to visit relatives and then some college friends for a New Years’ extravaganza of sorts. Hopefully I can remember how to play beer die — it’s been awhile. See y’all in 2007!

Singin' Hobo (Not The Stabbin' Kind)

2006-12-26T00:00:00-05:00

So it’s the holidays, and I’ve got some time “off” from “work” to recoup and think about my next project, play around with a few ideas, new toys… The first thing on that list of toys is Tom Locke’s Hobo framework.

The Hobo 0.4.0 Gem was released late last week and it’s pretty slick, although we’re warned not to use it in production webapps yet :-). Hobo extends Rails in a number of ways, but the crux of it is that it lets you get up and running with a real, usable (and cleanly coded) Ruby-based webapp quicker than ever before. Hobo bundles in a working user system (acts_as_authenticated), permisisons, and a bunch of other goodies — take a look at the screencast for a quickie walk-through. There also seem to be some interesting ideas here regarding tag libraries, but that’s not covered in this first screencast. Anyway, definitely worth checking out.

count_on counter_cache

2006-12-24T00:00:00-05:00

Counter cache is my new friend. It’s a very important little feature available on ActiveRecord that makes counting associations efficient by maintaining a cache on the model.

Although it’s documented in AWDWR (p359 in my shiny new copy of the second edition), I guess it slipped my mind until now, so I thought I’d blog about it just in case anyone else was looking for a solution…

So why does it rock so hard, you ask? Let’s say that I’m building YADRC (Yet Another Digg/Reddit Clone). I need to count the votes that users make to determine the popularity of an article, display that number, and use it to rank the order of the stories. So we set up our models: a story model, a vote model, and a user model, and we create the appropriate associations. Our vote.rb is going to look something like this:

class Vote < ActiveRecord::Base
  belongs_to :user
  belongs_to :story
end

Predictably, Story has_many votes and User has_many votes. Now we can do something like this to find the number of votes on a story object:

Story.find(4).votes.size

This will work nicely right out of the box. However, once we have a significant amount of stories logged in our system and a reasonable number of votes on each story, performance goes straight to poop. The reason is that each time we’re generating a score for a story (and remember, we’ve got N stories), we’re running a query like this against our database:

SELECT count(*) AS count_all FROM votes WHERE (votes.story_id = 4)

If we have any real amount of data in our system, this is going to get really ugly. Counter caching is one way to help counteract this problem. Let’s rewrite our model to use it:

class Vote < ActiveRecord::Base
  belongs_to :user
  belongs_to :story, :counter_cache => true
end

We also have to add a column, called votes_count, to the stories table in our database. Make sure to specify a default value of 0 in your DDL. Then we generate a migration, run it, and now we’re ready to try again. The difference should be pretty dramatic. If we tail -f our development log, we’ll notice that those count(*) queries aren’t getting run anymore. So what’s happening?

ActiveRecord is using our counter cache column (called votes_count in this case) on the stories table to store the number of belonging objects on the associate class. This value is incremented when an object of this class is created, and decremented when it’s destroyed. The result is that we have a local “cached count” on the Story instance so we don’t have to constantly query the votes table directly. Good deal, eh?

There are two additional things worth noting about counter caching. As Dave Thomas points out in AWDWR, the counter won’t get updated if entries are added by setting the link to the parent directly in the child like this:

vote = Vote.new
vote.story = story
vote.save

If you’re doing it this way, you’ll have to force the parent class to refresh the collection. The right approach is to add a Vote through the Story object, which makes the parent aware of the increment (or decrement) and update the counter cache accordingly:

story.vote.create

The other point I wanted to make was that if you call the count method on object instead of using size, it will always run the actual count query on the underlying database, instead of using our cached shortcut. Thanks for the tip on that one, technoweenie.

The Quest For The Perfect RoR IDE...

2006-12-22T00:00:00-05:00

Ruby itself doesn’t directly support multiple inheritance (yay for mixins) but the community sort of does. If you survey a random group of RoR developers, about half of them seem to come from a structured (oftentimes strongly-typed) OO language like Java, and the other half comes from the scripting world. One of the best things about Ruby is that it appeals equally to both camps. It’s a common ground of sorts, a compromise, maybe the best of both worlds. I dig that.

But as everyone knows, different backgrounds beget different toolsets. In the case of Ruby on Rails, it raises the question: do we need a real IDE for this kind of work, or is a simple text editor good enough?

I’ve gravitated back and forth between the two coding camps over the years. It’s a “right tool for the task” sort of thing if you ask me. You want a lightweight project management application that runs on the web? PHP please. You want a robust scalable service for the delivery of digital media and have some money to spend? Let’s do that one in Java. There’s a religious war to be had here for sure, and I don’t want to get into that… The interesting thing (and the point I’m trying to make) is that the tools you come to use and respond to differ depending on that background.

When I’m working in PHP, I use vim. No, really. I tried PHPEclipse and the pluses just didn’t outweight the minuses for me. I also tried Komodo. I’m an old school vi hacker, and I do all my sysadmin work in vi, so it became the natural choice. I don’t regret it. Well, not often, anyway. After all, PHP is a scripting language, right?

When I’m working in Java, I’m spoiled to death by IntelliJ. Yes, it’s expensive. Yes, there’s a learning curve. And yes, it’s worth every damn penny/hour spent. I’ve tried Eclipse. And it’s alright, but it’s not IDJ. The JetBrains guys have delivered what is by far the most intelligent, usable IDE I’ve ever used. That’s my story, and I’m sticking to it.

So is Ruby a scripting language, or is Ruby a proper OO “enterprisey” language? I’d argue that it’s both and that it’s use dictates the classification. But when you’re building Rails apps, you’re firmly entrenched in OO/MVC proper webapp territory, and therefore, imho, that demands the use of a proper IDE. Particularly once a project becomes sufficiently large.

So what do I use when it comes to Rails work then? Well, up until now I’ve been using RadRails with RDT and Eclipse. It works pretty well for the most part. But it’s no IntelliJ. We don’t, of course, have auto-complete yet, but the syntax highlighting is getting there, the generators and rake tasks are wrapped up nicely, as is run output, test execution, etc etc. It’s better, for me, than using vi, by leaps and bounds and it seems to be getting better and better (nice job guys!).

RadRails seems to be the choice for Windows and Linux users, but everyone else I know on OS X seems to be using TextMate. Whoah, what? I’ve never used TextMate — am I missing out? But wait, TextMate is just a text editor right? It’s NOT an IDE and doesn’t aspire to be. Regardless, the popular opinion seems to be that it’s “good enough”.

So what do you use? Are you, like everyone else out there, a TextMate-phile? If so, why? Don’t get me wrong, I understand the allure of a minimalistic text editor for hacking script, but have you been spoiled by something as nice as IDJ in the past? Oh man would I kill for ctrl-space to autocomplete/interrogate an object to discover it’s methods..

I wonder if there are a lot of people who have come over from the Java side of things who have switched to TextMate, particularly people who have used IntelliJ in the past. Am I making a blanket assumption that most of the people using text editors to hack Rails are not Java converts? Am I just overcomplicating the whole thing? Is TextMate really “good enough”?

The entire Rails core team purportedly uses TextMate… Maybe I’m just missing something? I’d love to hear your opinions.

UPDATE: I’m using NetBeans now. And it’s great.

IntelliJ On Rails

2006-12-22T00:00:00-05:00

If you’re an IntelliJ user like me, and have recently been bitten by the RoR bug, you’ll be glad to know that there’s a plugin on the way. It’s still in it’s infancy, lacking a lot of features, and is therefore not in the repository, but that doesn’t mean we can’t play around with it. What follows is a brief tutorial on how to locate, install, and use the ruby plugin…

First you need to check out the sources from the Subversion repo:

svn co http://svn.jetbrains.org/idea/Trunk/ruby

Use Ant to build it (run ant from the directory you co’d to, where the build.xml file lives). The build process should generate a jar file in dist/ called ruby-SNAPSHOT.jar.

Next, make a new directory in your IDJ plugins directory called ‘ruby’ and make a lib directory in there. Copy the jar to $IDJ_ROOT/plugins/ruby/lib. On OS X, this path is something like /Applications/IntelliJ IDEA 6.0.2.app/plugins/ruby/lib/.

Start IntelliJ. Go to Settings → Project Settiings → Project Structure. In Global Resources, under JDKs, right click and add a Ruby SDK. On OS X, you’ll want to point it at /usr/local, or whereever your copy of Ruby has been installed.

Now you should be able to create a new project and select Ruby SDK from the JDK list (heh). Create a single module project, select Rails as your module type, and set the Ruby SDK for the module. Finally, you’ll be given the chance to generate a new Rails application skeleton, generate missing files, or use an existing Rails app. Go ahead and create a test project and generate a new Rails framework. I’ll do all the work for you and populate the project explorer with that oh-so-familiar directory structure. Check out that ugly Ruby icon they’re using. Jeeze, what is that?

Right click in the project explorer and select New → Controller. Name your controller test and add an action name hello. Click OK. IDJ will run the Rails generator and update the project explorer. You now have a TestController with a hello action, the corresponding view template, and the expected test stubs.

You can select Run → Run… to start a WEBrick server and test your app. There are some bugs here. First of all, there is no run output in the console view where you’d expect it to be. No web browser is launched, no indication is given of what port number the server gets bound to. Worse, you can’t seem to kill a running WEBrick server without killing the process from a terminal. So yeah, there’s obviously still some work to do here. For now, I’d suggest running WEBrick from the command line (RadRails still wins here, at least). No command completion or real debugging support is available yet either, but hey.. it’s a start. It’s functional, you can run tests from within the IDE, you get basic code formatting, syntax highlighting, etc.

For more information, check out the JetBrains Project Homepage for the ruby plugin, where you’ll find a link to the roadmap and discussion groups. You’ll note that there are plans for autocompletion, ability to browse to symbol, proper YAML, RXML support, etc. I really hope that development continues on this. IDJ is much-loved amongst the Java community, and could be a huge hit in the Rails community if they get a slick, fully functional plugin out there.

Develop with pleasure ;-).

Relief

2006-12-20T00:00:00-05:00

So we just finished wrapping up work on the app we’ve been building for the past 8 months. Yay! It’s part of a suite of web-powered tools for a certain niche video editing system. Implemented in Java, leveraging Swing, Axis, WebObjects… Great project and totally learned a lot, but sure am relieved to have delivered it. I’m sure there’ll be a tweak to make here or there, but you know… It’s delivered (rc).

What’s next? Well, I’m not entirely sure to be honest. For the first time in my life I’m thinking about abandoning paid work in order to invest a couple solid months of full-time effort working on the Ruby/Rails app that’s in my head. Perhaps it’s finally time to put my neck out there a little and make it happen. After all, I isn’t getting any younger, now is I?

Searchable RoR Docs

2006-12-11T00:00:00-05:00

One of the great things about PHP isn’t the documentation, per se, but rather the centralized, searchable docs interface at PHP.net. Big thanks to Jeremy Durham for putting together an equivalent Rails resource site. There’s obviously still a good bit of work to do before docs are as complete and usable as they could be, but an online searchable repository like this is definitely a step in the right direction. Bookmark it, and add some example code and comments mang.

Oh and while we’re talking about documentation (or lack thereof), don’t forget to donate to the Rails API docs project at Caboo.se if you haven’t already.

JavaScript Tricks (RJS-R): Cleaning Up My Mess...

2006-12-07T00:00:00-05:00

So a couple folks have pointed out that the last Rails+YUI example I posted doesn’t work in IE. Or Safari. Eek, that’s not so good.

Anyway, this post is kind of a hodgepodge documenting the process I went through to fix those issues and clean it up a bit. Maybe more of a ‘note to self’ than an actual blog entry, so not required reading by any means. Unless you’re having issues with IE and Minus MOR that is, in which case the magic word is content-type. I’m embarassed to say how much sleep I lost tracking that one down. Sigh.

class ExampleController < ApplicationController
  layout "standard", :except => :add

  def show
  end

  def add
    @response.headers['content-type'] = 'text/javascript';
    @thing = params[:thing]
  end
end

That’s our updated ExampleController. Notice that we’re setting the content type of the response in the headers now. The default content type appears to be html, instead of text/javascript. Not entirely sure why this is happening at the moment as Minus-R appears to set the content-type in it’s render method. But anyway, for whatever reason, Safari and Firefox both work fine, but IE doesn’t like it one bit. Of course, instead of warning us (or giving us an option to warn us, for that matter) it simply discards the asynchronous response. Hence, we never see an update. Nice, eh?

I also took the opportunity clean up the rest of our example a little bit. Here’s our new layout template:

<html>
<head>
  <title>YUI Tester: <%= controller.action_name %></title>
  <%= javascript_include_tag "yui/yahoo", "yui/event", "yui/dom", "yui/dragdrop", "yui/connection", "yui/container"%>
  <%= stylesheet_link_tag  'yui/container'%>

  <script language="javascript">
    YAHOO.namespace("yuitest.container");

    function init() {
      var handleCancel = function() { this.cancel(); };
      var handleSubmit = function() { this.submit(); };
      var handleFailure = function(o) { alert("failure: " + o.responseText); };
      var handleSuccess = function(o) { eval(o.responseText); };

      YAHOO.yuitest.container.myDialog = new YAHOO.widget.Dialog("myDialog", {
        width: "500px",
        modal: true, 
        visible: false,
        fixedcenter: true, 
        constraintoviewport: true, 
        draggable: true });

      var escKeyListener = new YAHOO.util.KeyListener(document, { keys : 27 }, 
        {fn:handleCancel,scope:YAHOO.yuitest.container.myDialog,correctScope:true} );

      YAHOO.util.Event.addListener( 'myDialogForm', 'submit', function(e) {
        YAHOO.util.Event.preventDefault(e);
        YAHOO.yuitest.container.myDialog.submit();
      });
        
      YAHOO.yuitest.container.myDialog.cfg.queueProperty("keylisteners", escKeyListener);
      YAHOO.yuitest.container.myDialog.cfg.queueProperty("buttons",
        [{ text:"Save", handler:handleSubmit, isDefault:true },{ text:"Cancel", handler:handleCancel } ]);

      YAHOO.yuitest.container.myDialog.callback = {
        success: handleSuccess,
        failure: handleFailure
      };

      YAHOO.yuitest.container.myDialog.render();
    }

    function addThing() {
      YAHOO.yuitest.container.myDialog.show();
    }

    YAHOO.util.Event.addListener(window, "load", init);
  </script>
</head>
<body>
  <div id="main">
    <% if flash[:notice] -%>
      <div id="notice"><%= flash[:notice] %></div>
    <% end -%>
    <%= @content_for_layout %>
  </div>
</body>
</html>

OK, a bunch of changes there. First, we’ve removed all the Prototype JS libs because we no longer need it — YUI’s connection manager can take care of this stuff for us, and since we’re not using the default behavior of RJS, there are no worries about dependence on Prototype. Next, we’ve added a couple key listeners on the popup dialog to handle enter (submit) and escape (cancel). Note that we have to use Event.preventDefault() in our enter key listener to suppress the default form submission action. Otherwise, we end up redirected to a new page that just contains our result string, and we don’t want that…

Finally, we’ve also eliminated the clumsy body of the success handler and replaced it with a single statement: eval(o.responseText). Yup, we can just evaluate the JavaScript returned from our Rails app. No need to append a new script tag to the body, yehck. Here’s the code that’s returned from our add.ejs template, as a reminder (it’s unchanged):

document.getElementById('hello_msg').innerHTML = '<%=@thing[:name]%>';

So yeah, it just replaces the inner HTML in the element named hello_msg. Easy enough. The next step here would be to figure out how to encapsulate the stuff in the layout using some sort of helper module or plugin. But that’s it for now.

(Progress on my current Rails project has been pretty slow lately, as we’re nearing completion on a big client project (a slick Java-based webstart app that’s been occupying the majority of my time for the past 6 or so months). It’s nice to finally see the light at the end of the tunnel! Hopefully once that wraps, we’ll have some significant time to pour into the RoR ideas and prototypes we’ve been playing around with…)

RJS & MinusMOR

2006-12-02T00:00:00-05:00

RJS rocks. It lets me write JavaScript without writing any JavaScript. That’s very Zen, and I like it. But sometimes I find myself writing really ugly, narsty things in my RJS templates. Instead of using Ruby to write JavaScript I end up writing JavaScript and appending it to the page with Ruby, especially when client side conditionals are involved. Needless to say, the template code quickly devolves into what can only be described as frankenrubyscript.

To rid ourselves of the monster, take a look at Dan Webb’s MinusMOR plugin, which lets you return plain ol JavaScript to the browser using templates with an .ejs file extension. This may not seem like a big deal but it’s pretty damn helpful if you return any significant amount of client-side logic within RJS.

[Note that you’ll need to be on the Rails 1.2 codebase to use the plugin]

As a simple example, let’s overhaul our sample YUI test app to use MinusMOR. Now this really isn’t a great example, as the JavaScript code is super simple and therefore lends itself well to being written in Ruby. But oh well. At least it gives you an idea of how it works.

Our add.rjs file used to contain the following one-liner:

page.replace_html 'hello_msg', @thing[:name]

Now, our add.ejs file will contain the following code instead. Note the use of ERb in the template:

document.getElementById('hello_msg').innerHTML = '<%=@thing[:name]%>';

In this case the normal RJS approach is quicker, sexier, and, above all else, easier to read. And, admittedly, 90% of your client-side code will more than likely be the simple kind of stuff that RJS rocks at (update this text within that DIV, switch the visible state of that DOM element to hidden, etc). But you can certainly imagine scenarios where it’d make sense to write pure JavaScript in the template instead.

Use RJS wherever you can, but once bits and pieces of frankenrubyscript start sneaking into your code, be sure to check out Dan’s plugin. Cuz there’s no denying that there are cases where using plain ol JavaScript is cleaner, as un-Zen-like as that may seem….!

Moving To The Edge, Or Thereabouts

2006-11-27T00:00:00-05:00

So I tried to update my OS X dev box to GemRails 1.2 RC 1 and ran into some issues the other day. For some reason, I just couldn’t seem to get system Rails pointing to the new (.5618) copy. I’m usually a pretty stubborn bastard, but one of the plugins I wanted to use requires exempt_from_layout to be available on ActionController::Base, so I figured I’d use EdgeRails and freeze a copy of 1.2 RC 1 in the project’s vendors directory.

One of the nice things about the way this is all wired together is that you don’t have to be on the very edge of EdgeRails to take advantage of it. In this case, I just need some functionality in 1.2 RC 1 so I can update our existing project and check out using the tag:

rake rails:freeze:edge TAG=rel_1-2-0_RC1

To verify that we’re on EdgeRails now using the 1.2 codebase (so we can hang out with the cool kids), we can run script/about:

Edge Rails revision rel_1-2-0_RC1

Keep in mind that this is different than just doing a regular edge freeze since we know we’re getting exactly what we’re asking for. If we just issued an edge freeze without the TAG parameter we’re going to get the latest and greatest development version which of course means two things: 1) we get the bestest newest coolest stuff, and 2) there’s a good chance that some of that stuff is a bit buggy.

For the moment, we don’t have an immediate need to be running the very latest and will therefore generally tend toward valuing stability over freshness. But as our projects grow and we shed more and more of our noobskin, I’m sure we’ll begin making even more exceptions to that rule, forcing us ever closer to the bleeding edge.

Pun intended, of course.

Happy Thanksgiving: Rails 1.2 RC 1 Arrives!

2006-11-23T00:00:00-05:00

In case you haven’t already heard, Rails 1.2 RC 1 is out. Click here for details. Taking center stage this time seems to be the push towards creating RESTful services. Very nice. Also updates to Prototype and Script.aculo.us and, whoah, some deprecations.

So after you finish wolfing down that enormous, weight-altering dinner, sit back in your tryptophan-induced haze and take a gander over the new stuff. Me? Nah. I’m headed up to the Great White North for a couple of Internet-free days. But I know what I’ll be doing when I get back… Enjoy!

Prototype vs YUI Connection Manager: Dialog Continued...

2006-11-20T00:00:00-05:00

In the last blog entry, I wrote about doing a first pass integration between Rails and the Yahoo UI Library’s Dialog widget. In the event handler for the save action, we created an Ajax.Request object using the Prototype library to make the Ajax call but I didn’t elaborate on why just calling this.submit() in the handler wouldn’t work. Well, the answer is pretty obvious: I wanted to tease out a second article :-).

YUI expects us to set up a callback handler for the success/failure of the XMLHttpRequest request that it generates when this.submit() is called. If you don’t have a callback set up, the client receives the response but just ends up throwing it away. So let’s look into how we need to change our handler to do things the “right” way (according to Yahoo, anyway). We’ll also see how this is somewhat at odds with Prototype and RJS.

YUI’s Connection Manager utility exists to simplify your interface to the XMLHttpRequest object and provides a handler pattern for callbacks. It’s used throughout their library, so let’s use it here. This updated code should obviate the need for using Prototype in the body of the save action handler:

var handleSubmit = function() {
  this.callback = {
    success: function(o) {
      var scriptObj = document.createElement("script");
      scriptObj.setAttribute("type", "text/javascript");
      scriptObj.text = o.responseText;
      document.body.appendChild(scriptObj);
    },
    failure: function(o) { 
      // do something here
      alert(o.responseText);
    }
  };
  this.submit();
}

In the code listing above, we define the callback object to handle the success / failure cases reported by XMLHttpRequest. On success, we’re going to create a new script element in the DOM and load it up with the response that our RJS template renders. Then we have to append the new element to the DOM. Remember, what we’re appending here is really just some more JavaScript that we’ll use to alter the page contents. Here’s the code in that RJS template again (add.rjs), as a reminder:

page.replace_html 'hello_msg', @thing[:name]

Alright, that’s great. But what does the JavaScript code look like that actually gets generated?

try {
  Element.update("hello_msg", "Welcome Interstate Managers");
} catch (e) { 
  alert('RJS error:\n\n' + e.toString()); alert('Element.update(\"hello_msg\", \"sdafdsfsdff\");'); throw e 
}

That Element.update instruction is Prototype’s way of saying “take the DIV identified as hello_msg and replace it’s guts with the string Welcome Interstate Managers”. Of course, that’s just the string we gave it when we serialized our form data and sent it off (see previous article for details). Simple but powerful.

OK so that rocks, but there’s a bit of redundancy here. Yahoo’s Connection Manager utility and Prototype do a lot of the same stuff. That duplication is totally against the DRY spirit we’re going for. Sigh. Now I’m not well versed enough in the finer details to advocate The One True Way here, but I should note that I’m much more experienced with Prototype than I am with the YUI connection manager. Prototype is also much more entrenched in Rails, serving as the basis for both Scriptaculous and RJS, and it looks to remain that way as Sam Stephenson (Prototype’s creator) is part of the Rails core team.

Anyway, the point I’m trying to make is that the Yahoo UI connection manager library adds further unnecessary bloat to our applications, since it’s essentially just replicating what Prototype already does. I’m sure the YUI guys have their reasons for re-implementing this stuff (Prototype isn’t universally well-loved), but it’s kind of unfortunate for Rails developers, who are pretty well married to Prototype at this point. That isn’t to say that the Yahoo stuff is better or worse.

In the meantime, if we want to use YUI’s widgets, we just have to suck it up and eat a little extra pie this holiday season. Maybe it’s worth writing an alternative connection.js to act as a Prototype wrapper. Maybe we could whip up some helper modules to get these excellent UI widgets as well integrated into the Rails framework as the Scriptaculous stuff is. I’m sure this is all very possible, but just need to spend some time digging through the stuff in more detail. In any case, it seems clear that proper RoR integration needs a bit more thought. Add it to the TODO list!

PS the folks at OpenRico have done a nice job providing a set of controls that are very RoR-friendly. Their focus is somewhat different than that of the Yahoo library, more emphasis on behaviors and cinematic effects rather than on widgets, per se. They have a great accordion widget though, and a live grid too (although it currently lacks cell editing support, which is one of the key things we’re looking for).

YUI Dialog On Rails: First Pass

2006-11-18T00:00:00-05:00

RoR seamlessly integrates with Prototype and the Scriptaculous library, buying us slick auto-complete fields, sortable lists, some nifty effects and all sorts of other web2.0-ish goodies. But when it comes to more advanced UI toolkit widgets, ones you’d find in desktop app frameworks, like draggable modal dialogs, tabbed panels, and active data grids, it seems hard to beat the library that Yahoo has put together. [That is, unless you want to start mucking with Adobe’s Flex. But that’s a topic for another conversation…]

The Yahoo UI Library has been around for a while now (since February) and I’m just now getting around to playing with it. Unfortunately, there’s no Rails helper module or anything of that sort. But that doesn’t mean we can’t build one ourselves, or at least make them play nice together…

Let’s start with something simple. Oh yeah, I should mention that Sonjaya Tandon covered this same sorta stuff and what I’m doing is based on what I found there, but I’m going to do it a little bit differently, and demonstrate how you can leverage RJS. Here we go:

First, let’s set up a Rails project and create a controller. Call it ExampleController:

class ExampleController < ApplicationController
  layout "standard", :except => :add

  def show
  end

  def add
    @thing = params[:thing]
  end
end

Pretty simple stuff. We’ll need an RHTML view template for the show action, and an RJS template for our add action. We’ll also need a layout that’ll be added to everything but our add action. Let’s take a look at that layout (standard.rhtml):

<html>
<head>
  <title>YUI Tester: <%= controller.action_name %></title>
  <%= javascript_include_tag :defaults %>
  <%= javascript_include_tag "yui/yahoo", "yui/dom", "yui/event", "yui/connection", "yui/dragdrop", "yui/container" %>
  <%= stylesheet_link_tag  'yui/container'%>
  <script language="javascript">
    YAHOO.namespace('yuitest');

    function initDialog() {
      var handleCancel = function() {
        this.cancel();
      }

      var handleSubmit = function() {
        //this.submit();
        new Ajax.Request('/example/add', {asynchronous:true, evalScripts:true, parameters:Form.serialize(myDialogForm)});
        this.hide();
      }

      YAHOO.yuitest.myDialog = new YAHOO.widget.Dialog("dlg", {
        width: "500px",
        modal: true, 
        visible: false,
        fixedcenter: true, 
        constraintoviewport: true, 
        draggable: true });

      var myButtons = [ { text: "Save", handler: handleSubmit, isDefault: true },
        { text: "Cancel", handler: handleCancel } ];    
      YAHOO.yuitest.myDialog.cfg.queueProperty("buttons", myButtons);
      YAHOO.yuitest.myDialog.render();
    }

    function addThing() {
      document.myDialogForm.thing_name.value = "";
      YAHOO.yuitest.myDialog.show();
    }

    YAHOO.util.Event.addListener(window, "load", initDialog);
  </script>
</head>
<body>
  <div id="main">
    <%= @content_for_layout %>
  </div>
</body>
</html>

So there’s a bunch of JavaScript in there. I’m going to work on cleaning all that up and building a helper module later but for now let’s just get something functional.

We’ve copied the relevant YUI library javascripts to our public/javascripts directory, and now we include them in the layout along with our defaults (prototype, etc). We’d want to trim this down to just what we need before deploying an app for real world use of course.

We’re going to create a dialog from the YUI and add two buttons on it (save, cancel) and the corresponding event handlers. We also need to add a function addthing() that will be called when the user clicks on the link in the show template. It will simply reveal our modal dialog. If you’re confused about any of the syntax here, see the YUI docs and tutorials. Lots of good stuff over there, extremely well documented.

Now here’s our show template (show.rhtml):

<div name="hello_msg" id="hello_msg">hello</div><br />
<a href="#" onclick="addThing()">Add Thing</a>
<!-- begin: dialog box -->
<div id="dlg">
  <div class="hd">this is a dialog</div>
  <div class="bd">
    <%= form_tag({:action => :add}, {:name => 'myDialogForm'}) %>
      <label for="thing_name">Thing Name:</label> <%= text_field('thing', 'name') %>
    <%= end_form_tag %>
  </div>
</div>
<!-- end: dialog box -->

Note that the form name (myDialogForm) must match up. Also note that the dlg DIV uses the same name we initialize the dialog to in the layout. This is important, it means the contents of this div are rendered within the modal dialog and are therefore hidden from the view by default. When you click on the ‘Add Something’ link, the dialog will pop up. You’ll be able to drag it around the screen and enter some text in it. Yay. Then you can click save, and it should update the hello_msg DIV. There’s an easier way to do this of course, but we’re going to use RJS because the approach is demonstrative of a lot more powerful stuff you can do, leveraging Rails model data you may have on the backend and perhaps doing some processing or database access before rendering the results. You get the idea.

So when you hit that save button, the code in the submit handler is run. Let’s look at that JavaScript again:

new Ajax.Request('/example/add', {asynchronous:true, evalScripts:true, parameters:Form.serialize(myDialogForm)});
this.hide();

We serialize the data in the form (that one text field) and submit the data asynchronously by making a direct call to Ajax.Request (thanks Prototype!). Then we hide the model dialog again, returning control to the main page. Notice that URL: /example/add. This calls the add action on our ExampleController, which does something important — in theory — and then renders out an RJS template. This RJS template, for our simple example, just replaces the hello_msg div’s inner HTML with whatever it was we typed into that text field. Here’s the RJS template, add.rjs:

page.replace_html 'hello_msg', @thing[:name]

That’s it for now! We’ll revisit this later if I have time, and try to figure out how to wrap it up in a module to make it easier to use and more general purpose.

Down w/ with_scope

2006-11-08T00:00:00-05:00

We need to delete some stuff. But when we delete items, we don’t really delete them because hey, we don’t have to (we might want them later, no?) So we have an attribute on the model, deleted, which is null if the item is current. When we delete an item, we update_attributes to set deleted to the current datetime.

Yes, yes, I know, this is really common stuff. But hold on, this is where it gets kind of interesting. We want to call find on the model, like always, and only get back current items that have not been deleted. Oh, and we don’t want to have to pass in the condition every time, because that’s just gross. We’d just like to, well, add the condition to the scope. This is where the magic of with_scope can help us out.

Let’s declare a method find_current on the model:

def self.find_current
  find(:all, :conditions => "deleted IS NULL")
end

Well that works for our base case (finding all current items) but it’s pretty inflexible. What if I want to pass in an ID, specify a limit, additional conditions, etc?

def self.find_current(*args)
  with_scope(:find => { :conditions => "deleted IS NULL" }) do
    find(*args)
  end
end

The answer is to use with_scope, which allows us to specify conditions here that will apply throughout the course of the block. Now we can do things like:

Item.find_current(:all, :limit => 10)
Item.find_current(:first, :conditions => "name LIKE '%perishable%'")
Item.find_current(13)

Which invoke the find_current method on the model with our additional parameters and includes our deleted condition in the scope automatically.

K, so still not exactly rocket science, but it is a nice, clean solution to a common issue for sure. Unfortunately, with_scope isn’t found in my copy of Agile Web Development with Rails, which is my main reason for noting it here. Hopefully it’ll be in v2! Some other helpful bloggers are out there though, check out Ryan Daigle’s blog, which is where Ian found the article that got us started on this path.

In My Younger And More Vulnerable Years...

2006-11-04T00:00:00-05:00

Thus began the Zerosum dev blog, a place for folks who work on our code to muse about daily development happenings and such.

I’ve never been one to keep a blog, personally, but I think of this area as a useful place for us to post about things that don’t belong in our project trac wiki or elsewhere. Things you want to share with others. Things like: “Wow cool, Ian found a new way to do X that totally rocks. Spread the word” and “Rails migrations rule, check out this snippet!”, and “Saw this thing on Foo’s blog about how to do Y without needing Z. Maybe we should think about refactoring the BlahController to do that too?”

You get the idea.