poocs.net - Home

Ruby & Ruby on Rails Bootcamp 2009

2008-06-20T07:41:00Z

I’ve recently been recruited as an instructor for the holy Big Nerd Ranch and will be giving my first course, the 7-day Ruby & Ruby on Rails Bootcamp, in companion with Charles Brian Quinn of Highgrove Studios fame taking place in March 2009. I’ll take care of the first two days, which will be used to lay a solid foundation of Ruby programming before diving into the following 5 days where Charles teaches all things Rails.

The course takes place near Frankfurt, Germany, at the beautiful monastery “Kloster Eberbach”. In fact, numerous Big Nerd Ranch courses have been held at this venue, the first one being held by no other than Marcel Molina Jr. in April 2006.

For the duration of the course you will stay directly at the monastery, delicious meals will be provided at the historic “Klosterschänke” and the course itself is held on the just as historic “Heuboden”, a truly amazing environment to learn and have a good time. Also included is a tour through the monastery accompanied by a wine tasting.

Check out the course page for additional course details as well as pricing information and registration form.

See you at the monastery!

PS: Not a beginner Rails developer but looking to advance your skills? Charles will be at the monastery for the Advanced Ruby on Rails Bootcamp at the end of August 2008.

Simply Rails 2 now available

2008-05-22T10:21:00Z

I’ve been hard at work getting my Rails beginner’s book Build Your Own Ruby on Rails Web Applications updated to reflect the changes and additions in Rails 2. Part of this process was making everything work even simpler than it has been in the first edition, hence the title change to Simply Rails 2.

All of the chapters have been reworked to incorporate the partially massive simplifications that have shipped in Rails 2 and I’ve also changed the database used in the installation to be SQLite, aptly changed from the MySQL default in both the first edition of the book and in Rails 1.2.

Shovell, the sample application developed over the course of the book, is also developed fully RESTful now, one of the complaints the first edition received.

The chapter on debugging incorporates the content from the former stand-alone article Debugging Your Rails App with ruby-debug introducing you to the newly gained debugging powers from Kent Sibilev’s great debugging tool.

The book finally came back from the printer last week and is now available for purchase from SitePoint in both PDF and hard copy form. They also sell a bundle of both as a special value pack. Of course the hard copy is also available for purchase from the usual suspects.

SitePoint also published an excerpt of the book as an article titled Rails For Beginners: All You Need To Know! and made a PDF of chapters 1 through 4 available as a free download.

Have at it!

Mephisto: Change from SVN to Git

2008-04-19T15:24:00Z

The fine folks over at ENTP/ActiveReload have released version 0.8 of Mephisto, the Rails application that powers this site. With this new release, they, as everyone these days, have actively shifted the remaining bits and pieces of Mephisto’s development from Subversion to Git. (And its main repository is hosted at Github, where else.)

I hardly remember ever installing Mephisto from a tarball. I always used to track its Subversion trunk for the 3 blogs I run, which made upgrading as easy as svn up && rake db:migrate RAILS_ENV=production most of the time. Well, that was then and this is now. Looking at this recent shift to Git, I wanted to convert my blogs to the new Git repository without excessively messing with whatever I did to my local installation (quickly approaching my 30s, I might not even recall most of what I did). I was pretty certain, however, that I did not have massive local modifications. If I had, this approach might’ve been a little simplistic.

Here’s what I did.

Initializing

Starting out, you need to create a local Git repository within your local blog installation, which is as simple as:

$ cd /your/blog
$ git init
Initialized empty Git repository in .git/

The next step is to setup technoweenie’s master repository on Github as a remote to your local repository and fetch what’s currently in there.

$ git remote add technoweenie git://github.com/technoweenie/mephisto.git
$ git fetch technoweenie
remote: Generating pack...
...

This will fetch both the master branch and all branches technoweenie might’ve created. (This includes, for example, a branch that holds the current 0.8 release, if you don’t dare to ride the edge of Mephisto’s development.)

Merging

At this point we need to merge one of the branches we just fetched into your local (totally empty, for what it’s worth) repository. (I’ve decided to stay on the master branch. If you prefer a release branch, substitute it as appropriate.)

$ git merge technoweenie/master

Since Subversion scatters its .svn folders all over the place, we need to get rid of those. You can either do that manually or with a little find-fu.

$ find . -type d -name '.svn' -exec rm -rf {} \;

Excellent, that’s much better. Now it should be safe to check out the current state of affairs:

$ git status

Running this command will show you the currently untracked files. Those would be all files that existed locally before you started to create your own Git repository and which are non-existent in technoweenie’s repository.

Tracking local modifications

As I mentioned above, I didn’t have a boatload of local modifications. My changes were limited to bit of configuration, a few third party plugins (and the accompanying CSS/Javascript) and my local Mint installation. The additional files and directories that may show up are the cached HTML files that Mephisto sticks in public/.

To actually add your local modifications to your Git repository, simple add and commit them.

$ git add config/mongrel_cluster.yml
$ git commit -m 'Mongrel configuration'

If you’d prefer to rather ignore whatever else sits in your blog directory, add it to .gitignore

$ echo "public/*.html" >> .gitignore
$ echo "public/200*" >> .gitignore
$ echo "public/mint" >> .gitignore
$ git commit -m 'Ignore cache and mint' .gitignore

Cleaning up

I had a few files sitting in my directory that weren’t local modifications but seemed to have been removed from the official repository, too. Those weren’t caught by our merging of the Git branch since we started with zero history. To get rid of those, let’s take a look at git-clean.

$ git clean -n -d
Would remove app/views/admin/article_comments/
Would remove app/views/admin/articles/approve.rjs
Would remove app/views/admin/articles/comments.rhtml
Would remove app/views/admin/articles/destroy_comment.rjs
...

The -n argument prevents git clean from actually doing anything. If you’re confident it wouldn’t do anything harmful, go ahread and remove it. (You do have backups, right? Do you?)

At this point we’re down to regular upgrading business, so you might want to run the migrations and restart your Mongrel cluster. (Or whatever floats your deployment boat.)

$ rake db:migrate RAILS_ENV=production
$ mongrel_rails cluster::restart

Into the future

Now, whenever Mr. Weenie adds an exciting new feature to Mephisto you can grab that via:

$ git fetch technoweenie
$ git merge technoweenie/master

Or if you’d rather prefer to pick a specific commit:

$ git cherry-pick <SHA1>

Post deployment log to Basecamp

2008-04-05T14:53:00Z

I guess many of you have been reading the recent Signal vs. Noise blog post titled Using Basecamp to automatically keep track of product releases. I found it rather inspiring so I started to work on something similar for my own projects.

Out of that effort comes a super simple Capistrano plugin that grabs the first line from each commit (the subject in Git lingo) that happened between the last deploy and the current one and posts it as a new message to a pre-defined project (and category) on your Basecamp account using the Basecamp API.

Installation

$ cd <yourapp>/vendor/plugins
$ git clone git@github.com:scoop/basecamp_notify.git

It automatically hooks itself into your deployment process after deploy:symlink has run. Here’s a direct link to the GitHub repository.

If you don’t have git, you can download a tarball from GitHub, but read the caveat in the next section.

Configuration

The download ships with an example YAML configuration that needs to go into <yourapp>/config/basecamp.yml. It takes your Basecamp URL, username, and password as well as the numeric IDs for the project and category to post to, respectively.

Caveat: Since I wanted a fairly concise output in my posted messages (resembling what 37signals has in their example), I used a special command-line argument formatting thingamagick that only Git understands, so the plugin could be considered Git-only for now. Feel free to send in a patch that does the same for subversion.

Questions?

Email me at patrick@limited-overload.de if you have questions. Hope it’s useful for some of you.

UPDATE 04/11: basecamp_notify now has support for Subversion repositories. Thanks pyrat.

Use god to spawn FastCGI processes

2008-02-04T11:34:00Z

For some reason we’re still on FastCGI with one of our apps and it’s not planned to change any time soon. But as is notorious about Ruby’s processes, they can get out of hand, both uptime wise and memory-usage wise. The former is greatly taken care of by the script/spinner utility that Rails ships with. The latter? Not so much.

System monitoring in general

We’ve traditionally employed Nagios as our cluster-wide monitoring tool. However, Nagios gets really clumsy dealing with anything that needs to happen locally on a machine like monitoring a specific process without outside connectivity (think 127.0.0.1) or something like restarting a service that’s unavailable for some reason (nagios-nrpe? Yech!).

A different approach

Then there are systems like Monit and God. Monit attempts to address the issue of not being able to do* anything when you *know something is wrong (like a service being down). And God, well, God is described by its author Tom Preston-Werner (of GitHub and Gravatar fame) as “like monit, only awesome”.

Enter god

God’s awesomeness (apart from its name) comes from the fact that it uses your favorite programming language (and all of its nice syntax tricks) for its config file. The god homepage has a plethora of configuration examples ranging from simple poll-based monitoring to using sophisticated event-based monitoring through its native support for kqueue/netlink, so I’m not going to repeat any of that here. In short: God rocks. (As if you didn’t know that already.)

Replacing the spinner/spawner duo

Here’s a short configuration recipe to replace an existing spinner/spawner configuration for FastCGI with God. Basically, I’m just writing this down for myself, since I’m probably the only one stuck with a FastCGI-based app. So you may just as well stop reading here and grab a latte.


# config.god
RAILS_ROOT = "/apps/yourapp/current"

7000.upto(7009) do |port|
  God.watch do |w|
    w.name  = "#{`hostname`.strip}-fastcgi-#{port}"

    w.pid_file = File.join(RAILS_ROOT, "tmp/pids/dispatch.#{port}.pid")

    w.start = "spawn-fcgi -f #{RAILS_ROOT}/public/dispatch.fcgi -p #{port} -P #{w.pid_file}"
    w.stop  = "kill -9 `cat #{w.pid_file}`"

    w.interval = 30.seconds

    w.start_if do |start|
      start.condition(:process_running) do |c|
        c.interval = 5.seconds
        c.running = false
      end
    end

    w.restart_if do |restart|
      restart.condition(:memory_usage) do |c|
        c.above = 200.megabytes
        c.times = [3, 5]
      end
    end
  end
end

This config spawns and monitors 10 FastCGi processes on the machine we’re running god on. The name god shows in its logs, status reports and email notifications is derived from the machine name plus its port number. The process is monitored every 5 seconds to make sure it’s running. It’s also monitored every 30 seconds (the default) whether it’s above or beyond the set memory limit of 200MB, which was what originally got me playing with god. Of course you can then start weaving in all sorts of additional niftyness such as email notification, monitoring for maximum CPU usage, etc. But that’s beyond the scope of this post and it’s also nicely outlined on the god website. Live monitoring =============== Getting a quick overview what’s up:

$ god status
http-3-fastcgi-7000: up
http-3-fastcgi-7001: up
http-3-fastcgi-7002: up
http-3-fastcgi-7003: up
http-3-fastcgi-7004: up
http-3-fastcgi-7005: up
http-3-fastcgi-7006: up
http-3-fastcgi-7007: up
http-3-fastcgi-7008: up
http-3-fastcgi-7009: up

Fetching log entries for a specific port (sub-string match):

$ god log 7004
I, [2008-02-04T12:31:30.361125 #20050]  INFO -- : http-3-fastcgi-7004 [ok] process is running (ProcessRunning)
I, [2008-02-04T12:31:30.372208 #20050]  INFO -- : http-3-fastcgi-7004 [ok] memory within bounds [92256kb, 92256kb, 92256kb, 92256kb, 92256kb] (MemoryUsage)
I, [2008-02-04T12:32:00.601712 #20050]  INFO -- : http-3-fastcgi-7004 [ok] process is running (ProcessRunning)
I, [2008-02-04T12:32:00.617895 #20050]  INFO -- : http-3-fastcgi-7004 [ok] memory within bounds [92256kb, 92256kb, 92256kb, 92256kb, 92256kb] (MemoryUsage)
I, [2008-02-04T12:32:30.816031 #20050]  INFO -- : http-3-fastcgi-7004 [ok] process is running (ProcessRunning)
I, [2008-02-04T12:32:30.923948 #20050]  INFO -- : http-3-fastcgi-7004 [ok] memory within bounds [92256kb, 92256kb, 92256kb, 92256kb, 92256kb] (MemoryUsage)

Are you using God yet?

Drag and drop file upload on a Mac

2008-01-27T00:37:00Z

Uploading files to web applications via a browser an the accompanying web form is a necessity nowadays. It’s also a necessity to download things at site A and upload them to site B. Or upload something you’ve received in an email. Or upload a screenshot you just took.

While the process in and of itself is fairly straightforward, it can sure be tedious. Especially if you’re hunting a download or a screenshot in the file chooser that seems to be the only way to get that pointer to the file in question down the web browsers virtual throat.

Some site specific browsers such as Pyro (for 37signals’ Campfire) ease that process somewhat by implementing a drag-and-drop handler that allows you to drop files into the Pyro application window, which is then automatically uploaded. Dragging a file into a regular Safari or Firefox window will attempt to view that file, though, which is not what you want (most of the time).

But here’s an interesting observation I made the other day, which I haven’t read about anywhere else.

If you start dragging something into the OS dialog that you get to pick a file with, the dialog will automatically navigate to the folder enclosing the dragged (and dropped) something and pre-select that something so you just need to hit “Open” and submit the form to finish your upload. No hunting up and down folder hierarchies, no endless searching in packed download folders. Just simple drag and drop.

(Please note: This functionality could well be Leopard-only.)

And that something could even be a file from your ‘Downloads’ folder fan out thingy that Leopard offers. Or the handy ‘Drag Me’ control offered by Plasq’s Skitch, completely removing the need to store a one-off screenshot in a memorable place before uploading it somewhere.

Happy uploading.

PS: This does work with any such dialog the OS presents to you, be it an ‘Open’ dialog in TextMate or Photoshop or the file chooser in Safari or Firefox.

Fighting invalid page exceptions

2008-01-21T21:53:00Z

The will_paginate plugin by Err The Blog feat. Mislav sure is one heck of a must have.

But there’s a tiny thing that’s been bugging me for a while. In December of last year (yeah, last year, been a while..) Mislav committed a change to the plugin that changed the behavior of WillPaginate::Collection to raise an exception if/when the page argument converted to an integer is smaller than 1 (which, quite naturally, any non-integer will eventually end up as).

This change was committed as an attempt to address the invalid SQL generation that happened before (you’d end up with something like LIMIT -10, 10 in the SQL given a non-integer page argument), so this is first and foremost a good thing.

If, however, the only thing that ever makes your page argument a non-integer is during those times where your app is attacked by weird spam bots trying to exploit your PHP (cough) application by shoving random strings down your URIs, things slowly start being annoying if you’re using the exception_notification plugin at the same time and end up with hundreds of exception notifications in your inbox (or, heaven forbid, tickets in your bug tracker) for the WillPaginate::InvalidPage exception on a URL like

http://eins.de/videos?page=http%3A%2F%2Fwww.****.info%2Fimages%2Flebun%2Fisexopo%2F

(Obfuscation mine.)

So what’s an annoyed Ruby hacker to do? Work around it!

The global problem

You can surely go ahead and hack a rescue clause into all of your actions that make use of will_paginate but actually you really shouldn’t. You want these things handled globally.

Initially I was trying to go down the simple route, simply handling it via Rails 2.0’s rescue_from macro:


# app/controllers/application.rb
class ApplicationController < ActionController::Base

  rescue_from WillPaginate::InvalidPage, :with => :invalid_page

  protected

    def invalid_page
      render :text => 'Invalid page requested', :status => 400
    end

end

But there are two problems with this approach.

First of all, I actually wanted to serve a real page instead of an error page. Occasionally someone will mistype a URL or someone will link off of his page erroneously omitting something important and I don’t want him or her looking at an error page. I’d much rather have him look at the first page of the collection he’d like to paginate, which should be closer to the page s/he actually requested.

The second problem is that the application in question isn’t running on Rails 2.0 yet. Yes, I know. Bear with me here.

Hacking the root of the problem

Instead of approaching the problem from the controller side I decided to work on it from the plugin’s perspective. I wanted a default of page = 1 unless a valid page was specified. So I ended up patching WillPaginate::Collection#initialize like this:


# config/initializers/will_paginate_extension.rb
WillPaginate::Collection.send :include, WillPaginate::CollectionExtension

module WillPaginate
  module CollectionExtension

    def self.included(base)
      base.send :alias_method_chain, :initialize, :page_sanitizing
    end

    def initialize_with_page_sanitizing(page, per_page, total = nil)
      page = 1 if page.to_i.zero?
      initialize_without_page_sanitizing page, per_page, total
    end

  end
end

This will simply and quite effectively reset the page to view to 1 if anything that evaluates to a zero integer is passed in.

Okay, enough babbling for such a basic thing. Thanks for reading (if you actually got this far).

Special characters and nested routes

2007-11-14T20:58:23Z

I might be the only crazy guy on the planet using strings as the primary record identifier in the URI and also allowing a bunch of special characters in it. And just in case I am, please move along. I’ll just keep this article around as a reference for myself.

Say you’ve got a Rails web app from the early days. Way back when REST and Rails haven’t been spending day and night together. Back when we just had named routes.

But actually, back when it was already popular to occasionally use something different from the numeric primary key to identify a resource in a URL. Example:

/profile/show/scoop

Well, as far as that would actually resemble a URI of my own profile, some people are way fancier with their nicknames and the punctuation therein. The most prominent punctuation character is probably the period (.).

Back in the days, that was all dandy. Well, that was then and this is now.

Meet the Resource

With restful routes, we don’t need no stinkin’ named routes (for the most part). A simple declaration like


# config/routes.rb
map.resources :users

and we get a boatload of useful helpers such as user_path and new_user_path generating the appropriate URIs for us. But I digress.

Rewiring our application to use restful routes for the User model (after having seen the light), all’s well until you try to access a URI like

/users/mr.piggy

Eek! Rails interprets the period as a designation of format, like in /users.xml to offer an XML representation of the requested resource.

Now, who wants a piggy representation of a user?

To allow a period in the params[:id] part of the URL (which, after all, is what the username ends up in after routing is done chopping apart the requested URI), Rails 2 will have a way to re-use the :requirements parameter as an argument to map.resources, like so:


# config/routes.rb
map.resources :users,
  :requirements => { :id => %r([^/;,?]+) }

(Note: This has been committed to the Rails trunk back in February of 2007 as changeset 6232. I backported it as a patch to Rails 1.2 residing locally in my application (so I didn’t have to directly modify the Rails code. If there’s an interest in that I’ll post it as a separate article in a few days.)

Boom, now /users/mr.piggy nicely ends up having a params[:id] value of mr.piggy (instead of a value of mr and a failing attempt to render a piggy format).

What about nesting?

But our journey doesn’t end here. Coincidentally, if a site has users, those users tend to interact with it (in a true Web 2.0 fashion, you know).

Adding further to routes.rb, we now have a routing configuration like this


# config/routes.rb
map.resources :users,
  :requirements => { :id => %r([^/;,?]+) } do |users|

  users.resources :interests
  users.resources :buddies
end

Easy, right? Trying to access a URL like /users/mr.piggy/buddies throws an exception though.

No route matches "/users/mr.piggy/buddies" with {:method=>:get}

The fix would be to add the :requirements constraint to all the nested routes as well.


# config/routes.rb
map.resources :users,
  :requirements => { :id => %r([^/;,?]+) } do |users|

  users.resources :interests,
    :requirements => { :id => %r([^/;,?]+) }
  users.resources :buddies,
    :requirements => { :id => %r([^/;,?]+) }
end

Such a nasty repetition. Especially considering we might add a bunch of additional resources in there. Object#with_options to the rescue. Here’s the refactored version:


# config/routes.rb
map.resources :users,
  :requirements => { :id => %r([^/;,?]+) } do |users|

  users.with_options :requirements => {
    :id => %r([^/;,?]+)
  } do |users_requirements|

    users_requirements.resources :interests
    users_requirements.resources :buddies
  end
end

Much better. Accessing /users/mr.piggy/buddies works as expected now, routing to BuddiesController#index with params[:user_id] having a value of mr.piggy, which you can use in a before filter to setup the parent resource.

Final words

It’s debatable whether or not it’s a good idea to allow punctuation characters in the URI. In my case, reworking parts of an existing application with an existing user base of several hundred thousand registered users I didn’t have an option but to comply.

Slow queries: Rails habtm gotcha

2007-11-08T22:23:47Z

Back in the old days when some brave souls started with Rails, the framework would automatically supply helper methods to check the availability of associated records for every has_many or has_and_belongs_to_many association in the form of has_foos?.

For example, given a declaration like this:


class User
  has_and_belongs_to_many :interests
end

would get you User#has_interests? back in the days.

Fast forward to the present, these methods have long been removed from Rails core. There’s no 1:1 replacement, really. When you want to check a collection in a conditional for whether or not it’s empty, there are several things you can do.

Association Proxies, a quick review

Basically, every collection is a derivative of the Array class, as such most of Arrays methods have been (re-)implemented for the respective collection proxies.

First of all, there’s collection#length, which is the most brutal of them all because it simply loads the whole collection into memory and runs #size on it.

Next up is collection#count, which uses an SQL COUNT() statement to just fetch the number of associated records and is usually the quickest way at that.

Finally, there’s collection#size, which is basically a combination of both length and count since it behaves differently depending on whether or not the collection has already been loaded at the time it is being called. Given the collection has already been loaded (by a prior statement in your code, what have you) it’s identical to collection#length. If it hasn’t been loaded, its behavior is identical to collection#count.

Best practice

Judging from the rundown above, it’s usually best practice to simply use collection#size and trust it to do the right thing. In case you’re planning to use a collection as soon as you found out there are records associated with it, use collection#length to load the connection right away and then loop over it. Beware, however, that this is advisable only for those cases that don’t use pagination. (You’re using will_paginate for that, aren’t you?)

In a conditional, it makes most sense to use collection#empty?, which uses size#zero? internally.


unless user.interests.empty?
  # ...
end

The problem

99% of what I said above applies to both has_many and has_and_belongs_to_many associations. Admittedly, poor little habtm has had its momentum and seems to be on the way out of the cool kids’ block. Still, there are a few cases where it’s still the best fit (such as the User#interests example from first section of this article) and some people *do* have Rails code that’s been in existence for a few years. (Well, maybe only I do.)

So, the 1% that behaves differently is that size on a habtm collection is not as intelligent as its little brother from the has_many camp. In fact, it’s pretty dumb because it’s in every case behaving identical to length meaning it’s loading the whole collection. Ouch.

>> user.interests.size
  Join Table Columns (0.001284)   SHOW FIELDS FROM interests_users
  Interest Load (0.001263)   SELECT * FROM interests
    INNER JOIN interests_users
    ON interests.id = interests_users.interest_id
    WHERE (interests_users.user_id = 142841 )

The solution

You have to fill in the gaps of habtm#size’s lack of intelligence yourself. If you trap over habtm queries that take way too long for your taste, it might be about time to swap out that size call for an always speedy count call.

>> u.interests.count
  Interest Columns (0.001006)   SHOW FIELDS FROM interests
  SQL (0.009749)   SELECT count(*) AS count_all FROM interests
    INNER JOIN interests_users
    ON interests.id = interests_users.interest_id
    WHERE (interests_users.user_id = 142841 )

You would then also avoid using collection#empty? in your conditionals, since that would then resort back to using size internally. Instead, use the count#zero? form or define your own instance methods on the association.


if user.interests.count.zero?
  # ..
end

Postscript

To actually find out what Rails is transforming your method calls into (in terms of generated SQL) I prefer to use this technique by the always-wise Jamis Buck. Redirecting the ActiveRecord logger to the shell’s standard output will intermix the SQL statements with the output of your method calls, making everything relevant visible at first glance.

Revisiting date localization for Ruby 1.8.6

2007-10-23T14:45:06Z

Welcome to my yearly post about a revised version of a simple way to localize Ruby’s Time#strftime method (after my original post in ‘05 and the update in ‘06).

What’s changed?

In my original methodology, the arrays in the Date class containing the actual day and month names in clear text had to be replaced by strings wrapped in the infamous _() call of GetText in order to spit out their localized versions when requested from the modified Time#strftime call.

When Ruby 1.8.6 came along, it had its Date array constants frozen. While I agree it’s generally not a good idea to modify the contents of a constant (it’s a constant after all, mind you), the implementation I came up with 2 years ago worked fine up to and including today.

Since, also, most of the sites I’m working on require multiple languages (as opposed to, say, a single language set at application boot time), the contents of those Date arrays truly need to be modified at runtime and having those arrays frozen meant jumping through all sorts of hoops to address a supposedly simple issue.

What now?

Well, I had to come up with a way to actually execute the gettext functionality in the context of an object that has the current GetText locale bound to it. The most obvious object with that kind of property is ApplicationController.

But this still leaves us with the issue that we cannot modify the frozen Date constants and that everything we put into these constants is evaluated right away instead of at a point where we have the desired locale set.

What I came up with was a proxy object derived from the Array class that would basically just wrap the cleartext contents that are already in each of the Date arrays but not before they’re actually accessed/output.


    # lib/date_localization.rb
    class GetTextDateProxy < Array

      cattr_accessor :gettext_proxy

      def [](key)
        _(at(key))
      end

      def _(string)
        return string unless gettext_proxy
        gettext_proxy.instance_eval { gettext(string) }
      end

    end

As you can see, the proxy object is pretty simple after all. It just overwrites the default of Array#[] to look up the requested key and then wrap the output in _().

Since I couldn’t actually be bothered to include the whole of Ruby-GetText into my poor little proxy object, I then made room for it to hold a pointer to an instance of ApplicationController in a class attribute called gettext_proxy. The local underscore method of my proxy class then wraps around the actual gettext implementation available to the gettext proxy (read: ApplicationController), returning the string unchanged if there is no gettext proxy and if there is, run the string through the proxy’s gettext method.

Dealing with a state of not having a gettext proxy available is actually necessary in cases where there are calls to these arrays before ApplicationController gets to hook itself up to GetTextDateProxy.

But how does this actually hook into the Date class now? Let’s take a look:


    # lib/date_localization.rb
    class Date

      silence_warnings do
        %w(
          MONTHNAMES DAYNAMES ABBR_MONTHNAMES ABBR_DAYNAMES
        ).each do |array|
          class_eval %( #{array} = GetTextDateProxy.new(#{array}) )
        end
      end

    end

While this still looks a little tedious, it’s far less tedious than repeating the arrays’ contents simply wrapped in _() all over the place, like we had to do in previous incarnations of this methodology.

Basically, now every array is hooked up with their very own instance of GetTextDateProxy which then takes care of running the strings through gettext in the appropriate moments.

Wiring it all up

For the last part, we need to get ApplicationController to hook itself into GetTextDateProxy after having received the appropriate locale for the request it’s dealing with.

The best fit for this is the after_init_gettext hook provided by Ruby-GetText. Adding this code to ApplicationController will take care of the last required step.


    # app/controllers/application.rb
    after_init_gettext { GetTextDateProxy.gettext_proxy = self }

Here you go, working (albeit hackish) localization for Ruby’s Time#strftime working up to and including the most recent version of Ruby, which is 1.8.6 as of this writing.

Enjoy.

Ruby-Debug HOWTO and free book

2007-10-02T18:59:24Z

Somewhere between the release of my Rails book and now, several things happened. First of all, Ruby 1.8.6 was released in March and quickly became the preferred version to use with Rails application with the release of Rails 1.2.3.

This, however, meant the end to the era of the breakpointer library to debug your Rails application, which relied on a bug in Ruby that had been fixed in Ruby 1.8.5 onwards. The Rails Core group was quick to adopt ruby-debug, Kent Sibilev’s native implementation of a Ruby debugger which was also heavily inspired by more powerful debuggers from other programming languages such as C.

With the preview release of Rails 2.0, available since Sep 30, integration of ruby-debug has been fostered even more.

For this very reason, I recently sat down and wrote a replacement chapter for my Rails book that serves both as a gentle conceptual introduction to ruby-debug (which still somewhat lacks detailed hands-on articles, due to its still fairly young age) and a replacement for the example debugging sessions the printed book has (but relying on the slightly different operation of the breakpointer client).

The article is available through SitePoint.com. Please note, however, that you should have the source code for the sample application from the book available, to give yourself some context and the full scope of the code.

Rails book available for FREE

On a related note, SitePoint, the publisher of Build Your Own Ruby on Rails Web Applications, decided to offer the entire book as a free PDF download for a limited time period of 60 days starting today. Grab your copy of the 474 pages (including the updated chapter on debugging making use of ruby-debug) here.

RailsConf Europe 2007 Retrospective

2007-09-23T22:08:00Z

As some of you might or might not now (depending on whether or not you’ve been following my Twitter stream), I’ve spent the past week touring Berlin for RailsConf Europe.

Foreword

It’s always a difficult undertaking who you’re trying to attract with such a specialized conference like RailsConf, being about a specific framework in a specific area of development (The Web). Go too technical and lose the beginners. Stay too broad or basic and lose those who have been following for years. With RailsConf Europe 2007, I think the balance was basically pretty much spot on.

But: The same holds true for the audience, too. I occasionally had a hard time figuring out the “level of sophistication” of some of the talks beforehand, so I could decide which of the 4 tracks in parallel was worth attending. And sometimes I picked wrong and let go of a presentation for one that turned out to be much too broad and lacking depth.

I’m sure attempts to solve this issue have come up before. Everything from including a short passage of “recommended skills to attend” or a simplified, numeric “sophistication index” that goes on the schedule with the title and description of the talk might help. Or create additional confusion. There you have one of the reasons why I’m not putting together conferences.

Tutorials

RailsConf Europe 2007 kicked off on Monday, September 17 with a day of (mostly) half-day tutorial sessions in parallel tracks. (One of the morning tutorials then had to be cancelled at short notice, though.)

I had opted for the BDD tutorial from the RSpec guys. I’ve been using RSpec in a couple projects now so I was well prepared for not getting too much out of it, but still hoped that some best practice would be dealt with.

The guys were indeed having a good time on stage and the presentation was okay. (Actually, it was fairly uncommon practice to use a mind-map instead of presentation slides, but let’s save that story for next time.)

The tutorial got messy when the audience was asked to download the code for a sample application from the RSpec Subversion repository and no-one was actually able to get more than a few bytes down the pipe due to the massively overwhelmed Wi-Fi (more on that in a later section). This then exaggerated into a wild USB-stick trading scene and in the end we didn’t even get around looking at the code at all. That was a tad disappointing.

In the afternoon I then attended the Scaling Rails tutorial of Jason Hoffman of Joyent (I have that scaling thing going, as some of you might remember).

Jason spent quite an amount of time talking about some of their preferred hard- and software setups as well as some of the specifics of being the host for Twitter, which was nice.

Scaling talks can only be so far applicable to your own itches since this is one of the topics that is so tightly bound to the application specifics that it’s simply impossible to state more than a handful best practices and then spend a great amount of time with case studies.

Keynotes

The actual conference was then kicked off later Monday night by program chair David Black and the opening keynote by Dave Thomas, “The Art in Rails”.

I truly enjoyed Dave’s speech, being the first of his I saw in-person. Rather than giving a tech-heavy presentation (that he had, from his own words, gotten several beating for), Dave went down the philosophical path of contrasting software development with art. His speech is covered sufficiently by Casper Fabricius and Stuart Eccles - I have little (if anything) to add there.

Tuesday morning was then started by The Man Himself, David Heinemeier Hansson talking about the upcoming release of Rails 2.0.

DHH presented smaller increments of progress the core team has made during the past several months and stated that at this point they’re focussing on evolutions rather than revolutions since Rails has successfully had enough of the latter since it was first released.

Rails 2.0 will see a preview release in the short term, so David presented the old (way before Rails 1.0) and upcoming (past 2.0) way of developing a sample application (the now infamous weblog application that starred the very first Rails introductory screencast).

Additional notes and code samples are, again, available from Casper Fabricius.

Another keynote worth mentioning was Dr. Roy T. Fielding’s talk “The Rest of REST”, dealing with, as the name suggest, REST as an architecture of developing modern web applications.

Over the course of his talk, Roy Fielding for several times returned to a graph of how many web sites the World Wide Web had at a certain time while he iterated over major milestones in WWW and HTTP history as well as his involvement sculpting the protocols and specifications that drive major parts of the internet today.

Fielding even looked at Rails’ REST implementation (looking from the outside in, as he hasn’t really developed applications in Rails so far) and offered suggestions on how to improve it. His slides are available.

Sessions

The schedule of RailsConf Europe 2007 was packed. 50+ sessions were scheduled to take place in 4 parallel tracks. Of positive note should be that the track locations were so close together that almost no time was lost traveling around. But, as indicated in the foreword, there were time slots in the schedule that had me want to split in quarters to be able to attend all 4 tracks at once.

Another negative aspect was that only the keynotes were actually recorded. Having missed out on a couple sessions for the reasons above, I’m not even able to watch a recording of a session I missed.

From the sessions I went to I really liked Evan Phoenix’ presentation about the state of Rubinius, his alternative Ruby implementation.

Evan is now working full-time on Rubinius (financed by EngineYard) and has made really good progress during the past months. He’s anticipating a preview release of Rubinius 1.0 as early as November (yes, of 2007).

Apart from the interestingness the Rubinius project brings with it, Evan sure had the best made up stats graphs of the entire conference. Not to mention his awesome tie.

In a fill-in effort for Jamis Buck (who just released Child 3.0), Marcel Molina Jr. joined Michael Koziarski in a Rails Best Practices session along the lines of what they do over at The Rails Way.

Using several (supposedly bad) code samples the duo explained how one could improve readability, modularity, and maintainability all at once by following several simple guidelines such as ”Skinny Controller, Fat Model”, as first introduced on Jamis Buck’s blog in 2006.

Make sure all of these suggestions go straight into your “common sense” bin.

The Venue

RailsConf Europe 2007 took place in the Maritim proArte Berlin. As soon as your brain adjusted for the fact that the street-address-facing side of the hotel is actually a mall that doesn’t look at all like a hotel, the hotel worked fairly well as a venue for a 800+ attendee conference.

Being located in downtown Berlin on Friedrichstrasse, the hotel was both in little distance to most travel places (3km to the central station, 15 minutes cab ride to the next airport) and around lots of decent food places.

Speaking of food, lunch was a disaster. And I’m not talking about the food per-se (which was good), but the organization around getting 800+ attendees to their food (or rather, vice versa). If the session you attended happened to end a few minutes late, you’d have to expect to be stuck in lines for the next 20-30 minutes, risking either your cigarette break or your siesta (or both).

The breaks between the sessions as well as the lunch and intermediate breaks were nicely laid out and enough time for both participants and the venue staff to re-arrange the conference rooms going from keynote-mode into split-tracks mode.

From a technical standpoint, two things got in the way of the conference being a full win. First of all, as mentioned in the tutorials section above, the Wi-Fi was unusable most of the time. Luckily, the Wi-Fi at Starbucks right next door would accept the conference credentials for access and provided much better connectivity.

Additionally, the lights on stage and in the session rooms were really bad if you happen to have a passion for photography. Even Mr. Conference Photography himself twittered that. So for the next event, I’ll have to bring my flashes and PocketWizards and mess with Duncan’s lighting.

Summary

It was indeed a good conference where I’ve finally met several people I had only been having electronic conversations with. (So that part of the “networking” actually worked out well.)

Now I’m looking forward to RailsConf US 2008 in Portland (May 29-Jun 01), although I’m not yet certain that I will be able to attend. The next RailsConf Europe will be in Berlin again, but the dates aren’t set yet. As David Black put it: “Block out the entire fall.”

Apple Wireless Keyboard: First impressions

2007-09-21T08:28:00Z

Apple announced new keyboards alongside its new iMacs in early August, but the bluetooth variant wasn’t shipping until mid-September. As you can see, mine just shipped (I’ve been using Apple bluetooth keyboards since they first came out).

When you initially open the package, these things really seem tiny. But in the end, they’re exactly the size as the thicker older model minus the numeric keypad and cursor keys moved over.

With regards to the touch feel (and I’m typing this on the keyboard you see above), they feel different but I can type quick and fast easily. The keyboard of my MacBook Pro still feels a little softer and typing on the old whitish Apple keyboards is a different deal altogether. The lowered height of the device is definitely a welcome change.

So far I don’t miss the numeric keypad (and I’m far from being an accountant). The only thing I have to mentally adjust for is the lack of an enter key right next to where I keep the mouse. Due to the smaller size, my mouse currently lives quite a bit to the right and I tended to hit that extra enter key with my right hand occasionally when reaching over from the mouse. This hits solid table ground for the time being. But I’ll live.

Keyboard Update 1.2 popped up when checking with Software Update after pairing the keyboard, installed and rebooted, the new keys for Dashboard and iTunes (play/pause/skip) worked immediately. So no issues to report there.

Update: Here’s a shot of the front edge with a (metric) ruler attached to it, as some commenters indicated interest in it.

Highrise: Use Tags as the Poor Man's Case

2007-09-11T18:15:00Z

Highrise, 37signals’ simple CRM system, features cases to keep related stuff together. Depending on which plan you’re on, you may end up with anywhere from 1 to unlimited cases available to you.

Well, I love cases. And I hate them at the same time.

The problem with cases

We’re currently in the process of building a house. That means a lot of correspondence and a lot of involved people. I currently have more than 30 people attached to my ‘House’ case. Arguably, I could split it up into multiple cases, but that wouldn’t address my issues and concerns with the use of a busy case like this.

First of all, case assignment is a manual process. And it’s always at least 2 clicks away (and something you have to remember doing). (Reducing clicks is good, btw.)

When you’re adding a note to a contact, you have to remember clicking that little “Show options (files, cases, permissions)” to actually pick your case from the drop down menu. Admittedly, 37signals did try to reduce clutter in that form and all options besides the case drop down would actually *be* clutter. However, one out of two notes I’m adding I forget to assign a case. Blame it on my age.

Things get much worse when you’re just forwarding or Bcc’ing email to Highrise. That puts off case assignment even farther as you have to remember to actually open Highrise to do so. That, I won’t remember for life.

Enter Tags

The tags implementation in Highrise has recently seen welcome improvements. Most recently, they rolled out an update that lets you filter by multiple tags and a while farther back they gave us tag streams and tag tabs.

What especially the latter improvement buys us is a way to circumvent the cumbersome case assignment problem I was talking about in the last section. tag streams will collect all correspondence with contacts having a particular tag assigned automatically, whether you manually add notes directly in Highrise or forward/bcc email to Highrise. The tag stream will immediately reflect the new item.

Another little nicety of the tag streams is that they carry over the little ‘Task completed’ markers for completed tasks assigned to contacts tagged with a particular tag.

Tags, as mentioned before, will also show up as one of the recently visited tabs at the top of the page, next to contacts, companies, and ‘real’ cases. Additionally, the ‘Tags’ tab provides you with a list of all of your tags as well as recently viewed ones for easy and speedy access.

Finally, if you’re on the Free or Personal plans of Highrise, tags obviously won’t count against your limit of cases are allowed to have open simultaneously.

The Drawbacks

We all know there is No Free Lunch.

Using tags for cases means that as soon as a contact is involved in more than one case (or tag) you’re out of luck. The correspondence of both tags would accumulate in the tag streams and things would get wonky.

Also, while you can assign tasks to a case, you cannot assign tasks to tags (yet?). While this is not mission critical, I occasionally make use of this feature when dealing with cases.

On a visible note, cases nicely display the attached contacts and companies right there next to the stream of notes attached to a case. Highrise’s tag streams are just that, streams of correspondence. There’s a separate page for listing the contacts and companies tagged with a given tag.

Lastly, tags don’t have an open/close status like cases do. And since Highrise doesn’t allow for renaming of tags after the fact, you’re stuck with either removing tags from contacts after projects are done or have them stick around forever.

Conclusion

I mostly find myself using tags to complement cases, not instead of them. I hate going over a day’s correspondence to reassign cases so I tend to trust my tagging when reviewing a certain project’s correspondence through its tag stream. Cases still give the better overview in terms of being open and closed, though. Maybe a future Highrise update will rectify some of the concerns I’ve raised in this post requiring another mind shift.

September 2007, a life update

2007-09-05T18:43:00Z

Tap tap, is this thing on?

Looking at the fact that the most recent article on this site was written on May 9 was making me sad for a long time, yet I always found plenty of excuses to not produce new content. (All of them being moot, of course.)

So here I am, finally convincing myself that letting this site die out totally would be bad in way too many ways. I haven’t yet formally decided in which direction content will be flowing, so I’ll try to give a simple update of recent happenings.

The book

The major project that kept me busy during the second half of last year was of course finishing up my beginner’s book about developing Rails applications for SitePoint. Build Your Own Ruby on Rails Web Applications has been selling for roughly 6 months now and I’m eagerly awaiting the first sales figures.

Due to the fact that we were pushing the book out right after the release of Rails 1.2 it might’ve been a bumpy ride for some readers at some point since several major things changed in the Rails world after the book went to print. Because of that, the book ended up with a fairly big chunk of errata. Still, it was the right decision to focus on Rails 1.2 at that point and the errata has hopefully been comprehensive enough to assist readers when they got stuck. I also monitor the SitePoint forums closely and jump in to assist whenever necessary.

Additionally, one particular chapter in the book, although still applicable, got outdated quickly and will soon enough be replaced with new content that is going up on SitePoint.com as an article real soon now.

Gwen turns 2

On July 30th, my daughter Gwendolyn turned 2 having her first “real” birthday party with friends and such. It was an exhausting endeavor for both her and us :) But still, a lot of fun!

In general, Gwen’s been awesome. Although she’s only two, she’s talking about as much as I am, probably more. So much talking, so many words coming out of her baby brain. She’s also learning the alphabet using her new VTech learning laptop.

Oh, and no, as Kottke put it, this site won’t turn “into some kind of daddyblog” either.

RSpec

After having happily spent a long time in the test/spec camp when it comes to Behavior Driven Development for my Rails projects, I’ve recently started to adopt RSpec for my current and future projects. Its tight integration and the solidness coming with recent releases (past the 1.0 milestone, I guess) really made it a joy to work with.

Currently being in an unreleased and still-ironing-out-the-bugs state, the next release of RSpec will also come with rbehave merged into it, so it’s also possible to setup user stories to replace Rails’ own integration tests. Pat Maddox has a beautiful write-up on this very topic.

The lead developers of RSpec are also giving a talk titled A Half-day of Behavior-driven Development on Rails at the upcoming RailsConf Europe.

Visited by JDD

As for even more recent happenings, my friend and photographic mentor James Duncan Davidson visited me as part of his trip to Europe this month. Besides the usual “show me yours and I’ll show you mine” geekery we’ve obviously been out and about to shoot a few frames of several places in and around Wiesbaden, Germany.

Although the weather was far from striking (cloudy skies, frequent yet light rain showers), a couple pictures actually turned out pretty decently. You can find Duncan’s photoset here on Flickr, mine is right next to it. Duncan also blogged about this part of his trip.

RailsConf

Speaking of Duncan, he’s also hopped to Europe to shoot RailsConf Europe taking place in Berlin, Germany this year from September 17-19 featuring a boatload of interesting talks and sessions. While yours truly will not be presenting anything, I’m attending the conference and will be in Berlin starting September 16. Shoot me a message if you’re in town as well.

And by the way of Rails conferences, I’ve also attended Rails Konferenz in Frankfurt, Germany last June. My set of pictures shooting the conference can be found on Flickr, as usual. The conference itself was a little lacking, for my taste, probably due to the fact that RailsConf Europe is coming up now and people had been opting to rather go there instead of the Frankfurt one. Still, it’s a worthy effort that Thomas Baustert and friends should keep on pursuing.

Photography

As you might’ve guessed from the entries of my tumblelog and the references in this article, photography has taken up quite a seat in my life. I have yet to find my favorite shooting environment (although I’m pretty much certain that I don’t want to pursue a career as a beauty and fashion photographer) so I’m experimenting with all sorts of different shooting situations from available light to using strobes, from landscapes to studio work, from conference shooting to casual street shooting.

The workflow tool of choice as of March of 2007 has been Adobe Lightroom (previously I was hooked up to Apple Aperture until it showed that Lightroom’s workflow was so much faster dealing with huge RAW images of my Canon full-frame body).

Lightroom has really been a pleasure to work with. If you need a primer of what it can do for you, Michael Reichmann’s and Jeff Schewe’s Lightroom Video Tutorial sold through Luminous Landscape is probably the best resource for this. Additionally, the O’Reilly blog Inside Adobe Lightroom has daily tips, tricks and workflow help for working with the program. Duncan even published two of my Lightroom tips recently.

I’ve setup a placeholder site at photo.graphi.st for what may or may not become a future business.

OmniFocus

Self-organizing by using methodologies such as Getting Things Done and Inbox Zero have long been part of my life. What I haven’t found thus far was the perfect tool for the job. I’ve pondered baking my own, but haven’t gone down that path for various reasons, the most important being.. the lack of time.

Right now my private and professional life is spread over several tools, including but not limited to the trio infernale from 37signals (Highrise, Basecamp, Backpack), my IMAP mailboxes, and, as of recently, the still-not-quite-beta OmniFocus from the OmniGroup.

OmniFocus still has some way to go before being able to take over the center spot of my self-organization. But let’s be fair, they haven’t left the alpha stage. Yet still, they’ve accomplished quite something with regards to the workflow OmniFocus encourages. My major roadblock right now is the fact that it’s a desktop app. My tasks have always been with me in some form, yet with OmniFocus and even using tools like FolderShare (ignoring the fact that they’ve been acquired by Microsoft and been dormant for quite some time now) means I’ll have to remember to close the application on all of my machines when leaving the house or office or it’ll complain about “already being open”.

Maybe there’s a blog post or two to come out of this. I don’t yet know. I’ll try hard to adopt. And adapt.

Music I’m listening to

Closing off this way too lengthy post, here are some of the albums that I’ve recently added to my playlist.