codigo ergo sum

It's a spec, not a test

2010-06-03T00:00:00-07:00

You must have heard the question several times on the Rails mailing list and different IRC channels: "Should I test validates_uniqueness_of"? The standard answer to that one is "No, you definitely should not. It's Rails framework code, and it's already thoroughly tested. If you followed this path, you should also test whether objects are properly persisted in the database."

I think, however, that the question is wrong and thus you can not give a correct answer. It is wrong because validates_uniqueness_of is the implementation, not the requirement. If you approach it from this angle, the question turns into whether you should test the specific implementation or whether you should verify that (business) requirements are met.

That, in turn, comes down to tests vs. specs (short for specifications) and this is again an opportunity for specs to shine. If you write specs instead of tests (or, to put it in a more mind-warping way: if your tests are actually specs), then the above question is a no-brainer: it's part of the specification that no two users can have the same email address, so you must have a spec for it:

describe User do
  it "has a unique email address" do
    Factory(:user, :email => "jeff@topnotch.com")
    lambda { Factory(:user, :email => "jeff@topnotch.com") }.should
     raise_error(ActiveRecord::RecordInvalid)
  end
end

On the other hand, if you stick with calling your tests tests (how orthodox! ;) ) then not only you have to think (which consumes a lot of resources), but you can also come to the wrong conclusion and emit a strong business requirement from your test suite. And then you might not remember to have the implementation for it after modifying the code for whatever reason. And then bad things might happen.

(This thought came to me when coming to work in the subway this morning. I was never quite comfortable with the name "specs" but now it's starting to make a lot of sense to me. You are encouraged to disagree. Dissent is what makes the world progress.)

Remove'em trailing whitespaces!

2010-02-16T00:00:00-08:00

Some of you reading this probably use TextMate. It is an excellent editor with two caveats. The first is that you can only see one file in the editing window (no screen split), the other is that there is no save hook. This latter gave me headaches since I can't stand any trailing whitespace in source code and the easiest solution would have been to run a script to remove those when the file is saved.

Without further ado I'll paste my solution below. Obviously this is not a difficult task to accomplish so the goal is to share not to show off. I use Git for SCM and the following solution parses out the files that have been modified and runs the whitespace eraser script for those. If you use something else (why do you?) you should obviously change the first building block:

parse_modified_files_from_git_status.rb

#!/usr/bin/env ruby -wn
modified_file_pattern = /^#\s+(?:modified|new file):\s+(.*)$/
puts $1  if modified_file_pattern =~ $_

rm_trailing_whitespace.rb

#!/usr/bin/env ruby -wn
$:.unshift(File.dirname(__FILE__))

require "trailing_whitespace_eraser"
TrailingWhiteSpaceEraser.rm_trailing_whitespace!($_)

trailing_whitespace_eraser.rb

class TrailingWhiteSpaceEraser
  FILE_TYPES = ["rb", "feature", "yml", "erb", "haml"]

  def self.rm_trailing_whitespace_from_file!(file)
    trimmed = File.readlines(file).map do |line|
      line.gsub(/[\t ]+$/, "")
    end
    open(file, "w") { |f| f.write(trimmed) }
  end

  def self.rm_trailing_whitespace!(root)
    root = File.expand_path(root)
    files = File.directory?(root) ? Dir.glob("#{root}/**/*.{#{FILE_TYPES.join(',')}}") : [root]
    files.each { |file| rm_trailing_whitespace_from_file!(file.chomp) }
  end
end

And then you run it by typing:

git status | parse_modified_files_from_git_status.rb | rm_trailing_whitespace.rb

If you decide to use this, it is more convenient to download the raw source

Hopefully I did my tiny bit to have less trailing whitespace in OS code.

2010 is the year of the Javascript

2010-01-28T00:00:00-08:00

If you've read the The Pragmatic Progammer - From Journeyman to Master (and if you have not, believe me, you should) you might remember one precious advice: learn a new programming language every year. So when the year draws close to its end (around April, that is) I really start thinking about which language should be the one for me next year.

This reflection is very pleasant; it is such a joy to immerse oneself into a new language, to slowly discover its structure, its subtleties and learn new ways of thinking, of approaching a problem (because that's probably the biggest gain of it, even surpassing adding another language to your arsenal) that its prospect is already rewarding in itself.

My choice in 2009 fell on Clojure. I love functional programming, its elegance, its cleanness, its statelessness and after getting my feet wet with ANSI Common LISP a while ago I felt like Clojure would propel me on my way of becoming an FP guru. Guided by a great book I wrote a couple of, admittedly not too difficult exercises (hey, a sudoku solver is already something, isn't it?) and I would certainly like to continue to do more with it in 2010.

Now, on to 2010.

Thomas Fuchs is certainly right when he predicts that Javascript will play an increasingly significant role in web development. I was definitely wrong when I had thought of JS as an undebuggable, structure- and featureless, incoherent language. Of course, you can write Javascript code that is like this but I now think that -at least in the case of Javascript- this tells more about the craftsman than about the language.

Make no mistakes, I can already do Javascript! I can miraculously make a check box appear if you click on a link, or update a database record without reloading the page when you press a button and a ton more such wizardry, really. However, I always felt like there was a whole lot more to Javascript than putting some dumb-looking functions in a file and then include it from my html (no, I don't think inlining it makes a difference) and I felt uneasy about my javascript functions just standing there on their own without any apparent belonging to a group or some kind of cohesive force or idea that holds them together.

My recent enthusiasm comes from the fact that I had to browse through some of the source code of scriptaculous and I really liked what I saw. The enthusiasm is not totally new but looking at that source code demolished the last shreds of my Javascript skepticism, so to speak. So a year later than Peter Szinek I am hopping on the same train: Javascript, here I come! If you have read a good book that enhanced your Javascript foo, please tell me about it in the comments.

And you? Have you already chosen your language for 2010?

Twuckoo 0.3.5 - With email notification

2010-01-26T00:00:00-08:00

As some of you might know, I am running a few twitter channels that use my brainchild, twuckoo, to periodically send a tweet.

In two of these cases the program takes its next message from a file and takes care not to tweet the same thing twice by keeping track of the messages already sent. This means, however, that the pool of sendable messages are depleted after a while and the script simply does not send any more tweets, the channel becomes dead.

This has happened a couple of times in the past and I only realized it with a few days of delay which is kind of awkward (if you were subscribed to one of these accounts, I apologize). So I decided to have twuckoo send a notification in this case so I can go in and refill its queue. Hence twuckoo version 0.3.5 was born which sends an email to the address set in the configuration file when it failed to send a message.

To install it, add gemcutter to the list of gem sources if you haven't already:

gem source --add http://gemcutter.org

And install twuckoo:

gem install twuckoo

You might be thinking that it would be more straightforward to have the program replenish itself so that no intervention from the part of the developer is needed. And you would be right, this could be a task for the next version. I still think it is a good idea to send a notification so the (wo)man in charge knows it happened.

So go ahead, have a look at the README, set up your own twitter channel and don't fret about when the queue would run dry. You'll be notified.

My tech book list for 2009

2010-01-11T00:00:00-08:00

The title probably tells it all, below is the list of technical books I read in 2009. I am -unfortunately :)- not getting paid for any recommendation that lies herein.

My Job Went to India by Chad Fowler

This one is a real motivation booster. Or it might function like love in the case of separated lovers: if you were motivated in the first place, you'll get a kick out of this book and want to do everything it recommends right from the next day. If you were not it might depress you to have to do so many things to stay afloat. Full of useful advices mostly drawn from the author's personal experience in India. 5/5!

(There is a second, reworked version under the name: The Passionate Programmer, you should probably buy that one.)

User Interface Design for Programmers by Joel Spolsky

I real like Joel Spolsky's essays both for the content and for his witty style. I laughed out loud on several remarks in this book, too. The book reaffirms how important good UI is, makes it accessible for programmers by giving guidelines and provides some examples of good (and especially bad) examples. Its style makes the "dry" technical stuff fun to read.

The Pomodoro Technique by Francesco Cirillo

A time-management and productivity tool, the Pomodoro Technique is the latest craze. The technique can be summarized in a few paragraphs, the details fill about 40 pages which comprise this book. The e-book can be downloaded for free. Although I do not follow all the advices described in the book fully (like administering the tasks you have done at the end of each day) I think the technique is a great way to achieve focus especially if you have problems with it. (The PragProgs have also recently published a book about it)

Programming Clojure by Stuart Halloway

Clojure is a functional programming language that runs in the JVM (hence the "j", I guess). This excellent book contains everything you need to know to start (and continue) programming in Clojure from multimethods to infinite sequences, from ways to deal with concurrency to understanding and writing macros. Clojure rocks and so does this book!

The Principles of Beautiful Web Design by Jason Beaird

I bought this book to be able to do a fancier design than putting black text on white background and using ugly textboxes with Times Roman fonts. It has certainly lived up to this goal and it has some very practical advices and links to resources (I particularly liked the chapter about color). Just as its title says, it explains principles rather than implementation details, which is what I was looking for. That said, I still feel I need another book (and a decent amount of practice, of course) to beam me to the level I had planned to reach before buying it. Any suggestions?

Test-Driven Development By Example by Kent Beck

A true classic, I reckon this book is a must-read for anyone aspiring to adhere to TDD or in fact for anyone already doing it at any level of mastery. In the first two chapters two distinct functionalities are developed (the first one, the Money example, in Java, the second, the xUnit example, in Python) by tiny steps using TDD, at each step pondering on the problem at hand and giving an explanation of the chosen solution. The third and final chapter deals with TDD patterns and is an invaluable addition to the first two chapters. Now that I am writing about it I feel like I should reread this book in 2010 (and then probably once every year). Red, green, refactor!

Pragmatic Thinking and Learning by Andy Hunt

The fact that I have not finished only goes to show its splendidness, I simply don't want it to end yet. (I read this in a Paul Graham essay but I can't find it right now). Its subtitle, "Refactor your wetware", is telling: it shows you how to make yourself more productive by harnessing the innate capabilities of your brain and debugging its intrinsic "bugs". I guess it is also a very refreshing read because it is about our mind and its workings and not some dry technical stuff. The stories and anecdotes linked to some of the sections makes it easy to recall the message. In fact, I liked this book so much I created a "twitter mini-framework" and a twitter channel for the concise version of the advices.

Life is not just about stubbing, view helpers and achromatic color schemes

On a Christmas evening, I sat down on a comfy sofa with Révolutions by J.M.G. Le Clézio in my hand and was totally immersed in it right from page one. I realized I need occasions like this to repeatedly remind myself how much I miss of life if I only ever read technical books. (Sadly, my list of novels I read last year is a lot shorter than the above one but I heartily recommend you A Thousand Splendid Suns by Khaled Hosseini and Poisson d'or by J.M.G. Le Clézio)

Any good books you have read?

I am also making a (so far, only mental) list of books for this year and would like to hear your opinion, too. So have you read any books lately that you would passionately recommend for others?

i15r handles non-english source

2010-01-08T00:00:00-08:00

The other day thinking about how i15r could be improved I realized that there are times when the language of the non-internationalized site is not English (surprise, surprise). Add to this that lots of languages have "special" characters, characters that may not be properly found and replaced by the matchers. So I first learned the basics of how Ruby handles encodings (from James Edward Gray's excellent series) and then adjusted a few matchers to catch those special characters, too. (Note: one can't underestimate the utility of a spec suite that covers most of the code)

The specs pass but I am pretty certain there are some cases where the matchers might not be up to the task. If you come through such a case, please submit a bug report. Since there has been a huge improvement in string encoding in Ruby 1.9 (basically, strings now have an encoding as opposed to in Ruby 1.8), there might be some cases where strings are properly internationalized using Ruby 1.9 but not with 1.8.

So if you think this is a valuable addition or just have not tried i15r yet, go get it:

gem install i15r --source http://gemcutter.org

New year, new blog

2010-01-04T00:00:00-08:00

I guess it all began with this blog post. I saw that there is another way for composing a blog post than typing it into a textarea with a WYSIWYG interface (which is, by the way, never really WYSIWYG). It also seemed a lot cooler, something a "real hacker" would prefer hands down. The decision to switch my blog over to a textarea-free motor has been subconsciously made the time I read that post but the implementation needed a year to be realized. I reckon the final push was to see how easy the migration of the blog's content is.

The tools

I decided to use Jekyll, a static-site generator since it integrates nicely with Github and has all the features I need. Being a static-site generator I needed a client-side solution to handle comments. I chose Disqus because that's the one I knew and liked but there are alternatives.

The process

Content migration

I needed continuity and thus migrating the old posts and comments. Fortunately Jekyll includes migration scripts for several blog motors, among them Wordpress, so that was a piece of cake, everything worked out of the box.

For the comments, I used a modified version of Lackac's script, that he so kindly directed my attention to (thank you, Lackac). Clearly it was more work than migrating the posts but nothing to shy away from. (If you plan to switch from Wordpress to Disqus I believe you'll be able to use the script with a few minor modifications.)

New design

For my Wordpress blog, I used a design template that looked ok but was in PHP and was a PITA to modify or to add some styling to. Since I am looking to improve my capabilities as a designer I thought designing my own blog would be a suitable task to get my hands dirty with. I am not concealing the fact that I borrowed ideas from several blogs I liked but hey, they say it's not a shame to copy good ideas so what's wrong with that?

Layout, site feed, etc. with Jekyll

Have I said I love open source? There is a Jekyll wiki that lists Jekyll sites along with a link to their sources so seeing how to set up my blog with Jekyll was quite straightforward. I guess this was still the most time-consuming part of all but I did not really have to think of anything, the steps are well-defined. (Here is the source of my blog if you'd like to take a glimpse.)

Buying a Github plan to be able to use a non-github domain

If you'd like to host your blog under a custom domain (http://codigoergosum.com instead of http://balinterdi.github.com) you'll need to buy a Github plan. Starting at 7$/month for the Micro plan it's not an insurmountable obstacle, in fact it costs less than the Wordpress hosting I am moving away from.

Changing the name

Back in the spring of 2008, returning from the European Ruby conference (and having finished The Pragmatic Programmer on the train) my mind was buzzing with new ideas and I could not wait to set myself on a craftsman's journey.

I felt I needed a blog immediately. The hard part of course was coming up with a name. Since I felt it was more important to get something going than to idle on finding the perfect one (I guess we can call this agile, can't we? :)), I launched http://bucionrails.com. During the almost two years that have passed since that day I have grown somewhat uncomfortable with that name so I decided to change it. I hope you like the new one :). (I set up a feed redirection with Feedburner to notify you of the feed URL change after 15 days but you could directly subscribe to the new feed now)

The end result

It felt appropriate to start the new year with a new blog and -to my surprise- the switch was a lot easier than I had thought. I hope you, the faithful readers of my blog, welcome the change and ameliorate it with your precious comments.

Now I am blogging like a hacker, too!

i15r 0.3.1 is out - now with haml matchers!

2009-12-14T00:00:00-08:00

I've just released a new version of the i15r gem which alleviates the tedious task of internationalizing a Rails site by finding the "static" texts and replacing them with I18n message strings.

The good news -and probably the reason I am writing a blog post about it- is that it can now process haml files, too. This must cheer up those who -like me- have come to like haml so much they now use it for their projects. So go get it and let me know how it works for you.

Rubygems under the hood: hooking into require

2009-10-28T00:00:00-07:00

(See the introduction to the series.)

When you want to pull in a Ruby library, you require it. The library you require has to be on Ruby's load path ($LOAD_PATH) in order to succeed. So let's see how Rubygems hooks into this process.

The secret lies in custom_require.rb. You'll see a nice comment near the top.

When you call "require 'x'", this is what happens: * If the file can be loaded from the existing Ruby loadpath, it is. * Otherwise, installed gems are searched for a file that matches. If it's found in gem 'y', that gem is activated (added to the loadpath).

In fact, that explanation looks so straightforward to me that I doubt if I can add more words to precise it, so let's look at the code together:

module Kernel
  alias gem_original_require require
  (...)
  def require(path) # :doc:
    gem_original_require path
  rescue LoadError => load_error
    if load_error.message =~ /#{Regexp.escape path}\z/ and
       spec = Gem.searcher.find(path) then
      Gem.activate(spec.name, "= #{spec.version}")
      gem_original_require path
    else
      raise load_error
    end
  end
(...)
end

Aliasing a method, redefining it and calling the original version from the redefined method is a very familiar pattern if you have read Rails source code (called method chaining).

So, just as the above description says, if the file can be loaded "without Rubygems" it is and Rubygems never comes into the picture. If not, we make sure that the load error comes from the file not found on the load path and then find the gemspec for that file and activate it.

Activating it adds it to the load path, so we can call the original require safe in the knowledge that it will now succeed and we won't get another load error this time around (and go into an infinite loop). Clever, heh?

This is one of the cases when the code is so simple for a moment I think I could have written it myself. With its <10 lines of code Rubygems is empowered to load a myriad of useful Ruby libraries. Isn't this wonderful?

RubyGems under the hood: Introduction

2009-10-20T00:00:00-07:00

I am not sure about you, but one thing I keep bumping into while developing ruby applications is rubygem version conflicts. If you have ever come across "can't activate activesupport (= 2.3.4, runtime) for [], already activated activesupport-2.3.3 for []" type of errors, you might be sympathetic to the cause.

Since rubygems was and is being written by some excellent Ruby minds I knew the fault probably lies with me and not with the tool. Being a motivated and proud craftsman I felt like I needed to know my tools and rubygems is probably the number one tool most of us Ruby developers use on a daily basis.

I intend to write a mini-series of Rubygems posts. A post will be added to the series when I explore some murky corner of rubygems inner mechanics. Some of the time this will come from a particular problem I come across while coding while on other occasions I might just look into the source code and try to understand what a particular piece of code does.

Now, I realized that when I read on a blog: "I will go into more detail about X in a forthcoming post", it is the surest sign that you will never read about X again. At least not on that very blog. And I am not saying this in a mean way, I think it is very natural for our plans to change ("evolve" may sound better) even on the short term. So I am aiming low and hoping to give you more than you expected. (Notice I wrote "mini-series" which may just mean a couple of posts.)

Do not set your expectations high

I am absolutely not a Rubygems expert so please do not be fooled by the "under the hood" title. This will not be commensurate to Jamis Buck's series on Rails routing. I do not -yet?- have a deep insight and I am not even a contributor to Rubygems.

The forthcoming :) series is just a humble attempt to gain an understanding of a very important part of the Ruby arsenal. I hope to understand it better by explaining to you how it works and I hope you will understand it better by reading my explanation. And last, but not least, I hope we'll both spend less time debugging those tricky issues.

Having said that, I encourage you to participate in the series. Tell me about a particular problem you had with Rubygems. Correct me if I am wrong. Point me to an article where all this is already explained, and much better. Give feedback so this might evolve to be a discussion rather than an academic lecture. Thank you.

Cucumber meets Selenium meets Integrity

2009-09-25T00:00:00-07:00

Continuous Integration (CI) is a basic building block of any project done in TDD style. In brief, having a CI server properly set up guarantees that developers can rest assured that the application passes all its tests and can thus be deployed at any moment. It does this by sending some kind of a warning if something is broken so it can be fixed immediately.

Now I noticed that if a CI server is not in the mix right from the beginning of project, chances are it will never be, that was one of the first things I installed on a new Rails project. My server of choice is Integrity mostly because it is so easy to set up and quite straightforward to use.

Ok, so next we need some tests that Integrity will run at each commit and make sure the app can still be built. As a high-level acceptance test framework, I use Cucumber, which plays very nicely with Selenium for automated in-browser testing. Since nowadays even the most basic web application will have some amount of client-side scripting code (that is, javascript) if you really want to test the features of your application you'll need Selenium tests.

That's when matters get a bit more complicated when it comes to integrating these with the Integrity server. Why? Because on the server you usually don't have the "desktop environment" which is available on the machine you do the development on. By default, you don't run a desktop manager and have a graphic display on a server. A tool called xvfb comes into a picture that emulate a dumb framebuffer so you can still programs that need a graphic display.

To have some practical guidance, here's what I did on an Ubuntu server to enable all of the above:

Install java since Selenium runs in the JVM:

apt-get install java-common sun-java6-jre

Install firefox since that's what Selenium runs by default and that's a very good choice.

apt-get install apt-get install firefox

Install X since that's what the xvfb launches and Xvfb itself.

apt-get install xorg xserver-xorg
apt-get install xvfb

Next I found a wiki that describes how to launch the Xvfb correctly. Log into the server and do:

startx -- `which Xvfb` :1 -screen 0 1024x768x24 2>&1 >/dev/null &

So Xvfb will run on the DISPLAY :1. So far so good. But something was still not quite right. When integrity launched the test suite that included some Cucumber-Selenium tests I received an error message basically saying that no browser sessions could be started. And the solution to that, in fact, is where this post wants to get at.

After a decent amount of head-scratching and code mining I realized that the Selenium server starts the browser on the same display where the server itself (the jar file) runs. I have found the relevant code that assembles the command that starts the Selenium server in the selenium-client gem and figured it was not meant to be run in graphic hardware-less environment since I saw no options to define which display it should run on. So as an easy hack I added the hardcoded "DISPLAY=:1" before it and crossed my fingers.

Bingo, it worked and I had a green build again! What's more surprising is that it still runs perfectly on my Macbook so it seems to run in (some) graphical environments, too. It seems a bit strange to me to have found so little information on this subject since Rails, Cucumber, Selenium and CI are all en vogue so it is possible that I missed something obvious and there is an easier way to do all this. I am very eager to hear how others set up their CI to run automated-browser features. Do you use another tool, not Selenium? Do you use a CI server with a monitor?

Anyway, I certainly hope my hackish solution will prove to be useful for some of you TDD-minded developers out there who run their CI on a simple <name of your favorite provider here> slice.

UPDATE: As a fellow developer and the author of the selenium-client gem himself pointed out library code is not the place for enviroment specific settings. Rather, it should go into the application's code. I guess that leaves the choice of putting it into the code of the application you are building or the configuration of the CI server. This latter seemed more clean to me so I put the following line into config.ru in Integrity's directory:

env["DISPLAY"] = ":1"

There is still something left, though. When integrity -or, to be precise, the selenium process that was launched from integrity- wants to access display :1, it will be denied. You need to explicitly enable local connections by putting "localhost" in a file:

echo 'localhost' >/etc/X99.cfg

, and then using that file as the access records list when you launch the server:

xinit -- `which Xvfb` :1 -screen 0 1024x768x24 -auth /etc/X99.cfg 2>&1 >/dev/null &

(Note that I launch xinit and not startx as before. startx somehow adds another -auth option which messes things up)

There, that should do it. It works and there is no code where it does not belong.

A prime example of not eating your own dog food

2009-07-14T00:00:00-07:00

I realized how 20th century (plus boring and error-prone) it is to write one's invoices by hand. So I went looking for an invoicing application. My expectations were quite low: I wanted one which can be used from my MacBook, has some basic functions that cut down on typing (e.g a client "database"), has a decent design and UI, can make out invoices in different currencies and did not cost more than ~$100.

It seemed like I have found one, which, though it had several minor bugs, seemed acceptable, so I purchased the Basic version. Everything went reasonably well until I had to make out my first invoice in euros. It turned out that the Basic version can only make invoices in Hungarian forints in spite of having a couple of other functionalities (e.g set the VAT rate to 0% automatically on invoices made out to EU companies) which made me think it could make it in euros, too.

Ok, so accounting hell got me again. I sighed and asked the company how much it would cost to have this funcionality. I was informed I had to buy the upgrade to the Business version which costs ~$120 more, roughly the double of the original price I paid! That was too much to take, so I went looking for another invoicing application. After all, it should not be an insurmountable task to write such an app, I murmured to myself.

I did find a couple of very good applications which even overdo what I want them to accomplish. However, the Hungarian homologue of the IRS basically shuts out any foreign competitors by regulating very heavily which conditions must be fulfilled by an invoicing application for a Hungarian company to be able to use it. Bummer.

"There is still a glimmer of hope." - I thought. I checked the Hungarian scene still thinking it could not be that difficult to meet my expectations. Well, apparently I was wrong. The ones I found are either overcomplicated to use, look like home pages in the 80s or are way too expensive. Sometimes all of these. So I put off the challenge of finding an acceptable piece of software and got back of writing invoices manually.

Now you might wonder where the dog food is in the story. Well, today I received the invoice from the company of my purchase of the Basic version of the application. It was written manually on an invoice sheet :) That's tantamount of Steve Jobs using a PC with Windows Vista.

John Doe is dull: the importance of choosing good user names in tests

2009-07-12T00:00:00-07:00

We, developers, have to come up with user names all the time. In this glorious, pioneer era of TDD, more than ever we have to not only enter them into text fields but write them in test files that are part of the code and thus are clearly visible and permanent.

So it is important to give good names, but what is a good name like? I am not thinking about the semantics of the name (whether it has accented letters, or if it has two or three parts, etc.) but look at them from a very personal point of view: whether it makes you, the programmer, satisfied with your choice of names or bored with repeating the same old names you used in other projects and even in those projects, you had copied them from somewhere.

So when writing your first test where a user is needed, stop for a moment and imagine a world which you like and which is amusing in the context of your application's domain (like philosophers playing soccer, Luddites attending a technology conference, etc.). Pick some names and let the feeling that you have created something instead of just using old, boring names fill you with contentment. Whenever you need an other name, take one from your world. If you need further data (e.g date of birth) about your test users you can even do a little bit of research.

Though investing energy in this may reduce the time you spend writing code, compared to all the hours you put into a project, it is negligible. Nurturing this "subculture" in your tests can be very entertaining so you have a good time developing and are less prone to boredom. I think it pays off. We, Ruby programmers all know how important it is to be happy while programming and the effect it has on our productivity.

And besides, do you know of anyone who is called John Doe?

The hashtag (HRT) retweet bot gemified

2009-07-10T00:00:00-07:00

A very simple twitter bot that retweeted everything that was tagged by a certain tag was put together for Scotland on Rails '09. Then, Jaime Iniesta adapted it for Euruko '09. I then forked from his repository, made a few simplifications and minor improvements and DRY-d its configuration.

Maybe most importantly I then turned it into [a gem][hashtag_retweet_home] so that configuration files (including the bot's which has the credentials for the twitter account) do not have to be included in the repository.

I also set up a twitter account for the budapest.rb group where an instance of the HRT bot will post any tweets that have been tagged with #budapestrb. So, my fellow budapest.rb programmers, if you have anything to say about the budapest.rb, just make sure you include the #budapestrb tag in your tweet and watch the HRT bot repeat it.

To launch your own hashtag retweet bot, just follow the instructions in the README.

Pragmatic Thinking and Learning on Twitter

2009-07-03T00:00:00-07:00

Some of you may be aware of my grandiose plans with my twitter mini-framework named twuckoo. For my part I am constantly thinking about -hopefully reasonable- ways that it could be used for the better of mankind :)

The other part of the story is my enthusiasm with Pragmatic Programmers books. I have recently started Pragmatic Thinking and Learning by Andy Hunt which is also a very good one and found the familiar "resuming card" at the end. This card sums up the wisdom of the book in short phrases just so that you can recall what you read quickly. It is a great idea and can be found in other PP books, too.

So I asked at a PP email address which seemed to be closest to copyright questions whether I have the right to do this. To my surprise, it was the author himself, Andy Hunt, who answered me and kindly gave me permission for the book in question. (Once again, thank you, Andy!)

So there you have it, a twitter account that will serve you an advice each day just so that you can "refactor your wetware" (the subtitle of the book) and hopefully help you be a better craftsman.

And now, my little twuckoo, on to world domination!

installing ruby on a linode slice

2009-07-02T00:00:00-07:00

To be able to experiment freely and find a store for my twuckoos and other goodies I have recently purchased a Linode 360 slice and had Ubuntu 9.04 installed on it. Next thing was setting up ruby (ruby 1.8.6, to be precise).

When deciding about how to install ruby, in part I wanted to have flexibility but mostly I wanted to feel like I am a professional sysadmin for some hours so I balked at pre-built ruby packages and went with the roll-your-own approach. I'll summarize below the process and some pitfalls I encountered so it might help someone.

Some basic tools

First, you will need wget (or curl) to download the sources you will need along the way, so:

$ sudo apt-get install wget

Also, before you stare dumbly at the screen (like I did) wondering why can't the stupid machine run make when the Makefile is clearly there in the directory , don't forget to install make:

$ sudo apt-get install make

Updating the package repos

Plus, since we'll be installing packages that are found in the "universe" namespace (or whatever it is called) you should uncomment the below two lines in /etc/apt/sources.list :

deb http://us.archive.ubuntu.com/ubuntu/ jaunty universe
deb-src http://us.archive.ubuntu.com/ubuntu/ jaunty universe

... and then update your package index:

$ sudo apt-get update

Installing some packages ruby needs

Before we download and build ruby, however, it is recommendable to have the zlib and openssl libraries so ruby can already bind to them. This is one of the things that is a lot easier to see with hindsight, but here I am, blogging this to you:

$ sudo apt-get install zlib1g zlib1g-dev zlibc
$ sudo apt-get install openssl

It turns out from this thread, that the zlib bindings are part of ruby since 1.8.6 so you will not need the libzlib-ruby package.

Now, on to ruby itself.

Ruby & Rubygems

$ wget ftp://ftp.ruby-lang.org/pub/ruby/ruby-1.8.6-p369.tar.bz2
(untar and cd to new directory)
$ ./configure
configure: error: no acceptable C compiler found in $PATH

Piece of cake:

$ sudo apt-get install gcc
$ ./configure
configure: error: in `/home/balint/ruby-1.8.6-p369':
configure: error: C compiler cannot create executables
See `config.log' for more details.

A bit harder, but I have quickly found the answer here, and then did:

$ sudo apt-get install libc6-dev g++
$ ./configure
$ make
$ sudo make install
$ ruby -e "p 'hello from linode slice'"
"hello from linode slice"

Rolling!

However, we all know that a ruby installation without gems is a toothless tiger (lion?) so we'll install rubygems last, first downloading the source, and then installing it:

$ wget http://rubyforge.org/frs/download.php/57643/rubygems-1.3.4.tgz
(untar and cd to new directory)
$ sudo ruby setup.rb

If you want to use gems stored on github (and you probably do) it is convenient to add the gem github repository to your gem sources:

$ gem source -a http://gems.github.com
$ sudo gem install balinterdi-twuckoo

Ok, that's all. I hope you have found this useful.

Note:

If you receive an error message similar to the following when trying to install a gem:

/usr/local/lib/ruby/site_ruby/1.8/rubygems/custom_require.rb:31:in `gem_original_require': no such file to load -- zlib (LoadError)

Then you need to install the appropriate lib package and recompile ruby. Go to the directory where you unpacked the ruby source to and do:

$ make clean
$ make
$ sudo make install

twuckoo - my twitter mini framework

2009-06-22T00:00:00-07:00

I am reading Andy Hunt's excellent Pragmatic Thinking and Learning book. There is a section about so called "oblique strategies", short, mysterious phrases that exercise your mind and make you look at problems from another perspective (e.g "repetition is a form of change").

The suggested intake was once a day and there was a free application that did just this for Apple computers. However, the application was so outdated that I could no longer run it on my laptop. So, I set out to write that application and after a bit of thinking decided to make a twitter account where I ("I" meaning a script that I wrote :) ) would post an oblique strategy each day and then just follow that account. This way, I can also spread the knowledge around.

Thus Twuckoo was born. Twuckoo is a simple program (relying on twibot for communication with twitter) that lets you periodically post a message on a twitter account. It can fetch the messages from a file, from a database, from the web or whereever you want it to retrieve them from. Its very modular in nature so it delegates the task of getting the next message to twitter and storing the posts to the module. here is currently one generic module, the one that fetches them from a file, and one that fetches them from wikipedia's main page. I strongly hope that it is very easy for you to write your own module for your own purpose. Twuckoo aims to follow the "provide-what's-needed-and-then-just-get-out-of-the-way" principle. Go check out the README for further details.

It's quite easy to install and run. You can find an example for the file-fetcher module at http://twitter.com/daily_oblique and http://twitter.com/wikipedia_tfa grabs "Today's Featured Article" from wikipedia and posts the title and the link so you can grow a little wiser each day :)

Since it is modular it's very extensible. I kept the API very simple so writing modules should be a piece of cake. Each module has to define the following methods:

load_tweets Loads the messages that can be twittered.
next Gets the next message that will be posted.
store Store the tweet after it had been posted.

Once more, I encourage you to scan through the README, devise your own module and let me know about it. Any feedback is very welcome.

Note: For my Hungarian-speaking readers, I gave a lightning talk about twuckoo at the latest budapest.rb meetup.

acts_as_trivia: would you like to play?

2009-05-18T00:00:00-07:00

We all love playing games, from poker to soccer, from hide'n seek to ... trivia! I am a great fan of this latter and also of Rails apps so it was kind of natural for me to come up with the idea of using all the data in your Rails app to serve as the basis of trivia questions.

The ingredients are few and basic. You have a class with an attribute that is comparable and makes sense to compare (the population of states is a good example, the zip code of addresses is a counter-example).

Installation

Install the gem

Install the gem through Rails's config.gem

Put this:

    config.gem "balinterdi-acts_as_trivia", :source => "http://gems.github.com", 
:lib => "acts_as_trivia"

in your environment.rb and then run rake gems:install or rake gems:unpack.

Install it system-wide with the gem command

  gem install acts_as_trivia --source http://gems.github.com

Make your app act as a trivia

You just have to run the provided trivia from the root of your Rails application:

  ./script/generate acts_as_trivia

Create trivia questions easily from the command line

    ./script.generate acts_as_trivia_record country population name

This trivia question will be about the population of countries and the name of each will be used by the provided helpers for the sake of displaying something unique of each country.

Create the pages to answer and assess trivia

The acts_as_trivia gem only aims to provide a clean interface and the logic, so you will have to create the new controller action of the TriviaAnswersController and the corresponding view:

  /users/:user_id/trivias/:trivia_id/trivia_answers/new

However, you can take a look at these files in the rails app generator or just directly copy them.

Get right in the game

Instead of going through the above steps, you can use a rails app generator to set up a trivia app quickly:

rails my_shiny_app -m 
http://gist.github.com/raw/107361/f31caad451f0cca699288700aa3d98291a259fd1/gistfile1.rb

Once you go through the setup steps of the app generator, you have everything you need to have a functioning trivia app, so you can go to:

  /users/1/trivias/1/trivia_answers/new

And if you created model instances you can already answer your first trivia question. For a more technical (and more complete) description, please see the README. Also, since this is a beta version, please make sure to report any bugs you might come across.

protecting actions of owner-type associations

2009-05-01T00:00:00-07:00

The actions of a web application basically fall into three categories based on their access rights:

Actions with anonymous access
Actions the user has to be logged in to access. (authenticated actions)
Actions the user needs a certain privilege for to access (authorized actions)

At the implementation level, the first category is obvious, since the actions in this category do not have to be protected. So let's shift our attention to the second and third category and consider how access protection for these can be achieved in Rails applications.

Both of these are best done with before filters since they run before the control is passed to the action's code and provide a DRY way to protect several actions.

Authenticated actions

Access restriction is quite straightforward once you have a basic libarary that provides a method to see if a user is logged in (see restful-authentication for a full-scale solution)

class ProfilesController < ApplicationController
  before_filter :login_required 
  (...)
  def login_required
    redirect_to login_path unless logged_in?
  end
end

Authorized actions

This can be more tricky since there is a great deal of possibilities of what privilege is needed to access a certain action (e.g only admins can see the full user list, only managers can edit the employees' records, etc.).

I realized there is one very prevalent type, though, the owner-type access. Only the owner of a blog can modify its data, only the user of a profile can edit its attributes, only the leader of a project can set its deadline, etc. The number of these is endless and I bet there are basically no sites where this does not come up.

Also, the pattern of this access restriction is pretty much the same in all cases. There is the resource to be protected, its owner and the user currently logged in. For access to be granted, the owner of the resource needs to match the current user. So why not extract the pattern to be reused?

Only owner

Hence the only-owner plugin�(I know I suck at naming projects)�was born. By default, it will create a before filter in the controller which checks if it is the owner that wants to access the resource. If it is, access is granted. Otherwise, the user is redirected to the login path. Convention over configuration makes a lot of sense so to get up and running you only need to do these two things:

Install the plugin:

./script/plugin install git://github.com/balinterdi/only_owner.git

"Tag" the controller to be protected:

  class ProfilesController > ApplicationController
    only_owner
    (...)
  end

That assumes that the profile can reach its user through the user association and that there is a find_profile method in scope in the controller. If your association or the finder method is named otherwise, you can pass the appropriate parameters to define them (:owner and :finder, respectively). As a -sensible, I reckon- convention, all methods in the controller except the new, create, index and show ones will be protected by default. Once again, this can be overridden with the usual :only and :except parameters.

I encourage you to scan through the README�for the options and especially, as always, to give me some feedback.

upstream or downstream?

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

With the proliferation of middleware applications the mentions of upstream and downstream servers has intensified so I decided to get to the end of this and find out what exactly an upstream server is. I first looked up wikipedia:

In computer networking, upstream server refers to a server that provides service to another server. In other words, upstream server is a server that is located higher in the hierarchy of servers.

Ok, so based on this simplistic definition, a sketch of a request's route to the application server and the response back can be illustrated like this:

In this drawing, the middleware is an upstream server to the underlying application since it provides a service to it (be it caching, url mapping, exception handling and plenty of others).

So now with my definition established, I was looking for examples in the wild that support it. Jon Crosby's excellent presentation at the MountainWest Ruby Conference used upstream in this context as far as I remember. Check one.

Browsing the source code of rack-cache -which, by the way, I strongly encourage you to do if you want to understand caching (better) or just like the look of clean Ruby code- I realized Ryan Tomayko's definition of upstream coincides with the above one since he uses downstream in the code to refer to the component/application below the rack-cache component. Check two.

I recently set up an nginx web server as a front end server to a mongrel cluster that runs a Rails application. Ok, so in this case, the nginx server must be the upstream server since requests hit there first and then are passed to the mongrels. One must hear the sound of collapse of cards in my head when I saw the following nginx directive:

upstream production_mongrels {
  server 127.0.0.1:8000;
  server 127.0.0.1:8001;
  server 127.0.0.1:8002;
}

Hmm, what? Nginx is above the component it provides a load-balancing service to so by any -ok, by my- definition the directive should say "downstream" and not "upstream".

I realize that the request arrow on the diagram moving from top to bottom is a matter of convention and that it probably correlates with the fact that most languages write from the top to the bottom. Nevertheless, as far as I know Nginx is made by a Russian guy and Russians write top to bottom, too, so he should still use "downstream" for the directive, now shouldn't he? Or did he simply start to sketch up boxes and arrows from bottom to top for the sake of it when designing his web server?

Summing up, I think the above described convention is the common one but since it is not standardized there will always be people and software that uses it the other way around. I am not overly confident though, so please tell me about your definition or just point to examples which support or contradict mine.

have your to_param begin with the record's id

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

If you overwrite the to_param method in your model class such that it does not begin with its id, you can be in for a nasty surprise. Let's say you have a User class and you want URLs to contain the user's login instead of its id.

  class User
    def to_param
      self.login
    end
    ...
  end

And let�s assume you have a user called "bob". One might think the following works:

  >> bob = User.find(3)
  => #<User id: 3, login: "bob", ...>
  >> User.find(bob.to_param)
  ActiveRecord::RecordNotFound: Couldn't find User with ID=bob

But it does not. That's a problem since URLs are created by calling the to_param method of the model instances composing the path and a standard, nice way of finding the model instance (user in our example) in a controller action is to fetch the id (now: user_id) from the controller. That will quickly lead to error messages of the above form.

The reason that it does not work is that ActiveRecord's find method will look for a numerical id at the beginning of the argument. It extracts this id and discards anything that comes after it. It then looks up that id in the database and returns the instantiated record. No numerical id results in an error message. The solution from here on is straightforward, have your to_param return a string where the id comes first:

  class User
    def to_param
      "#{self.id}-#{self.login}"
    end
    ...
  end

>> bob = User.find(3)
=> #<User id: 3, login: "bob", ...>
>> User.find(bob.to_param)
=> #<User id: 3, login: "bob", �>

As a splendid way to prove my point but a totally useless piece of information is that you can put any non-numeric value after the id, and find will still find the record:

>> User.find("3-be-aware-of-what-you-overwrite-to-param-with")
=> #<User id: 3, login: "bob", �>

So I hope you have found this useful, see you in the next episode :)

yes and no in YAML

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

I recently needed to display 'yes' and 'no' "internationally" depending on whether the value of a certain attribute is true or false. So I came up with this simple helper method:

  def to_yes_no(expr)
    expr ? I18n.t('yes') : I18n.t('no')
  end

and the corresponding translations in the yaml file:

  yes: s�
  no: no

It was so obviously correct and yet it did not work. It kept displaying "true" or "false". After about an hour spent scratching my head and juggling with yaml files I finally realized that YAML recognizes the strings Yes and No (or their lowercase versions) and handles them as true and false.

Strictly speaking, one should always put quotes around the strings in the locale yaml files to make sure they are recognized as strings, but it's so much uglier that way. Anyhow, the solution was precisely that:

  "yes": "s�"
  "no": "no"

Now I wonder if this is a case where the grammar designers (or whatever we call YAML) want to be smarter than the programmer. In any case, they were this time :)

finding missing I18n translations with missing_t

2009-03-25T00:00:00-07:00

A recurring problem in an internationalized Rails project is to see which translations are missing. You could go through all the pages looking for "translation missing: en, user, new" texts. That, however is very tedious and error prone. There may be some texts you don't even see that are missing translation. (like a title of an image).

A better solution is to write a program that finds these. So that's what I did. I gave it a very imaginative name: missing_t. It's darn simple. You first have to install the gem:

gem install balinterdi-missing_t

and then from the root of your Rails app you type:

missing_t

You will see all the I18n strings that do not have translations along with the file they were found in. If you want to restrict your search for a specific language, you provide its language code as the first parameter, like so:

missing_t fr

For a bit more detailed description, see the README.

Go ahead, give it a try, your app has the right to speak all those beautiful languages out there!

Thrifty - track your expenses easily

2009-03-17T00:00:00-07:00

Thrifty is a simple application I have written (and am still writing) in Sinatra that tracks your expenses. You can quickly record each spending you make and assign tags to them so you can group your expenditures easily. You can then see how much you spend in different categories (by tags) possibly narrowed down to a given date interval.

Anyway, a web app is all about interaction so give it a try on the test site or download it from its github repo and run it locally. You'll also find a somewhat detailed README there.

This is a very early release so I'd appreciate any kind of feedback, be it a bug report, a comment on bad UI or anything you might find worthwhile sharing.

plans for 2009 - contribute (more) to open source projects

2009-03-12T00:00:00-07:00

At the start of 2009 my friend Jaime resumed his previous year and proposed me to do the same. It seemed a really good idea but somehow it still died down.

I know it's March now but I reckon it's still ok to do this until December :) I'll attempt to write a mini-series of posts about not so much what I did in 2008 but rather what I would like to achieve in 2009.

When I started to work full-time with Ruby I also realized the vast possibilities and magnetism of open source projects. I could -and still can- spend hours browsing among different projects on github, peeping into their code, reading related articles, etc.

So when I set out for this journey one of my tasks naturally became to regularly contribute to a "serious" open source project. When I got acquainted with Merb I also got to know DataMapper, its default ORM. I admired its elegance and coherence and the more I knew of it the more I liked it. So when the maintainer position of a dm-more gem, dm-constraints* seemed to be up for grabs I took the opportunity.

That was in December and since then I sent in a few patches and merged changes implemented by others. (which I realized could sometimes be a lot more difficult than writing code :) ). I like to do this and have learned -and probably will learn- a lot so one of my plans for 2009 is to continue with dm-constraints and maybe find other open source projects I could contribute to on a regular basis.

So, if you happen to use DataMapper, which I strongly encourage you to do, and find a bug related to foreign-key constraints, file a ticket and assign it directly to me (Balint Erdi). And/or start contributing!

Notes

* Dm-more is the meta package that contains everything outside the core functions of DataMapper. Dm-constraints deals with foreign key constraints. If you are familiar with ActiveRecord, it is basically the options you specify with :dependent on an association.

easily quote passage with Mail in a reply

2009-03-12T00:00:00-07:00

That was too long to twitter, so here it goes.

If you use Mail (OS-X) when replying to a message you can select some text in the email you want to reply to and then hit reply. The new email will only include the text you selected so you don't have to delete all the lines you don't need. I hope someone finds this useful, I really do.

Why I love Datamapper

2009-02-12T00:00:00-08:00

I wanted to find the last user in alphabetic order of their names in a Merb project that uses Datamapper (the default ORM in Merb). So I did [*]:

irb(main):020:0> User.all(:order => [:name]).first.name
 ~ (0.032946) SELECT  FROM `users` ORDER BY `name` LIMIT 1
=> "Admin User"

Ok, so the default sorting order is ascending but I need the last one. There are two ways to do this. Write an SQL snippet and sneak in "DESC" somewhere or reverse the collection before taking the first element. Since I was not sure how to sneak in "DESC" plus I prefer writing Ruby to writing SQL hands down, I went with the second approach:

irb(main):021:0> User.all(:order => [:name]).reverse.first.name
 ~ (1.033271) SELECT  FROM `users` ORDER BY `name` DESC LIMIT 1
=> "XX XX"

See what happened? Instead of reverting the collection (which is extra time even if it is done very fast) Datamapper sneaked in that DESC for me! Isn't this just brilliant? Datamapper takes the burden to write SQL off of your shoulders. You can keep writing Ruby statements you presumably love and let Datamapper take care of the SQL reaping both the comfort and the performance gain. [**]. Also, likewise your app stays database type agnostic. Note how it is not supposed there is a RDBMS under the ORM layer. It could work with CouchDB, for example (I think there is actually work in progress for a CouchDB adapter). This is not the only reason I like Datamapper so much, so if you are still not convinced, go check out some other reasons to use it.

Notes

* I could have written this one in a simpler way:

irb(main):018:0> User.first(:order => [:name]).name
 ~ (0.032345) SELECT  FROM `users` ORDER BY `name` LIMIT 1
=> "Admin User"

But you -or at least I- could not do it for the last element (there is no User.last)

** I am not suggesting not to learn SQL at all. I am all for a know-thy-tools approach (especially it it means not cluttering your markup with javascript :) ). However, having the ORM do obviously good things for you is worth it most of the time.

deep_test to become TDD more easily

2009-02-11T00:00:00-08:00

I am all for TDD, really. I did not even waver when recently I have been working on a medium-sized Rails project and running the tests after each change took about 60-80 seconds. 60 seconds is still a lot, though, especially if you go through these cycles ~50 times a day (a wild guess). I also believe in very short test-implementation cycles to stay focused so I was starting to think about ways to keep that time down.

Autotest, part of the Zentest toolbox is a very good choice. It basically runs all the tests automatically after something has changed in the code and more importantly it only runs the tests it deems affected by the latest change. This helped to reduce the amount of time by reducing the number of tests that were run in each loop.

Another I think less well-known option is deep_test which helps to reduce testing time by increasing computational power. More precisely, it runs the tests through worker threads so you can either benefit from using deep_test if you set it up for a computer network (individual computers take from a pool of tests and then send in the results) or if you have a multi-core computer. Since many of us do nowadays, that stepped up as a viable option.

It was quite easy to set up and the results it brought were quite remarkable. It reduced the running time of my tests by ~40% (based on a completely unscientific benchmark). One thing I experienced is that it did not really play out well with sqlite although I have not spent a lot of time trying to make it work there. I just switched to mysql and it worked seamlessly. So yeah, the next logical step was to get the better of both worlds: run only the tests that need to be run and run them on as many cores as possible. I will talk about that in a later post.

I would very much like to hear your experiences and solutions to make TDD a breeze or just plain bearable. I cannot imagine doing real TDD if running tests takes more than a certain time limit, around maybe 90 seconds. Not only you lose a lot of time waiting for the tests to finish, more importantly you fall out of the falling test-implementation cycle, you lose focus, your mind drifts away and then the whole thing probably just does not work.

simple to-do list in Sinatra

2009-02-09T00:00:00-08:00

After Bence Golda's presentation at the last budapest.rb meetup I decided to build something easy in Sinatra since it seemed so cool and easy to do. And I have to tell you, it really is both.

With zero prior experience with Sinatra and only a bit of fresh HAML knowledge, my todolist was ready in a few hours. What can you do with it? Add todos to your list and delete them when you are done. What features does it have? Unobtrusive javascript :) What does it lack? Obtrusive javascript :) User-related funcionalities, the possibility of having more lists, seeing done todos, etc. Lots of things. But with the ease of development Sinatra provides I am sure that for a simple application like this these could be added quite quickly. And then tadalist.com would be running for its money :) (I know, it's free).

ps. I use an ORM, datamapper to not to have to deal with SQL directly, so you'll have to "gem install dm-core" beyond the sinatra gems if you want to run the app.

strings as haml render parameters in Sinatra do not work

2009-02-04T00:00:00-08:00

I was intrigued by the simplicity and elegance of Sinatra as presented by Bence Golda at the last budapest.rb meetup., so I decided to build a simple application with it (I am planning to talk just a little bit more about that in a later post).

One quick thing I learned the hard way is when generating haml views in Sinatra, you have to use symbols as the name of the view, strings will just be rendered as strings. That was a tough lesson to learn coming from Rails. So while in Rails you can write:

  def index
    render :action => :index
  end

  def index
    render :action => "index"
  end

In Sinatra, you can only use a symbol to designate the view to be rendered:

get '/' do
  haml :index
end

Which makes sense, I think, since symbols (unlike strings, see below) with the same name refer to the same entity which is a perfect fit for naming views, now ain't they? Plus, I'll admit I am in love with them symbols, with their colon in the front and all. And when they are syntax highlighted, I melt.

irb(main):002:0> sym1 = :index; sym2 = :index; sym1.object_id == sym2.object_id
=> true
irb(main):003:0> s1 = "index"; s2 = "index"; s1.object_id == s2.object_id
=> false

Shoulda: setup and should blocks and don't wander off the map

2009-01-28T00:00:00-08:00

I'm using shoulda for testing in a rails project and I wrote this simple test to see if my update action really updated the object and redirected to the appropriate place:

context "the update" do
  setup do     # 1
    @project = Factory(:project, :director => @user)
    put :update, :id => @project, :project => { :name => "updated name" }
  end
  # 2    
  updated_project = Project.first(:order => "created_at DESC")
  # 3
  should_redirect_to "project_url(updated_project)" # 4
  should "update the attributes" do
    assert_equal("updated name", updated_project.name) # 5
  end  
end

To my surprise, I received an "undefined local variable or method 'updated_project' on both tests (#4 and #5). I figured out why and I want to share it with you. In case you are a shoulda expert, you must know the answer already and sorry for wasting your time. On the other hand, if you are new to shoulda like I am, you may find this useful.

What shoulda does when running a 'should' block is that it runs all the 'setup' blocks of the contexts in which it is nested, from the outside to the inside, so this:

context "alpha" do
  setup do
    puts "A"
  end
  context "beta" do
    setup do
      puts "B"
    end
    context "gamma" do
      setup do
        puts "C"
      end
      should "work" do
         puts "the only test"
      end
    end
  end
end

Will print

A
B
C
the only test

Also the area between #2 and #3 in the above test is sort of a no man's land, since it is not in a setup block, so assignments that are executed here are completely useless. You can not use it either for side-effects since it will run before the setup block (#1 above). My advice is to simply put everything in a block, be it a 'setup' or a 'should' one. (the 'should_redirect_to' is a macro that's part of shoulda, it gets expanded into a block, too).

So here is the same test correctly:

context "the update" do
  setup do
    @project = Factory(:project, :director => @user)
    put :update, :id => @project, :project => { :name => "updated name" }
  end
  
  should_redirect_to "project_url(@project)" 
  should "update the attributes" do
    # reload is needed to see the new state
    @project.reload
    assert_equal("updated name", @project.name)
  end
  
end

Shoulda is a nice tool. There is only one I know and I like a tad better which is quite similar in structure, rspec.

MySQL table types and foreign key constraints

2009-01-25T00:00:00-08:00

Uff, I have recently spent some time checking foreign key constraints in MySQL and I got a bit upset. The MySQL docs tell you that InnoDB tables support foreign key constraints but that's not the same as saying MyISAM tables do not. More importantly, an error (or at least a warning) should be raised so that I am not relying on something that seems to be there when in fact it is not.

Here is the raw SQL:

CREATE TABLE `drivers` (
  `id` INT PRIMARY KEY AUTO_INCREMENT,
  `name` VARCHAR(100)
);


CREATE TABLE `cars` (
  `id` INT PRIMARY KEY AUTO_INCREMENT,
  `plate_number` VARCHAR(12),
  `driver_id` INT,
  FOREIGN KEY (`driver_id`) REFERENCES `drivers`(`id`) ON DELETE CASCADE
);

INSERT INTO drivers(name) VALUES ('bob');
INSERT INTO drivers(name) VALUES ('alice');
INSERT INTO cars(plate_number, driver_id) VALUES ('bbb', 1);
INSERT INTO cars(plate_number, driver_id) VALUES ('ooo', 1);
INSERT INTO cars(plate_number, driver_id) VALUES ('aaa', 2);
INSERT INTO cars(plate_number, driver_id) VALUES ('lll', 2);

mysql> delete from drivers where id=1;
Query OK, 1 row affected (0.00 sec)

mysql> select * from cars;
+----+--------------+-----------+
| id | plate_number | driver_id |
+----+--------------+-----------+
|  1 | bbb          |         1 | 
|  2 | ooo          |         1 | 
|  3 | aaa          |         2 | 
|  4 | lll          |         2 | 
+----+--------------+-----------+
4 rows in set (0.00 sec)

CREATE TABLE `drivers` (
  `id` INT PRIMARY KEY AUTO_INCREMENT,
  `name` VARCHAR(100)
) ENGINE=INNODB;


CREATE TABLE `cars` (
  `id` INT PRIMARY KEY AUTO_INCREMENT,
  `plate_number` VARCHAR(12),
  `driver_id` INT,
  FOREIGN KEY (`driver_id`) REFERENCES `drivers`(`id`) ON DELETE CASCADE
) ENGINE=INNODB;

INSERT INTO drivers(name) VALUES ('bob');
INSERT INTO drivers(name) VALUES ('alice');
INSERT INTO cars(plate_number, driver_id) VALUES ('bbb', 1);
INSERT INTO cars(plate_number, driver_id) VALUES ('ooo', 1);
INSERT INTO cars(plate_number, driver_id) VALUES ('aaa', 2);
INSERT INTO cars(plate_number, driver_id) VALUES ('lll', 2);

mysql> delete from drivers where id=1;
Query OK, 1 row affected (0.00 sec)

mysql> select * from cars;
+----+--------------+-----------+
| id | plate_number | driver_id |
+----+--------------+-----------+
|  3 | ppp          |         2 | 
|  4 | eee          |         2 | 
+----+--------------+-----------+
2 rows in set (0.00 sec)

I know very well one should read the manual before complaining but I also think software should complain if asked something which it is not capable of doing. -1 for MySQL.

Google Groups tracker using Yahoo Pipes

2009-01-17T00:00:00-08:00

I -and I suppose most of my developer mates- am subscribed to many Google Groups. When there is a topic I am interested in or a problem I posted or replied to it would be cool to get notified of changes to it. Instead of checking it five times a day to see if someone has commented on it which also slices up the big, continuous chunks of time we programmers need. Also, some groups are littered by spam topics so it would be nice to filter out all the things you are not particularly fascinated about and be left with the things you are.

Unfortunately, Google Groups does not offer us the possibility of following certain topics (e.g by sending you an email whenever someone added his comment, a la Lighthouse). But there is a solution although I'll admit the one I am describing below is not a particularly cunning or elegant one. If you felt the same pain and found a remedy, I am curious to know what it is, so please leave a comment.

So, as we all know, the Internet is just a series of tubes, so the idea to use Yahoo Pipes to cobble together something came quite naturally. Ladies and gentlement, I created the Googe Groups issue tracker. It is capable of tracking two Google groups. You can pass three strings for each one and it generates an RSS of the items whose title have any of the strings you provide.

I know it has many shortcomings (to say the least). What if you want to track issues for 3 groups or more? More than 3 issues per group? My puny tracker can't do that right now since its "legoed" together from Yahoo Pipes building blocks and so it's not programmable. You can, however, clone my pipe, expand it to handle more groups or more expressions, enter the groups you want to track and subscribe to the resulting RSS with your reader of choice.

It may still feel clumsy, since you have to regularly update your strings based on the issues you are interested in. I know a more general solution would be to hack together something that is more manageable and expandable which I might do soon. But it still feels so good from time to time to leave the serious, hard-thinking adult world and build Lego castles. So go ahead, don't be shy, build your own castle and let me know about it! :)

UPDATE: Thanks to Bob, I realized Google has the very option I missed and constructed the pipe for :) However, there can still be some valid scenarios where it can be of service. As per Jaime's comment I realized I did not really explain how to run the pipe, so let me do it through an example that is not too contrived:

Let's suppose you are a DataMapper expert and you want to help those newbies/impatient people who put 'help' in the title of their post. In that case, you would input http://groups.google.com/group/datamapper in the "Group1 URL" box and "help" in the "Group1 - Title 1" field. At the pipe output you'd only see those posts which have help in their title, then.

If you want to also see announcements and the convention would be to have [DM] in the title of those posts, you would then enter "[DM]" in the "Group1 - Title 2" field.

To construct a filter which only lists ruby-quiz related posts on http://groups.google.com/group/ruby-talk-google is left as an exercise to the reader :).

A ruby-style currency converter

2009-01-17T00:00:00-08:00

Though it is said that we live in a highly-globalized world, all countries still have their own proper currency (with one exception that I know of, the euro) so we still need to convert between them. If one is used to shop online (and one is) the need to get the price in the national currency occurs quite often. Going to a currency converter page is not much of a hassle but it still takes too much time and it seemed an overshoot to use a browser for this task. Inspired by Rails's date calculations extensions (where you could write 3.days.ago), I decided to create something similar and see how much flying to Barcelona or buying a PragProg book costs from the command line.


require "net/http"
require "open-uri"
require "hpricot"

# makes 1284.eur.to.usd types of queries possible
class CurrencyConverter
 
  Currencies = { :huf => "HUF", :eur => "EUR", :usd => "USD", :gbp => "GBP", :chf => "CHF" }
 
  # these methods "close" the quote.
  # when they are called, it means all data is ready
  # the quote can be sent.
  class_eval do
    Currencies.each_key do |curr|
      define_method curr do
        @to = curr
        calculate
      end
    end
  end
 
  def initialize(amount, from=nil, to=nil)
    @amount = amount
    @from = from
    @to = to
  end
 
  def send_request_for_quote
   from_as_param = @from.to_s.upcase
   to_as_param = @to.to_s.upcase
   url = "http://xurrency.com/#{[@amount, @from, @to].join('/')}/feed"
   doc = Hpricot(open(url).read)
   (doc/'dc:value').inner_html
  end
 
  def calculate
    send_request_for_quote
  end

  def to
    self
  end
 
end

class Fixnum 
  def method_missing(name)
    CurrencyConverter.new(self, name)   
  end
end

Thanks to ruby's open classes, the code is quite terse (you can also see and download the raw script from here). Now you can fire up irb and do all the conversions you want:

$ irb -r currency_converter.rb 
irb(main):001:0> 23.eur.to.huf
=> "6473.3500"
irb(main):002:0> 1.usd.to.eur
=> "0.7642"

Or do it through the ruby interpreter:

$ ruby -r rubygems -r currency_converter.rb -e "puts 1.eur.to.usd"
1.3085

I find it very pleasing to be able to write "10.eur.to.usd" since it is so close to our spoken, human language. One of ruby's numerous charms.

My friend, Peter sent a more general solution that uses html scraping with Scrubyt and the conversion capabilities of Google search:

require 'rubygems'
require 'cgi'
require 'scrubyt'

begin
google_converter = Scrubyt::Extractor.define do
  fetch "http://www.google.com/search?q=#{CGI::escape(ARGV[0])}+#{CGI::escape(ARGV[1])}+to+#{CGI::escape(ARGV[2])}"
  
  google_result "//td[@dir='ltr']" do
    final_result(/= (.+) /)
  end
end
  puts google_converter.to_hash[0][:final_result]
rescue
  puts "Sorry, even *google* can't translate that!"
end

Using this you can convert amounts between any two currencies (distances, weights, etc., everything that Google search can handle):

$ ruby conv.rb 30 EUR HUF

It may be swimming against the current but I like solutions that do not need the browser for simple problems like this one. I scratched my itch and hopefully scratched yours, too.

Record your bike trips with Gmap Pedometer

2009-01-05T00:00:00-08:00

Though I thought I would only post about technical issues here, I now make an exception. After all, (soft) rules are for breaking occasionally, aren't they?

So in case you don't know, there is a nice service out there to record your bike trips that I have recently discovered. It is a Google Maps application where you first search your point of departure then your point of arrival and Gmap Pedometer does the rest for you. Occasionally you have to lend it a helping hand, though, in case the automatic route generation does not work well. It usually does not if you take bicycle roads that does not run paralelly with the highway since the automatic route generation selects the "car route" by default (it seemed to me). You can set up your itinerary in no time and promptly see the distance you did and how much energy you burned during the process (and ultimately also the elevation of your trip).

I also grab the opportunity to tell you how bike tours are the perfect way of tourism for me. You can easily do 40-50kms per day in a moderate pace. In my opinion that's a perfect middle ground between being too slow and passing by magnificent landscapes and towns in a car. What's more, there is the thrill of riding your bike, feeling the air against your cheeks, the ability to stop anywhere and the ambiance of adventure that comes with the nomad lifestyle.

One thing I miss is a convenient method to store your trips. According to the site itself, Gmap Pedometer is "A hack that uses Google's mapping application to help record distances traveled and calories burned during a running or walking workout." so one should not expect a full-fletched, shiny application but a basic user registration/login method would be handy so I could quickly access my trips. To be able to review your trips, you must store the unique url that is generated for each one in a safe place.

To give you some example routes and also to store a pointer to some trips I would like to be able to access in the future I list the daily routes of two fairly recent bike routes:

The Netherlands (summer 2007)

Amsterdam - Den Haag Amsterdam - Enkhuizen Urk - Elburg Elburg - Appeldoorn (Beekbergen) Beekbergen - Arnhem (Oosterbeek)

Austria, going along the Danube (summer 2006)

Passau - Obernzell Obernzell - Feldkirchen Feldkirchen - Au an der Donau Au an der Donau - Willersbach Willersbach - Aggsbach Aggsbach - Krems

So what are you waiting for? Hop on your bike! :)

ps. Walking trips can also be recorded on the site and there is automatic route generation for walkers, too.

Ruby metaprogramming: Call counter - Take 2

2008-12-15T00:00:00-08:00

So last time I left you with the promise that I'd return with a solution so that the number of times a certain method was called is a class method which makes more sense than if it was an instance method. So here is the "improved version":

call_counter.rb:

module CallCounter
        
    def count_calls_to(method_name)
      original_method = instance_method(method_name)
            
      unless class_variable_defined?(:@@call_counter):
        class_variable_set(:@@call_counter, {})
      end
    
      call_counter = class_variable_get(:@@call_counter)
    
      define_method(method_name) do |*args|
        call_counter[method_name] ||= 0
        call_counter[method_name] += 1
        bound_original_method = original_method.bind(self)
        bound_original_method.call(*args)
      end

      metaclass = class << self; self; end
      metaclass.instance_eval do

        define_method(:calls_to) do |m|
          call_counter[m].nil? ? 0 : call_counter[m]
        end

        define_method(:reset_counters) do
          call_counter.each_key do |k|
            call_counter[k] = 0
          end
        end
    end
    
  end

end

What has changed is the introduction of a class variable that counts the calls on all watched methods and that the number of calls on each method is queried by calls_to(<method name>) instead of calls_to_<method_name>. A bit less magic.

call_foo.rb:

require "call_counter"

class CallFoo
    
  extend CallCounter

  def foo; "foo"; end
  def bar; "bar"; end

  count_calls_to :foo
  count_calls_to :bar

end

(a snippet of) call_counter_spec.rb:

require "call_foo"
require "spec"
    
describe CallFoo do
    
  before(:each) do
    @call_foo = CallFoo.new
    CallFoo.reset_counters
  end
        
  it "should be able to count several methods' calls" do
    4.times { @call_foo.foo }
    CallFoo.calls_to(:foo).should == 4
    7.times { @call_foo.bar }
    CallFoo.calls_to(:bar).should == 7
  end
    
end

I'm still not 100% content with this solution, the programming interface is nice now but it would be cool to get rid of the class variable somehow, possibly replacing it with closures. If you know how to achieve it, please leave a comment.

ps. You can also get the whole code in nice colored format or the raw text version.

Exploring Ruby metaprogramming: call counter

2008-12-06T00:00:00-08:00

A few days ago I purchased a screencast by Dave Thomas on Ruby metaprogramming. (I do not receive any affiliation fees :)). The part I bought presents a problem and describes nine different ways of solving it in ascending order of beauty and code clarity.

I was stunned by its beauty so I came up with another -though similar- problem and put together a simple solution for it. I present it for the Rubyists to silently smile in the knowledge of its elegance and power and for non-Ruby programmers to be -hopefully :)- amazed by it.

The task is to count the calls to a certain method of all instances of a class.

call_counter.rb:

module CallCounter
  def count_calls_to(method_name)
    original_method = instance_method(method_name)
    
    call_counter = 0
    define_method(method_name) do |*args|
        call_counter += 1
        bound_original_method = original_method.bind(self)
        bound_original_method.call(*args)
    end

    define_method "calls_to_#{method_name}" do
        call_counter
    end      
  end
end

call_foo.rb:

require "call_counter"

class CallFoo
    
    extend CallCounter

    def foo; end
    count_calls_to :foo

end

After calling "count_calls_to :foo" in the CallFoo class definition, calls to the "foo" method of CallFoo instances will be counted. A "calls_to_foo" method is available to get this count.

I first created an UnboundMethod with "instance_method" and then used the bind method to attach it to an instance of ClassFoo. All this is to prevent aliasing method names, not because it is necessarily evil but because I agree with Dave Thomas about "bind" being a nicer solution. The define_method acts as a closure and saves its context so there is no need to use an instance variable for call_counter.

You can use the counter like this:

irb(main):003:0> cf = CallFoo.new
=> #<CallFoo:0x608100>
irb(main):004:0> cf.calls_to_foo
=> 0
irb(main):005:0> 4.times { cf.foo }
=> 4
irb(main):006:0> cf.calls_to_foo
=> 4

Once again, what I love about Ruby is that in ~ 20 lines we have laid the base of a benchmarking tool (adding the possibility of measuring time spent in the method would not be hard). Also, the original class is not sullied by the call counting code intrinsic details. That functionality is stashed in a module, eager to be reused again.

You may note there is something not quite nice about this. The method calls are counted per class, which makes sense since we usually want to know how many times the method in question was called in all instances, not per instance. However, the calls_to_foo is called on the instance which is confusing. It should be called on the class object, like this:

  4.times { cf.foo }
  CallFoo.calls_to_foo
  => 4

I may get back to this later.

A Git guide that emboldens

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

Git is extremely powerful. I knew that much and that I would really like to thoroughly master it because it is so cool. However, it is quite sophisticated (not to mention that some commands, like checkout and revert designate totally different actions than in Subversion where I am coming from) and like with most things one learns by doing.

One key to doing is the ability to play around with a git repository. The possibility to have an account on github.com and to contribute to a myriad of open source projects there removed that obstacle. The other ingredient to be a master chef is a good guide in the subject. One needs some initial self-confidence to know what he is doing lest he screws up his own work. (Note: that is very hard with git but I remember the panic when I did "git checkout <earlier commit>" and I did not find my earlier HEAD with "git log" )

We may be different but I have not read a really insightful guide albeit I have gone through a dozen of them. Some are too vague or concentrate on one specific task (e.g how to create a repo on github and push to it) and some present too many options and go into details that intimidate the novice. (like the official man pages). Ladies and gentlemen, I have found it. It's the Git User's Manual and it strikes the perfect balance between verbosity and shallowness. It gives examples which nicely clarify the concepts. It won't make you an expert right away, of course, but it provides you with the insight and initial courage to embark on the journey.

Installing rmagick

2008-11-28T00:00:00-08:00

I needed to install rmagick for a Rails project. I had some amount of trouble along the way but finally succeeded so I am sharing my experience in case you bump into the same problems.

I first installed the binary OS-X distribution of imagemagick (no problems here) and then attempted to install rmagick, the ruby interface to the ImageMagick libraries:

sudo gem install rmagick

However, I received the following unpleasant error:

Can't install RMagick 2.7.2. Can't find MagickCore.h.

I checked that the header file is there (on the path the install script was looking for it), and decided not to go the hard way. After some googling I found there is a rmagick-osx-installer which downloads, compiles and installs ImageMagick and rmagick. Just what I needed.

However, the script failed to accomplish its mission, it hung when installing rmagick. Taking a peak in its log I saw several other errors so I had to look for another way. And that way was compiling the ImageMagick library myself. So I downloaded the source, made the configuration-make-make install cycle and fortunately everything went smoothly. The good news is I could install rmagick without any problem after that:

balint$ sudo gem install rmagick
Building native extensions.  This could take a while...
Successfully installed rmagick-2.7.2
1 gem installed

Refuting Rails myths

2008-11-17T00:00:00-08:00

David Heinemeier Hansson, the creator of Rails is doing an outstanding series of blog posts on his blog to derail (pun intended) some common myths that claim Rails does not do this or that and that hinders (or rather, slows down) its widespread acceptance.

I am sure David holds his best for last and will refute the infamous "Rails does not scale" in the final episode of the series.

ConferenciaRails 2008: enhorabuena!

2008-11-17T00:00:00-08:00

I have just returned from Madrid where the Spanish Rails Conference, Conferencia Rails was held. I liked it quite a lot, there were several interesting talks most of which made me want to learn all of that and very fast (one thing conferences do to me is to boost that healthy feeling of wanting to always learn and discover new things). So I would like to add my e-voice to the web noise: congratulations and thank you to the organizers and presenters!

Blackbird - simple log messages in Javascript

2008-10-26T00:00:00-07:00

Using alert() for debugging javascript is a pain. Firebug makes it a lot easier and enables several debug facilities (e.g inserting breakpoints, stepping into methods, adding variable watches) but a painless logging mechanism would still be very useful to supplement Firebug's features.

Enter Blackbird, a simple javascript logging tool which has a very clean, nice API and a cool console. It's really worth to check out, you can download the Blackbird files here and my demo here to try out its features. (If you use my demo, you have to save the Blackbird files in a directory named blackbirdjs that is situated in the same directory as the demo page)

Blackbird's motto says it all: say "hello" to Blackbird and "goodbye" to alert().

PostgreSQL pg_hba.conf authentication

2008-10-22T00:00:00-07:00

I recently spent some time debugging while I can't connect to a local postgreSQL database. I wanted the nice_db database to be accessible to all local users (not real names) without any authentication. The "trust" authentication method was what I needed for this scenario, I was sure of this much. So I set up an authentication record in the configuration file below the one that existed by default:

# TYPE  DATABASE    USER    CIDR-ADDRESS    METHOD
local    all          all                   ident sameuser
local    nice_db      all                   trust

But this gave me the following error and denied access:

psql: FATAL:� Ident authentication failed for user "balint"

I tried several things making the second record more allowing each time (in fact, what you see above is the final, most liberal version) to no avail. I then swapped the order of the two records and finally was granted access.

Of course, I should have been wiser and apply the grand old RTFM principle. The PostgreSQL documentation states in very clear terms how each line in the pg_hba.conf is accessed:

The first record with a matching connection type, client address, requested database, and user name is used to perform authentication. There is no "fall-through" or "backup": if one record is chosen and the authentication fails, subsequent records are not considered. If no record matches, access is denied.

For my particular case, the "local all all ident sameuser" record blocked access to all databases but to those whose name matched that of the operating system's user (that's what the ident sameuser does) since that matches all user and database names.

Beyond the mechanics of PostgreSQL authentication (put the authentication records that match more users/databases below the ones that are more specific), I have learned something which is more precious and that I can put into good use in the future: RTFM!

javascript method chain

2008-10-09T00:00:00-07:00

John Resig has an extraordinary advanced javascript tutorial on his blog that he presented on a web conference. It is definitely worth a walk-through since it expands one's javascript horizon unless one has not written a javascript framework himself.

I played around with several of his slides learning a lot. My favorite was probably the last slide which explains how method overloading works using the fact that methodname.length in javascript gives back the number of expected arguments of that function.

function addMethod(object, name, fn){ 
  // Save a reference to the old method 
  var old = object[ name ];
 
  // Overwrite the method with our new one 
  object[ name ] = function(){ 
    // Check the number of incoming arguments, 
    // compared to our overloaded function 
    if ( fn.length == arguments.length ) 
      // If there was a match, run the function 
      return fn.apply( this, arguments ); 
 
    // Otherwise, fallback to the old method 
    else if ( typeof old === "function" ) 
      return old.apply( this, arguments ); 
  }; 
} 
 
function Ninjas(){ 
  var ninjas = [ "Dean Edwards", "Sam Stephenson", "Alex Russell" ]; 
  addMethod(this, "find", function(){ 
    return ninjas; 
  }); 
  addMethod(this, "find", function(name){ 
    var ret = []; 
    for ( var i = 0; i < ninjas.length; i++ ) 
      if ( ninjas[i].indexOf(name) == 0 ) 
        ret.push( ninjas[i] ); 
    return ret; 
  }); 
  addMethod(this, "find", function(first, last){ 
    var ret = []; 
    for ( var i = 0; i < ninjas.length; i++ ) 
      if ( ninjas[i] == (first + " " + last) ) 
        ret.push( ninjas[i] ); 
    return ret; 
  }); 
} 
 
var ninjas = new Ninjas(); 
assert( ninjas.find().length == 3, "Finds all ninjas" ); 
assert( ninjas.find("Sam").length == 1, "Finds ninjas by first name" ); 
assert( ninjas.find("Dean", "Edwards").length == 1, "Finds ninjas by first and last name" ); 
assert( ninjas.find("Alex", "X", "Russell") == null, "Does nothing" );

It took me some time to figure out how exactly the method calls are routed but it was an interesting process nevertheless. I guess the one tricky part to interpret is the following bit:

if ( fn.length == arguments.length ) 
  // If there was a match, run the function 
  return fn.apply( this, arguments ); 
 
  // Otherwise, fallback to the old method 
  else if ( typeof old === "function" ) 
    return old.apply( this, arguments ); 
  };

This makes a method chain and allows for method overloading. With the three addMethod calls in the above example a chained method is built up.

After the call to addMethod with no arguments (the first one), the find method of the Ninjas "class" will return all ninjas if called with no arguments and do nothing if called with any number of arguments. After the call to addMethod with one single name argument the find method will return the ninjas whose first name matches the passed argument if there is only one argument, return all ninjas if it has been called with no arguments and do nothing otherwise.

I could go on but the pattern is probably clear now. At each call of the find method, the lastly added method is matched for the number of arguments (so in the above example, it will match if the caller passed two arguments) and the method called if the match is successful. Otherwise, it will try to match the number of arguments with the method that was added before the last one, and so on.

I am elaborating this in so much detail because

it was such a "Eureka!" moment for me when I got it.
it is an incredibly ingenious way to flex the possibilites of javascript and introduce an OOP concept into an originally non-OOP language.

I think John Resig made javascript lovable again which is why he deserves my total gratitude.

My first DSL in Ruby

2008-09-21T00:00:00-07:00

I read a few posts about how good fit Ruby is for building DSLs, Domain Specific Languages. Ever the curious I have been waiting for the opportunity to build a very simple one for a particular problem.

Well, I did not have to wait very long (when you have a hammer everything looks like a nail). I needed a quick method which generates nice html graphs for my post about browser javascript engine benchmarking. After spending a few minutes searching for a free tool (I did not want anything fluffy, just something very basic) I hit the nail in the head with my hammer. Only the nail was the generated HTML charts for my post and the hammer, (my desire to build) a DSL in Ruby.

I would like to say it was difficult but in fact it was a piece of cake with Ruby (and armed with the knowledge of previous DSL builders). The solution is composed of the following three parts:

The DSL file which defines the charts
The interpreter which understands the definitions in the DSL file
The "controller" which just passes the data contained in the DSL file to the interpreter

So let's see each part separately:

browser_js_benchmarks.dsl (the DSL)

chart "Score" do |c|
    c.add "Safari 3.1.2" => 164
    c.add "Firefox 3.0.1" => 156
    c.add "Shiretoko" => 145
    c.add "Google Chrome" => 1589
end

chart.rb (the interpreter)

require "math_aux"

class ChartDSL
    
    Template = %(%%ITEMS%%%%CAPTION%%)
    Background_colors = %w(red blue green yellow grey)
    
    attr_reader :values
    def initialize
        @charts = Array.new
        @values = Hash.new
    end
    
    def chart(name)     
        @name = name
        yield self
        @charts.push(make_html)
    end
    
    def add(name_and_value)
        @values ||= Hash.new
        @values.merge!(name_and_value)
    end
    
    def load(filename)
        # c = new
        instance_eval(File.read(filename), filename)
        write_output
    end

    def make_html
        sorted_pairs = @values.sort_by { |v| - v[1] }
        vals = sorted_pairs.map { |p| p[1] }
        norm_values = MathAux::normalize(vals, 100.0)
        html = Array.new
        sorted_pairs.each_with_index do |pair, i|
            name, value = pair
            html.push(%Q(#{name} #{value}))
        end
        filled_chart = ChartDSL::Template.sub("%%CAPTION%%", @name)     
        filled_chart.sub("%%ITEMS%%", html.join)
    end
    
    def write_output
        File.open("generated_charts.html", "w") do |f|
            f.write(@charts)
        end
    end
end

chart_loader.rb (the controller)

require "chart"
class ChartLoader
    def self.load_chart(dsl_filename)
        c = ChartDSL.new
        c.load(dsl_filename)
    end
end

if __FILE__ == $0
    ChartLoader.load_chart(ARGV[0])
end

For the sake of completeness here is math_aux.rb:

module MathAux
    def self.normalize(numbers, to=1.0)
        norm_rat = to / numbers.max
        numbers.map { |n| n * norm_rat }
    end
end

To generate the charts, one only has to run "the interpreter" with a dsl file as the first parameter:

ruby chart_loader.rb browser_js_benchmarks.dsl

The output is called generated_charts.html and contains the following:


Score
 
  Google Chrome
   
  1589
 
 
  Safari 3.1.2
     164
 
  Firefox 3.0.1
    156


 Shiretoko
   145

Note that in ~30-40 code lines we have a "language interpreter", one that understands the chart DSL and spits out some HTML code that represents the charts. Of course there is plenty of room for improvement, like having the same color denote the same actor between charts (Firefox 3.0.1 should always be the blue bar, for example, unlike in my post), using a better solution for the template strings, adding the possibility of pie charts (although "standard" HTML is not very flexible on different chart forms, one would probably have to use a <canvas> ), and so on.

The essential thing is that it works and it does what the particular situation demanded. It took me a couple of interrupted hours plus the time to read through two related posts which is not that much given that I now have a "tool" (once again, I feel a bit conceited to call it that) which I can use for my future posts whenever the need arises. A custom hammer for my custom nail.

(If you care, feel free to download, use and modify the source code located here)

V8 javascript engine benchmarks

2008-09-17T00:00:00-07:00

A few weeks back when I read about Chrome I became interested in V8, a javascript engine that Google integrated in their browser and that they claimed to be very fast due to the following reasons:

Hidden class transitions that enable dynamic optimizations since objects will use the same (hidden) class
generating machine code instead of interpreting the source code each time
incremental garbage collection which reduces the time needed for the cleanup to milliseconds and eliminates "second long pauses"

All that sounded very promising but as an engineer by profession it left me with a desire to find out how much faster all these features made V8 (and any browser that might use it). Even more so since I love running benchmarks and compare numbers. Well, maybe Google sensed that since they provided all the necessary tools to run these tests on the V8 benchmark page and to run them very easily.

There are 5 different algorithms in the testing suite exercising different qualities of the javascript engine. To be fair I closed all other tabs in browsers during the testing attempting to minimize operations that can have an effect on test performance. Also, the V8 tests were run from the command line so that might skew the results a bit towards V8. Anyyway, here are the results (numbers mean execution time so smaller is better):

Richards
Google Chrome		2072
Firefox 3.0.1		152
Shiretoko		116
Safari 3.1.2		91

DeltaBlue
Google Chrome		1753
Firefox 3.0.1		171
Safari 3.1.2		127
Shiretoko		123

Crypto
Google Chrome		1415
Firefox 3.0.1		150
Shiretoko		150
Safari 3.1.2		135

RayTrace
Google Chrome		1021
Safari 3.1.2		232
Firefox 3.0.1		126
Shiretoko		114

EarleyBoyer
Google Chrome		1933
Safari 3.1.2		328
Shiretoko		259
Firefox 3.0.1		188

Score
Google Chrome		1589
Safari 3.1.2		164
Firefox 3.0.1		156
Shiretoko		145

The superiority of V8 stunned me so much even to push me to ask whether all this is possible. Googe Chrome that uses V8 is on average (see Score) 10 times faster than all the other browsers (that pretty much flock together). I expected to find the speed of Firefox 3.1 (codename Shiretoko) close to that of Chrome but to my surprise it does not even surpass that of the other browsers. That made me a bit disappointed since I am a big Firefox fan.

Can it be that these benchmarks are somehow tailored to show V8's dominance? (like some political polls are skewed to give the "correct" answer). That this is not such a far-fetched idea is supported by Mozilla's announcement that TraceMonkey, Firefox's javascript engine will be 16-28% faster than V8. And they have their own benchmarking solution, SunSpider to prove their point.

So the life of javascript engine developers has got a lot harder. Not only they have to implement a fast engine but also a benchmarking system that shows there is nothing as fast as theirs!

Navigator for the Google Chrome comicbook

2008-09-03T00:00:00-07:00

The first beta version (for now only for Windows) of Google's browser is out, but I don't think Google needs the marketing power of my post so that's not what I want to talk about. The browser is introduced by a ingenious comics of 39 pages. However, the navigator is too simple, in my opinion in that you cannot skip a page so if you read until say page 19 and you have to start over (e.g you closed the browser), you have to click on the "Next" link 18 times. There is no unique URL for each page, the whole navigation is done with a javascript snippet changing the image (the cartoon strip) when the user clicks "Prev" or "Next".

So I took a peep at the source of the page and reverse-engineered the navigation which is simply a javascript call to goPage('next') when the user clicks the Next link. So now I can simply write

javascript:for (var i=0; i < 10; i++) goPage('next');

to the location bar to skip 10 pages ahead and do the same with 'prev' to rewind 10 pages.

I know "reverse-engineering" is way too conceited a term for this but this kind of hacking tickles my brain in a very joyful way and feels a bit like outsmarting Google. And that's not bad at all.

UPDATE: I now realize the comics's navigation has been redesigned so my above fix became obsolete. At least I cherish the knowledge my hack addressed a real UI problem (and did that faster than Google :) ).

Now that's what I call Web2.0: Ubiquity

2008-08-29T00:00:00-07:00

I've stumbled upon a great Firefox plugin, Ubiquity. It basically accesses several web services (GoogleMaps, Gmail, Flickr, etc.) via its own panel and with its own commands so that common online tasks (e.g looking up something on Wikipedia you have just found on a page) become amazingly simple. I was really stunned by how much this plugin is capable of doing after watching the briefing video and going through the tutorial. And that does not stop there: power users can add their own commands to extend the already vast capabilities of the plugin. It's been a long time I've been so excited about a "web 2.0" tool.

Here is the blog post about Ubiquity on Aza Raskin's blog who is the main developer of the plugin.

Note: If you use a Mac, you'll need Growl for Ubiquity to display its command panel.

Can less work be more?

2008-07-17T00:00:00-07:00

I saw the keynote speech David Heinemeier Hansson gave at this year's Railsconf in Portland and I liked it a lot. I really like the idea of following the pattern of "Less software is more" to the work we do each day. In his speech he says developers should spend one day a week discovering a subject of interest, writing code for a pet project, contributing to an open source project, etc. Basically anything but doing the work they do on the other four days of the week. This "day-off" raises the developer's productivity so it is a net gain for the main work he is involved with, too.

I tend to agree. However, in this post I want to elaborate rather what 'be more' means in both the 'less software is more' and the 'less work is more' phrases. Less software means less lines of code to achieve the same tasks. Less work means less time spent working producing code to achieve the same tasks. There are two underlying concepts here that make this possible: abstraction and productivity. More precisely: the ideas in your (hacker) head and the tools that allow you to implement these ideas in abstract, high-level terms and thus raise your productivity.

When you write a program, there are basically two phases of producing code that solves a problem: first, you think about how to solve it and second, you convert the ideas into code. There is always a gap between the ideas and the code you write and that the computer comprehends. The more high-level the language is, the smaller the gap that needs to be bridged. But there is a backward effect, too. Usually when you are in the first phase you already think in terms of the second. The expressive tools the language provides have a strong effect on how you think of the problem (generally you know what language your solution will be implemented in). And that is bad because it dumbs down your thinking before you get to the point where you should consider the possibilities of the language.

I tend to think less of the language specifics in the first phase if I know the language provides all the high-level tools and provides them neatly. "For" loops skews your thinking more than -all kinds of- iterators. If I know functions are first-class objects and metaprogramming is available I worry less about how (or whether!) my abstract solution, only existing on the plane of ideas can be converted to functioning code.

So, back to where I started, your choice of the language counts and it counts a lot. It can help you be more productive in several ways, not just the fewer-lines-of-code-to-do-the-same-thing way but also the minimizing-the-skewing-of-your-thinking way. However, a high-level language is no guarantee to achieve that. One can churn out C-like code in Ruby, it is just easier to realize you are not using the full arsenal. And that's where it really kicks in: if you know you can basically do anything painlessly you will dare to think big, your ideas can get off the ground. Consequently they will be abstract enough for you to be more productive.

So armed with daringly abstract ideas and tools that make it possible to put them into code, one sets out to conquer the world. The limit to the amount of code generated is the number of hours one can spend each day programming. After about ~8 hours of work is it worth to put in some more time to produce more code? Probably not. Our thinking breaks down pretty fast after that. I have experienced on several occasions that I could do in 10 minutes the next morning what I could not do in 2 hours the evening before. This is not about dropping the keyboard when the clock strikes 5pm, of course. It is about planning for measurable progress without too much overtime.

I think David is right when asserting that replenishing your mind so it can come up with constructive ideas is equally important. I am sure there are numerous ways to attain that. Some of them are constructive activities in themselves (David's example was playing the banjo), some may just give you peace (e.g friends, family) and some may simply drift your thoughts away from the very problem you are working on (e.g playing soccer) and help you that way.

So what do you think about all that? Can low-level languages still have advantages over high-level ones in certain situations? Do you think the language your are programming in can have an effect on your problem-solving thoughts? What activities switch you off in the most "productive" way? What other factors have an effect on your work? (of course your working environment is very relevant). Are naps worth it? When would the official Railsconf'08 videos be online? :)

First Mexperiences

2008-05-27T00:00:00-07:00

I recently wrote about me getting a Mac, the reasons I made the switch and how I really like it. I would now like to add nuances to this overall picture. What is really cool? What is hard to get used to? Which are the things I could not find how to achieve on the Mac?

Non-keyboard input

I think I am one of the few who prefers the trackball (Thinkpad-style) to trackpads. For me, trackpads are clumsy, it is hard to position the cursor correctly, they make an incomfortable sound and I often click inadvertently by pushing too hard (but not hard at all). So I had thought I'd get a mouse but then I found out the usb ports are located on the left hand side of the Macbook which does not seem to logical unless Apple specifically targeted left-handed people. Or does everyone already have cordless mice?

Anyway, I gave the trackpad a try and I was thoroughly satisfied. The trademark two-finger scrolling works miracle, clicking is silent and the trackpad is wide enough to be able to lay two-fingers on the pad and click with my thumb which serves as a right-click. Absolutely phenomenal. My plans to acquire a cordless mouse have been postponed. (Even more so since I learned from a colleague that to really get the best out of the mouse you need to purchase a driver. I can imagine paying for software, but for a mouse driver? that seems harsh.)

Managing windows and menus

Having said all about non-keyboard input I always try to minimize the time I have to lift my hands from the keyboard in all applications. Switching between applications is easy with cmd+tab and I also learned the cmd+` and cmd+~ which switches between windows of the same application and is very useful. Closing an application with cmd+q and a tab/window with cmd+w also come in handy and was easy to learn. However, one thing which I miss badly is a key combination to just go to the menu and browse there (e.g alt+f1 in gnome). I mean there are several combinations to activate certain menu items but if I do not want to learn a few dozens of them per application it seems a good idea to me to have just one and then be able to access everything. Or maybe there is, waiting for me to discover it.

Command line boosters

Another feature I adore in the terminal is to be able to quickly navigate. Go to the start, to the end, skip a word forwards, backwards, delete a word, etc. One extra advantage of my favorite text editor, emacs, is that its combinations coincide with those used on the command line, which is fantastic. After a while, I learned that they can all be invoked in Mac terminals, too, it is just that they seem less logical too me. For example , Esc-D is to delete from the cursor to the end of the word, why is Ctrl-W Delete the word to the left of the cursor? (found here). Also, Esc is too far away to reach comfortably. I know iTerm can be programmed to respond to any key combination, so I might do some tinkering here to have a more consistent interface.

Installing software

Getting applications installed on your computer is quite easy with the disk image installers or one can always compile from source the advantages of which are described in this excellent article. I have to tell that the provided applications are really top notch like iTunes or iPhoto, and I haven't even had the time to try all of them (iMovie, Garage Band, etc.). One caveat is that some applications, like iPhoto treats your data as one big library file so you need to export particular files if you need them outside of the application (how do you upload individual photos to a photo company's site to have them developed? how do you upload an image to a photo-sharing website? you'll need plugins or you have to export them thus duplicating the photos and wasting space). This surely suits ordinary users but advanced, tech-savvy users don't like this kind of obfuscation, or at least I don't.

A big pain for me is the presence of spaces in directory names. It may be an old habit to automatically evade them but it looks amateurish to me. Which Mac (and OS/X) is certainly not. It is a great machine (and operating system) to have.

Post scriptum. I am most interested to see what Fernando has to say about his first steps with his Mac.

Update I realized the iPhoto Library file does contain the actual photos although in a shrunk version. You can't see this in the Finder, you have to use the command line (which is ok since that can be considered as a habit that distinguishes a normal user from a power user). To be able to burn the photos to a DVD or upload them somewhere, you still have to export them and thus have your photos duplicated (even if only for the time of creating the CD/uploading the photos).

Confession of a conversion

2008-05-22T00:00:00-07:00

My company laptop has gotten old and weary. So old that I could not even find a replacement battery and some memory for it. I could, but for half a price of a shiny new notebook that is three times stronger. I liked my old laptop, but not that much. So I went looking for a new one. I was hesitating between a Thinkpad and an ASUS since I was pretty content with both of them but the faint voice was already whispering into my ear: "get a Mac, get a Mac".

I'll admit the sysadmin side of things is not my favorite part of working with a computer. I have nothing against modifying configuration files, installing software from the command line and the like but I do feel like I am wasting my time when trying to get Skype voice to work for several hours to no avail, make my laptop "soft-hibernate" when I close the lid (I got that one, finally) or set up the wifi hotspot selector icon. I know it is just a matter of time and perseverance and I like the idea that you can get it to work if you finally understand what needs to be tweaked and how. (In fact, most of the time you don't. You just find the answer by searching on Google, copy-paste something you don't understand and eureka, it works.). It is just that my priorities lie elsewhere. It has been said a million times but it is still true: time is too precious to spend on anything but the most important things. For me, these are writing code, learning software, discovering new tools and technologies.

There was something more in favor of a Mac: its design. I don't primarily mean the physical design of the laptop though in my opinion it is the best looking one there is but how everything works so ingeniously and smoothly. Everything is pre-installed so I basically only had to customize a few things like creating a user (it took me a while to realize who the guy on the default avatar picture was since I was not moving too much), setting the time zone and the default keyboard layout, etc. And the fonts. Yes, the fonts above all. I remember how refreshing it was when I switched to a Gnome desktop from Windows XP several years ago. I felt the same but even stronger when I opened Firefox the first time on my new Mac. My heart is filled with joy using iTerm with the Monaco font. I know font types and the look of fonts should probably be a detail for stone-hearted programmers but on the other hand beauty in details is so important. I spent some time thinking whether using nicer terminal fonts makes me a happier developer and it certainly does. I could do without the whizzing windows, sliding workspaces and flamboyant icons but I can not imagine using anything with less beautiful fonts. In three weeks I have become so fond of my precious little fonts I have a hard time imagining abandoning them.

But it is just me. What about you? What made you change to a Mac? What do you fancy most about it? Or if you are not a Mac owner, what do you like most about your Linux/Windows/etc. machine?

Agile help with Rails

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

I have recently taken the habit of checking on Rails forum from time to time whether there are unanswered questions I can help with. The best way to see a problem in its context is to recreate it and I was amazed by how easy it is to set up a rails site and debug e.g a routing problem.


> rails railsforum_help_routing
> createdb railsforum_help_routing_development
(edit database.yml to set user and possibly database type)
> script/generate model Trip
> script/generate controller Trip
(edit routes.rb, in this case)

Naturally the fact that all this takes about 5 minutes greatly leverages lending a hand to a fellow developer. Now that's what I call agile!

Code syntax highlighting

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

I realized this would be a key feature of any blog that aims to include code snippets in posts right after my friend, Bronson, told me so. With Wordpress, it seems, the problem is not that there are no tools for a certain task but that there are too many. Anyway, I finally found this one to perfectly suit my needs. It supports a plethora of programming/markup languages and the only thing you should add to your code blocks, is a lang attribute to the <pre> like so:

       (ruby code comes here)

My code in my earlier post looks a lot better, doesn't it?

Quick adaptor - my role model

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

I returned two weeks ago from the fantastic Euruko 2008 conference in Prague dazzled by the outstanding presentations and the power of Ruby. It is hard to pick a favorite but I especially liked David Black's "Per-Object Behavior in Ruby" (slides hopefully coming up) mainly because I am a sucker for metaprogramming and the true object-orientedness of Ruby in all its glory.

One fundamental concept was the singleton class which I think I've finally understood from this session. His example was the OpenStruct class whose instances learn to respond to all messages sent to them (this is Smalltalk/Ruby parlance, we could also say they learn to handle method calls) instead of throwing a NoMethodError. So I thought a great way to gain an insight of how this works is to actually code that up myself. Here is what I got:

require 'test/unit'
class QuickAdaptor
  def method_missing(method_id, *args)
    method_name = method_id.to_s
    if method_name =~ /=$/
      attr = method_name.to_s.chop
      self.class.class_eval do
        define_method method_id do |x|
          instance_variable_set("@#{attr}", x)
        end
        method_name.chop!
        define_method method_name.to_sym do
          instance_variable_get "@#{attr}"
        end
      end
      instance_variable_set("@#{attr}", args[0])
    end
  end

end

class QuickSingletonAdaptor
  # does the same as QuickAdaptor
  # but only defines methods for singleton
  # class of object, so it is not the class
  # that "learns", but the singleton class
  def method_missing(method_id, *args)
    method_name = method_id.to_s
    if method_name =~ /=$/
      attr = method_name.to_s.chop
      singleton_class = class << self ; self; end
      singleton_class.instance_eval do
        define_method method_id do |x|
          instance_variable_set("@#{attr}", x)
        end
        method_name.chop!
        define_method method_name.to_sym do
          instance_variable_get "@#{attr}"
        end
      end
      instance_variable_set("@#{attr}", args[0])
    end
  end

end

if __FILE__ == $0
  class ModuleTester < Test::Unit::TestCase

    def test_quick_adaptor_creates_methods
      qa = QuickAdaptor.new
      qa.age = 18
      assert_equal(18, qa.age)
      qa.age = 24
      assert_equal(24, qa.age)
      assert_equal(nil, qa.name)
      qa.name = 'joe'
      assert_equal('joe', qa.name)
      assert(!qa.respond_to(:nam))
    end

    def test_quick_adaptor_creates_instance_methods
      qa1 = QuickAdaptor.new
      qa1.age = 18
      qa2 = QuickAdaptor.new
      assert(qa2.respond_to?(:age=))
      assert(qa2.respond_to?(:age))
      assert_equal(nil, qa2.age)
    end

    def test_quick_singleton_adaptor_creates_singleton_methods
      qa1 = QuickSingletonAdaptor.new
      qa1.age = 18
      qa2 = QuickSingletonAdaptor.new
      # qa2 at this point should not know anything!
      assert(!qa2.respond_to?(:age=))
      assert(!qa2.respond_to?(:age))
    end

  end
end

As a test enthusiastic I embedded the tests in the same file which also has the advantage of giving a documentation of what the code achieves.

You can see that the real difference between the QuickAdaptor and QuickSingletonAdaptor classes lies in the following lines:

class QuickAdaptor
  ...
  self.class.class_eval do
    define_method method_id do |x|
      ...
    end
  end
end

class QuickSingletonAdaptor
  ...
  singleton_class = class << self ; self; end
  singleton_class.instance_eval do
    define_method method_id do |x|
      ...
    end
  end
end

You can see from the tests that the QuickAdaptor shares the knowledge it gained with its peers (other QuickAdaptor instances), whereas QuickSingletonAdaptor is an egoist, it keeps it to itself! That's why I agree with David Black that the best way to call the class that only one instance can access is singleton class because this has more expressive power than other terms (e.g metaclass, eigenclass, etc.)

My goal is to act like the QuickAdaptor, to suck in all ruby knowledge and learn as fast as QuickAdaptor does while having fun at the same time!

ps. I have also taken a look at how Matz's OpenStruct class accomplishes the same (well, much more :) ). It uses a table of fields where each new "member method" is defined. Nice.