Aside from some minor bug fixes, nuntium now implements an exponential backoff strategy when a message delivery fails. Previously, it worked like this:

1. A message failed to be delivered.
2. If the cause was the message itself (for example it contains invalid data), it was discarded.
3. If the cause was an authentication problem, for example an SMTP server's password changed, the channel responsible for delivering the message was disabled and an alert was sent to the administrator.
4. Otherwise, the cause was a temporary one, maybe a connection timeout. In that case, delivery through that channel was suspended for five minutes with an alert being sent to the administrator.

In this last point, sometimes the cause was in fact an invalid message for which the other side expecting to get the message wasn't correctly prepared to handle. This caused all subsequent valid messages to be suspended for five minutes.

We changed this behavior to just suspend this message for some time (using an exponential backoff strategy) but allowing next messages to be sent. The message is marked as "delayed" an you can see it in the UI. We think this is a much more resilient solution.

The other big thing is that we changed the library we used to receive and send XMPP messages. Previously we used xmpp4r, which works quite well but sometimes it would raise unexpected exceptions which we couldn't understand. Also, it wasn't based on event machine. We switched to the excelent blather library and so far it didn't let us down.

What's next? Having implemented delayed messages on failure cases we are only a small step away from implementing delayed messages just for the sake of it. Imagine sending a message to nuntium and telling it to send it on a specific date. With this you could implement things as simple as birthday reminders to pregnancy checks reminders or messages sent today or tomorrow afternoon of a given time zone.

I'm not much of a cook. I checked some online recipes and finally settled on a Chocotorta, a somewhat famous pie here in Argentina that you can prepare with chocolate cookies, coffee, dulce de leche and white cheese. I wanted it to be special for this last day so I thought about decorating it with powder chocolate that would read either "Friday" or "Manas". But those words were too long and they wouldn't fit. So the closest thing that meant happiness to me but was shorter was "Ruby".

Here's a picture of it. The "R" is not very clear...

The rubycake

So here's the recipe I used:

Ingredients:

• 3 packs of Chocolinas
• 500 grams of dulce de leche
• 300 grams of white cheese
• 1 cup of hot chocolate milk (can also be coffee)
• Chocolate powder
• 1 pionono (can be replaced with chocolinas)
• 1 peach

Mix the dulce the leche and the white cheese. I also added some chocolate powder to it. We'll call this the stuffing.

Wet some chocolinas in the hot chocolate milk and with them form a rectangle, like a platform. Then put some of the stuffing on it. Then put either another platform of chocolinas or pionono. Continue until your formed three or four platforms. On top of the final platform put more sutffing. Sprinkle the chocolate powder to form the word "Ruby". Chop the peach in tiny sliced and put them around. Don't forget to put one slice in the "R"'s hole and two on the "B"'s circle. Put on the fridge. You are done!

I also moved the code from Google Code to github, so i can have all my projects under a single tree, and to start using git more frequently.

Here are the new URLs:

http://github.com/asterite/rgviz
http://github.com/asterite/rgviz-rails

For writing the scenarios she could learn the steps from other features or just browse the step definition files, but I felt it was a little uncomfortable, specially having to deal with regular expressions. So we thought about writing a script that lists all step definitions in a project: then she could browse the list, copy what she needed and fill in the parameters.

I went a step further: why not generating a page that allows her to browse steps, select one, fill in the parameters and then write it to a scenario? After doing this for many steps he could copy and paste the resulting scenario to the feature file. Autocompletion, no need to deal with regular expressions, just one copy and paste, nice colors (well, this last point might not be true).

And so cukecooker was born. You can think of it as a Cucumber IDE. To install it:

gem install cukecooker

To run it:

cukecooker

or

cukecooker path/to/your/project

This will generate an HTML file. Open it and start writing cucumber scenarios. Here are some screenshots.

This is the step selection part, where typing in the input above filters the steps, you can navigate them using the arrow keys and choose one pressing enter (or using the mouse):

Once you select a step you can fill in the parameters:

For steps which require a table or a multiline string I just put a big "TODO: complete this"... maybe in a future I'll include an editor for that.

Enjoy!

The idea: in github you can watch some repositories, but later you can't make a search over those watches. The only search github provides is one over all repositories. When your watches reaches a big number it's defeats its purpose. So we decided to let users tag their watches and then be able to search them by tags.

(Well, actually the original idea was a lot bigger: github generates a big feed for your watches, including commits, comments and gists, and we wanted to filter that feed in a smart way, but in just 48 hours, having to install a server from scratch it was a little ambitious)

What we wanted is the tags to be a community effort: if I tag a project with "java", let that tag be shown to other users. On the other side, we also wanted the users to have personal tags. But we didn't want the user to choose, when tagging, wheter it's personal or global, because that's a burden on him. So we came up with the following idea: if more than five users put the same tag on a give repository, that tag becomes automatically available to all users.

We also wanted to start out with some tags, like for programming languages or common software terms, so when a user logs in she starts with some tags on her repositories. So we have a background process that imports a user's watches and put tags on them if their description contains one of those common words. That list gets expanded as tags become automatically available to all users, as described in the previous paragraph. For instance, if the initial tags list didn't contains "orm" as a tag, but more than five users tagged the same repository as "orm", all repositories whose description contain "orm" will now contain that tag. That makes the community effort a lot easier.

On the other hand, the automatic tagging might not be perfect and a repository might get tagged with an incorrect word. So, if more than five users remove the same tag from a repository, that tag gets automatically removed from that repository to all users.

Unfortunately, we forgot to put this behavior on our web site so users might think they must tag their watches without the system ever helping them. We hope to spread that knowledge with blogs and tweets, since we will get disqualified if we make changes after those 48 hours.

It was a really fun experience. I couldn't install the necessary software to deploy it on my computer so I used Emmanuel's one, with Arch Linux and using gvim. I learned a lot!

Emmanuel's brother-in-law helped us out with the design and the logo, which we really like. It seems that octocat had some troubles keeping his watches organized and got tired of it.

Finally, here's the website: http://www.githubdamper.com. We hope you find it useful!

Well, you don't need to do that anymore. Now rgviz-rails supports a pretty simple and powerful way to do it. In your views templates you now have an rgviz function. You use it like this:


<%= rgviz :id => 'my_visualization',
:kind => 'BarChart',
:url => '/some_endpoint',
:query => 'select country_name, sum(age) group by country_name',
'options' => {:width => 640, :height => 480, :is3D => true}
%>


Not a single line of javascript code.

Yes, I know. You have a combo box and when the users changes its value you need to refresh the visualization, right? You can do it with what I call "magic names", hehe.

Read more about this.

We analyzed several solutions. One was using Google Fusion Tables but we soon realized it was not an easy task: we need to keep our records synchronized with Google. Well, maybe not very hard: have a background process that keeps track of the last date of synchronization and gets all the records whose updated_at date is greater then that, and synchronize. The problem is that some of our records can be deleted, so we would need to mark them as deleted or think of something else, which complicates the main logic of our application. Also our application is pretty simple and complicating it with background processes wasn't our ideal solution.

Then we though about just using the Google Visualization API. It works by sending a query to an endpoint which returns some javascript code that includes, amongst other things, a table to be used in the visualization. The query can be anything that the end-point understands but Google has it's own query language, which is used by Google Spreadsheets, for example.

So we started by making one endpoint that just ignores the query and sends what we needed for one of our visualizations. We basically issued an ActiveRecord query, with some sums, custom selects, groups by and joins, and transformed the results into the necessary javascript code. But then we needed another visualization and we had to write another endpoint with yet another query. Soon we realized it would really be nice to have just one endpoint that supports receiving a query, and much better if that query comes in Google's query language syntax, since people should be familiar with it and we can give the documentation URL to our developers and tell them "This is how you can query our endpoint".

This is how rgviz and rgviz-rails were born. The first one just implements a query language parser. The second one executes queries with ActiveRecord. So if you have a model named Person and you want to provide an endpoint to query Person data, you just need to write this in a method of your controller:

render :rgviz => Person

One of the nicest things about this is that you can also use associations in your query. So for example if a Person belongs to a City, you could write a query like:

select city_name, avg(age) group by city_name

Another nice thing is that the pivot clause is fully supported. And the endpoint will always execute your query in just one SQL query, and an efficient one.

So I wanted to simply send an sms message to some number to track my expenses. I carry my cellphone all the time so I can send an sms immediately after paying something. Such an application seems very hard to do at first, specially because of the messaging component: receiving sms, configuring a number, etc. Doesn't it?

Well, we have GeoChat! GeoChat is an application that lets you create groups of people to stay in touch with them. When a message is sent to a group it will be broadcasted to every member. And not necessarily to their mobile phone: each user can decide to receive emails, twitter updates, an instant message to their jabber client, etc. The original use case is for people in the field to report emergency and disaster situations to recover from them as quickly as possible. But that doesn't mean we can use it for other purposes.

For example, one thing that you can do is configure a group in GeoChat to forward some or all of the messages to an external service. You can also configure GeoChat not to broadcast its messages.

So here's the idea: we'll create a group and we'll configure it to send every message to an external service. This service will receive messages like "shopping $20" or "accomodation $300".

So I started coding it and in one hour I got it working! This new tool is called Xpenz.

That shows us how easy is to build some applications on top of GeoChat. In fact, here we are not using much of GeoChat's power, mainly the messaging component. For this you could instead use Nuntium, but I decided to use GeoChat since a lot of messaging is already configured for me and I also had the authentication problem solved.

The code is in Google Code, so it's open source. Let's review the main logic:

class TrackController < ApplicationController
  def expense
    name = params[:sender]
    if name.blank?
      head 'bad_request'
    else
      User.track :user => name, :message => request.raw_post
      head 'ok'
    end
  end
end

So basically we are getting the sender query parameter, which is the GeoChat login name, and if it is present we track the expense by using the request raw post body. And here's User#track:

def self.track(options)
    user = User.find_or_create_by_name options[:user]
    pieces = options[:message].split(' ')
    pieces.map!{|x| x.start_with?('$') ? x[1 .. -1] : x}

    numbers = pieces.select{|x| x.float?}
    texts = pieces.select{|x| !x.float?}
    text = texts.join(' ')

    if numbers.length == 0
      user.currency = text
      user.save!
    else
      if numbers.length == 1
        amount = numbers[0].to_f
      else
        amount = numbers.last
        numbers[0 .. -2].reverse.each{|n| text = "#{n} #{text}"}
      end
      Expense.create! :user => user, :amount => amount, :reason => text, :currency => user.currency
    end
  end

So the first line finds or create the user in xpenz for the GeoChat user. Then we split the message in spaces and do some logic do termine whether it's a currency change or an expense track.

The main point here is that I just had to write about 20 lines of code to make it work. Well, maybe 50 because I tested it.

test "sqrt 1" do
  assert_equals 1, sqrt(1)
end

test "sqrt 4" do
  assert_equals 2, sqrt(4)
end

test "sqrt 9" do
  assert_equals 3, sqrt(9)
end

Here we are dupplicating code, since "assert_equals X, sqrt(Y)" is written all over the place. The naive way to refactor this is:

def assert_sqrt(input, output)
  assert_equals output, sqrt(input)
end

test "sqrt 1" do
  assert_sqrt 1, 1
end

test "sqrt 4" do
  assert_sqrt 4, 2
end

test "sqrt 9" do
  assert_sqrt 9, 3
end

Much better.

Some languages provide tools to deal with this problem in a nicer way. In C# you can do this:

[Test]
public void TestSqrt(
  Values(
    new int[] { 1, 1 },
    new int[] { 4, 2 },
    new int[] { 9, 3 }
    ) int[] values) {
  Assert.Equals(values[1], Sqrt(values[0]));
}

So here we are supplying a set of values for our test. (maybe not much nicer, but the code duplication is gone)

The thing I like most about ruby is that the language gives you the tools to get the most out of your code so you don't end up inventing classes, attributes or whatever just to make something as simple as supplying many values to a test.

Here's a better way to do it in ruby:

[[1, 1], [4, 2], [9, 3]].each do |values|
  test "sqrt #{values[0]}"
    assert_equal values[1], sqrt(values[0])
  end
end

Very good!

What makes this possible?

1. Ruby lets you define code that will be executed at the class definition level
2. Ruby lets you define methods dynamically (here the test function defines a "test_..." method)

Those two particularities makes the language really nice to work with.

Oh, but wait, there's one more thing. I just found out I can do |input, output| in that last piece of code. It seems that if you iterate an array of arrays, you can specify many arguments to the given block and the i-th argument will match the i-th element of the array, so you don't end up doing values[0] and values[1], which obfuscates the meaning of our code. Thanks again, ruby!

So, here's the final code:

[[1, 1], [4, 2], [9, 3]].each do |input, output|
  test "sqrt #{input}"
    assert_equal output, sqrt(input)
  end
end

irb(main):001:0> str = 'chan'
=> "chan"
irb(main):002:0> str.object_id
=> 69952758899780
irb(main):003:0> str += 'ged'
=> "changed"
irb(main):004:0> str.object_id
=> 69952758848800
irb(main):005:0> str << ', now not'
=> "changed, now not"
irb(main):006:0> str.object_id
=> 69952758848800

So I think that basically you should never use += for strings, unless you really want to hurt the garbage collector.