I also use DJ to send out emails, and a typical asynchronous call sending a message from one user to another – scheduling a delayed job – used to look like this:

UserMailer.send_later(
  :deliver_message,
   @recipient,
  current_user,
  params[:message]
)

Since darebusters.com is an internationalized website currently offering users the choice between English and German, this has proved a slight challenge, however. We have the usual internationalization (i18n) bells and whistles: Flags to select the language, and remembering the user’s language selection in session, cookie and in the users database table. By default, a delayed job will simply run with the default locale of the site. It has no way of accessing the context it was invoked in, so it cannot set the locale from session or cookie. The job only knows what it can work it from the arguments it was created with.

It looks like an easy problem to solve. DJ shouldn’t have to know about locales, the code should just set I18n.locale from @recipient.locale. That’s exactly how I initially thought I had solved it: In the UserMailer.message method I set the locale, and then passed parameters to render the mail. The catch is, however, that I use a slight hack to get support for localized ActionMailer templates, i.e. when the locale is set to de it will render the message.de.text.plain.erb view rather than the message.en.text.plain.erb view. The template to render is selected before UserMailer.message is invoked, so at that time it’s too late to set the correct locale. In fact, I needed the entire job to run in a locale specified when the job as scheduled.

For this purpose, I created a custom delayed method to be invoked by DJ: LocalizedJob.

This code should be placed in /lib/. I want the send_later_with_i18n to be available on all objects just like DJ’s own send_later, so I also also created an initializer to extend the Object class:

This code should be placed in /config/initializers/. I am now able to replace all my send_later calls with send_later_with_i18n calls, storing the required locale with job to be extracted when it’s run:

UserMailer.send_later_with_i18n(
  :deliver_message,
  @recipient.locale,
  @recipient,
  current_user,
  params[:message]
)

So on darebusters.com, Germans get all their mails in German – no matter what locale the sender used (although the actual message written by the sender is of course not translated ;) – and everyone else gets mails in English. Now that was a real Ruby fairytale.

IronRuby went 1.0 at April 12th, and it runs Ruby on Rails for real. I demonstrated it myself to a packed room of (mostly) .NET developers at Community Day. There was a lot of buzz around IronRuby more than two years ago – back then, the hype around Ruby on Rails was at its peak and the .NET developers wanted in. It took a lot longer for IronRuby to go gold than many of us had hoped, and meanwhile ASP.NET MVC made its entry. Many ASP.NET developers were aware that the “webform” abstraction with its events, viewstate etc. is leaky and broken, and when Microsoft finally presented this “official” alternative to webforms they rallied to it and rejoiced, for now they had their own Rails-clone, but with a proper programming language and thorough IDE-support.

My presentation compared ASP.NET MVC to Ruby on Rails. The conclusion is ambiguous. I thought I’d be able to crush ASP.NET MVC with the pure greatness of Ruby and Rails, making it obvious to everyone which was the better framework and language. While Rails do support a lot things that ASP.NET MVC is nowhere near of having, the latter does – at least with the recently released version 2 – have the central elements of a proper MVC framework in place. What’s more surprising is that C# 4.0 is so much less clunky than C# 1.0, so in some comparisons of syntax Ruby is not even the obvious winner when it comes to readability. Take this example:

Before LINQ, C# would have never been able to map a collection in a such an elegant manner. In my biased opinion, I still find the Ruby version prettier and more readable, but the fact is that C# is not that far behind. It’s another syntax paradigm for sure, but it’s compact and it’s readable – that’s not bad at all.

So I understand if Ruby and Rails doesn’t have the appeal to .NET developers now as it had a few years ago – back when they where stuck with C# 2.0 and broken webforms. That said, there is of course no doubt that our favorite programming language, framework and community has a lot to offer anyone brave enough to try it out. Previously that required .NET developers to get involved with foreign things such as Apache server and perhaps even Linux servers (!) if they wanted to deploy their Rails project – but with IronRuby and the very cool Rack-implementation for IIS7 it is now painless to run Rails and other Ruby web frameworks (such as Sinatra) on a Windows server. And even better, seen from a .NET developer’s perspective, it’s as easy as pie to call into the .NET framework and custom .NET libraries from Rails:

IronRuby is also good news for Rails-developers. It opens up the the market for selling Rails-applications to al the companies engaged to Microsoft-technology and the .NET platform, and heaven knows there’s a lot of them here in Denmark. We can develop the sites locally on our beloved Macs using SQLite or MySQL as a database, and then deploy to Windows to run on IIS7 and SQL Server – all thanks to Rack and ActiveRecord.

I’m exited about IronRuby, and I hope some of .NET developers in the Microsoft companies are too. If you need any help getting up and running with IronRuby on Rails, just let me know.

Bundler (Github | Website) is the new way to manage gem dependencies in Rails and other Ruby applications. If you haven’t heard about it, there is (of course) a great introduction at Railcasts. It’s pretty easy and straight-forward to use, especially if you are used to the config.gem format of Rails.

However, one very common use case in Bundler’s Gemfile that is not explicitly documented anywhere I’ve seen, is how to configure gems to be installed in both development and test environments, but not in staging and production environments. You have probably seen the examples of how you can assign a gem to a specific environment using the :group option or method. So you’d probably write something like this:

group :test do
  gem "rspec-rails", ">= 2.0.0.beta.1"
end

group :development do
  gem "ruby-debug"
end

The gems you don’t need on the server are usually all those related to testing, debugging and perhaps generating fake data and so on. But wait a minute. You also need the RSpec in the development environment so you can use it’s generators, right? And you need Ruby Debug in the test environment so you can put breakpoints in your tests.

Luckily there is a very easy, and – once you know it – obvious solution to this: You can pass multiple environments to the group method, just like this:

group :development, :test do
  gem "rspec-rails", ">= 2.0.0.beta.1"
  gem "ruby-debug"
end

And that's probably the only grouping of gems you'll need in many Rails projects. Most gems installed and required in all environments, and a few just in the development and test environments. Happy Rails 3 coding.

I have a good friend named Oliver Kofoed who is a brilliant .NET developer. Oliver is an entrepreneur and has written the entire backend for Nonoba and Player IO, he has written his own object-relational mapper (ORM), templating system, multiplayer game server, content management system and so on. He has also been toying with several experimental .NET languages over the years (such as Boo) and even worked a bit on one of his own. Oliver is both curious and passionate about development, and he was in fact the one who initially told me about Ruby on Rails – I owe you one, Oliver ;)

I occasionally nudge Oliver about releasing some of his work as open source, but it has yet to happen. I don’t think Oliver mind sharing his stuff with the community, but the fact is that it takes a lot of work to prepare your code for open sourcing, especially if you haven’t build it with that in mind from the beginning. You need to take anything out that’s specific to your own applications, you have to write at least some documentation and you probably also have to make the code a bit more configurable and modular. To make that effort you need to get something in return from the community – you have to be reasonably sure that your efforts will be appreciated and that your peers will respect you for sharing valuable code with them.

The best way to get a name in the Ruby community is to release a piece of open source software that help other people get their work done. Ruby on Rails is a pretty good example of this. In fact, in a typical stack for running a Rails-based website, not a single piece of software is proprietary. From the operating system and programming language, the database and the web server to the web framework, gems and plugins used in the application, everything is free and open source. To be fair, the .NET framework is also free, limited versions of the development IDEs and the SQL server database are free and I believe it is currently even possible to get free hosting on Windows Azure. But none of these things are open source and that makes an important difference in the perception of the importance of open sourcing in the eyes of .NET developers, I believe. When most of your stack is closed source, you don’t see the need to share your own source with anyone else either.

There is of course lots of great open source projects within the .NET community: NUnit, Log4Net, NAnt, NHibernate (I’m not sure why I can only think of ports of open source Java projects right now) and also some great “higher-level” open source projects such as Umbraco. Many of these has existed for a long time, but it’s a relatively new thing that Microsoft has started releasing parts of their own projects as open source with ASP.NET MVC – a web framework that’s essentially a port of Ruby on Rails (minus the ActiveRecord ORM) to .NET done by some of Microsoft’s best developers – as the prime example. This is awesome, and ASP.NET MVC is deservingly winning a lot .NET developers over from the broken notion of “web forms”. I’m not sure how easy it is to build and share plugins for ASP.NET MVC, but hopefully the project will help more .NET developers to realize the value of sharing code. In the Ruby world we have Github for sharing and collaborating on open source projects, and Codeplex might be able to do the same for .NET – or .NET developers could start using git, but that’s a different story.

ASP.NET MVC also endorses test-driven development, which is another key differentiator when comparing the Ruby and .NET communities. To be honest, I think some .NET developers have even harder seeing the value of testing than of open sourcing. They use a static language after all, so the compiler “tests” that all is good, right? Wrong. Even without tests, problems with wrong types and nil-reference exceptions (“null” is called “nil” in Ruby) are usually easily found and fixed in Ruby. What needs to be tested is intend. Business logic. Calculations. Complicated SQL queries. Redirects. The flow of the application. Test-driven development (TDD) forces the developer to think before he acts, and later it gives him the freedom to refactor without the fear of breaking existing functionality. I understand any developer who feel it is a waste of time to write tests after you have written the actual production code – it’s not, but it feels like it. TDD gives the pleasure of accomplishing hundreds of small steps in the fail-pass test cycle every day, and I hope the popularity of the ASP.NET MVC will push .NET developers more in this direction.

I have of course attended all sessions related to Ruby at MIX10 (all three of them), and Microsoft’s prime example of what to use IronRuby (the .NET implementation of Ruby) for seems to be testing. They love to show off RSpec and Cucumber, and yes, those are cool testing frameworks, but will it really make .NET developers write their test code in a language different from the production code? To me, IronRuby is the .NET developer’s chance to spread the love and magic of Ruby in their Microsoft-centric companies, and just like Rails has been the killer app for the traditional C-version of Ruby, I believe this fantastic web framework can also be the driver of a wide adoption of IronRuby. ASP.NET MVC will be the segway for this, because MVC and Rails have so much in common, that when you understand one, you understand them both – provided you also know C# and Ruby, that is.

Yes, I said “the love and magic of Ruby”. If you think it sounds cheesy, that’s because it is, but the fact is that I’ve seen several slides at MIX10 with statements such as “Ruby is love” and “We love Ruby on Rails”. Ruby is a pretty programming language, and Rails is an awesome framework – but really working with Ruby is all about being passionate about programming, being curious about new technology and have a desire to be on the “cutting edge”. I’m not saying that .NET developers are not those things, but I’ll make this claim: The ratio of highly passionate developers actively seeking the cutting edge of software development is higher in the Ruby community than in the .NET community. There is some very simple reasons for this: First of all, the Ruby community is smaller and has a smaller customer base, which leaves less room for … let’s say “average” developers. Second, almost everyone in the Ruby community comes from a different technical background and has made an active choice to switch to Ruby. C# is a language taught in schools, there are certifications and programs, and in some environments I believe you’d hardly even consider the alternatives. This again leaves more room for the “average” developer who is by no means a bad programmer or person, but who is not building and seeking out new things on the cutting edge. To him, programming is more a job than a passion, and he might even do something else with his spare time than sit in front of the computer.

The point I am trying to make is this: Ruby has a community consisting almost entirely of early adopters, while .NET has many followers in the community. This is not necessarily a problem – in fact it can be very pragmatic not to be on the cutting edge. On the other hand, .NET developers are missing out on a lot of the good stuff by waiting for Microsoft to tell them what to do. As an example, my impression from MIX10 is that the javascript framework jQuery is still a very new thing to many .NET developers, while it is something we have used for years in the Ruby community. I was learning about jQuery at a Rails-conference two years ago, and back then I felt I was late in the game. What’s interesting is that Ruby on Rails is in fact pretty tightly integrated with another javascript framework – Prototype (much too tightly in fact, but that has been remedied in Rails 3) – but we were so blown away by the productivity and community surrounding jQuery that we switched anyway. The fact that Rails is open source and that Ruby is a dynamic language that allows any code to be changed, overridden and monkeypatched, allowed someone to quickly release a plugin that modified all places where Rails currently generates Prototype-specific javascript. Sure, ASP.NET MVC is also open source, but if someone wanted to make a fundemental change such as the one in this example, they would probably have to release a separate branch of the framework the with modified code, since a plugin wouldn’t be able to modify the statically typed and compiled code.

The Ruby community is not perfect. Some think we are arrogant. I can think of at least one person about which this is true, and perhaps you think I’m another good example after having read this. I am actually impressed with how humble and down-to-earth the VIP’s of the .NET community seemed to at MIX10. Another thing you could say about us is that we are trying to avoid dealing with real-world problems by going into Ruby. We leave the .NET developers to maintain and extend existing enterprise solutions built on Microsoft technology, while we go out and build entrepreneurial web apps from scratch. Personally, I like being curious, passionate and on the cutting edge, but it might not be for everyone. Are you a passionate developer?

© 2010 MIX

You might have noticed that I did not link HTML5 to W3C’s specification of the language, but rather to the Wikipedia entry. The reason for that is not just the entry on Wikipedia is much easier to read than any academical spec, but also that W3C’s spec is not necessarily the official spec – or least not the only recognized spec. Molly Holzschlag explained how members of the XHTML 2.0 working group in 2004 grew tired of the slow progress and seemingly wrong direction of what was at the time supposed to be the next generation of HTML, and formed their own working group known as WHAT-WG. These “cowboys”, as Holzschlag likes to call them, very quickly (that is, they did in less than a year!) reached consensus on a new spec and further managed to get all the major browser vendors on board. As a result, W3C eventually shut down their XHTML 2 working group and started their own HTML5 working which adapts and formalizes the WHAT-WG spec into the the long legal specs we know and love … right.

So what is HTML5, really? Is it just the a couple of new tags and features such as built-in client-side form validation? That’s a big part of it, but to be more specific, Holzschlag explained, the term HTML5 covers at least three things: The “cowboy-spec” by WHAT-WG, the “approved” spec by W3C, and then the “umbrella” technology that everybody else talks about. Just as AJAX as a term covers much than sending asynchronous javascript and XML, HTML5 has almost become synonymous with “Web 3.0″ and covers everything that the next generations of browsers will support. And that’s fine, as long as we realize what we are talking about when we say HTML5.

In the Thuesday morning keynote Microsoft announced great enthusiasm about HTML5 in Internet Explorer 9. They are dedicated to get the same markup work across all browsers, but at the same time they are completely in line with an interesting thing Molly Holzschlag said: “Implementation always trumps specification”. So the IE9 team made a tool that crawled the 7000 biggest websites on the Internet and analyzed what features currently missing in IE8 are used the most. So in a very pragmatic way, IE9 will support what people already use and introduce all the new aspects of HTML5.

If you speak Danish, make sure you check out the podcast Daniel Frost has recorded here at MIX featuring me and two other developers talking about our experiences from the first day of the conference.

Community Day in Copenhagen is back again this year, so reserve May 27 if you are near Copenhagen and like free tech-talks, networking and beer. This year Daniel Frost, the Microsoft evangelist that makes it happen, has involved me and several other developers actively in the planning of the day. With CD ‘10 we have raised the level of ambition – bigger venue, more people, more talks and if course more fun.

We will have 20 sessions distributed on four concurrent tracks covering a surprisingly wide number of topics – very few of the talks are on Microsoft-technologies, in fact so few that we might loose a few of those .NET consultants who thinks anything non-MS are not worth listening to ;) Still, if you are doing anything at all related to the web (and most of us are, right?) you will surely find topics such as HTML 5, Single Sign On, Azure, Advanced jQuery etc. interesting.

I will be giving a talk with the rather bold title “Replace ASP.NET with IronRuby on Rails”. It will give me an excuse to seriously dive into IronRuby and how to make a Rails site talk fluently with .NET libraries and assemblies. Coming from a serious amount of ASP.NET development myself, I really think a lot of web-based .NET projects could benefit from Ruby on Rails. The only time I was really happy with ASP.NET was when I switched to that from classic ASP – but since then, it hasn’t evolved that much. Granted, ASP.NET MVC has rescued developers from the annyoing “webform” structure, but it still has a long way to go.

I’m getting ahead of myself here, come watch the session – sign up for Community Day ‘10 now!

For me, the situation is like this: My standard version of Ruby on my development machine is 1.8.7. I deploy to many different environments, some (the ones I have a degree of control over) runs 1.8.7 and others (such as Heroku and some customer’s servers) runs 1.8.6. I can test and code away happily only to get some ugly exceptions when I deploy because I have called count on an array instead of length. Further, I also want to play with the new features of Ruby 1.9 and run Rails 3 on it. And that’s not to mention that I also use alternative Ruby implementations such as JRuby for projects where I need to tap into Java libraries.

So that’s at least four different versions and implementations of Ruby I want to use at various times. I need to compile gems separately for each of them, and I don’t want them to clutter up my default and very functional Ruby 1.8.7 installation which I still use most of the time.

Ruby Version Manager (rvm) to the rescue! This very welcome open source project allows us to easily install, manage and switch between multiple Ruby versions and implementations with a single command. The software itself is also easy to install:

sudo gem install rvm
rvm-install

Once you have followed the instructions and pasted the line of script into the correct file and restarted (or sourced) your shell, I recommend that you upgrade to the edge version of rvm by running this command:

rvm update --head

This gives you access to the newest versions of the installation scripts, and that is needed if you for instance want to install JRuby:

rvm install jruby
rvm jruby

That second line is all you need to switch between ruby implementations – here we switch to JRuby. Note that this is not a system-wide change – the switch is done simply by changing a few environment variables in your current shell so ruby, rake and so on now refers to the JRuby versions.

One gotcha is that gem will installed the wrong place if you have the —user-install flag in your .gemrc file. The only current resolution I know is to remove the flag.

Never the less, I will highly recommend that you install Ruby Version Manager and play with different Ruby version and implementations – it has never been easier.

Enjoy the new decade – take care of our world.

For some reason – and I am sure people with a bit more insight into the human psyche than me can tell you exactly why – videos where people do something really stupid, disgusting, dangerous or daring are amongst the most popular. But what reward do the people who makes these videos get for their hard work? A lot of views and comments on Youtube? That’s nice, sure, but couldn’t we get something even better if the makers actually earned some money on entertaining the rest of us?

darebusters.com is where this is happening right now. We have created a platform where people who wants to show how truly talented or crazy they are rewarded for their hard work in cash – we call them darebusters. darebusters.com is not the next Youtube or Vimeo – rather, it is intended to be a sprouting community of people with crazy ideas for dares, people willing to sponsor those dares on video and – of course – the darebusters making it all happen.

Here is how it works: A darebuster uploads a teaser video where he explains what kind of dare he has in mind – or a user suggests a dare for somebody else to complete. Either way, the dare now has a certain time period to collect the required amount of money through micropayments from other users who thinks that idea is cool enough to support. When the amount is reached, the darebuster must now complete the dare and the ratings the completion video receives decides how much money the he gets out of it.

The business model for darebusters.com is simple – there is no subscription fee or price tag for watching specific videos. Rather, users are required to sponsor a dare at least every two weeks to continually have access to all completion videos. This way, the users decides which dares are really worth making and a higher quality of entertainment is reached.

I am a founding partner of darebusters.com and I have developed the entire site in Ruby on Rails during the last couple of months (well, except for the fantastic graphical design). We are currently testing the site in a closed beta, but if you signup for a beta invitation or contact me, we will let you in to play around with it: darebusters.com.

Many of the applications we build send out a lot of emails, and for some, it is a critical part of the system. Lokalebasen is such an application, and the people behind wanted to monitor all outgoing mail, whether generated by a page request, a cron job, an administrator or anything else.

I built a clever little monkey-patch for the Ruby on Rails ActionMailer that makes sure that all outgoing emails has a certain email address put on BCC. This is not visible to the recipient, but it allows you to keep an archive of all outgoing mail, which is certainly useful – especially for support and bug-tracking.

Drop this into your lib-folder (remember to change the email address):

- and be sure to enable it by adding this line to environment/production.rb (you probably don’t want to BCC mails sent in development and test mode):

ActionMailer::Base.send(:include, BccAllMails)