Daniel Mellgaard Frost, Developer Evangelist with Microsoft Denmark, had put together a diverse program where only two talks was devoted entirely to Microsoft technologies (Silverlight and LINQ), but six out of eight talks was about web development in some form. I did a talk on ActiveRecord, the O/RM of Ruby on Rails, and according to the many happy comment I got afterwards, it went pretty well.

One really great thing about Ruby is that you can start writing code in front a crowd that have never seen the language before, and they will understand everything you are doing - provided, of course, that they know another object-oriented programming language. Ruby is such a beautiful language that it instantly appeals to most coders, and that makes it a pure joy to do a presentation mostly based on live code examples such as I did.

It also helps that ActiveRecord has an impressive number of features to show off, and even though I don’t how much it really mattered, I think I made a good tactical choice in demonstrating the O/RM running against a Microsoft SQL Server instance. This post, by the way, is what helped me to get my Mac to talk to SQL Server, but bear in mind, that if you run an older Ruby version and/or use the installation that comes with Leopard, that tutorial will upgrade you to Ruby 1.8.7 running via Macports.

Here is the presentation slides from the talk (in Danish), and here is the very limited quantity of code I wrote.

I also lead an open space meeting on jQuery - the presentation on the topic was unfortunately canceled in the last minute - and although I am still learning the many aspects of this great Javascript framework, I think every web developer owe it to his or hers own productivity to take a look at it. Doing Javascript development with jQuery and Firebug is immensely effective, not least because of the literally thousands of open source plugins that have been written for the framework by the community.

Thanks for Daniel, Microsoft and the community sites for sponsoring and organizing this fun and inspiring event - I look forward to next year.

We did that anyway, obviously, but mostly we were learning, tweeting, chatting, coding, emailing and taking notes at a conference where the wifi actually worked and power strips were easily available. I’m not going to reference all the talks that I went to here, but I have uploaded my notes here. Also, I’ve written a detailed summery of David Heinemeier Hansson’s keynote and a few select talks that I attended for RailsMagazine, but the free PDF-edition won’t be available for another two weeks now freely available for download … slides from all the presentations can be found here.

So what did I take away from RailsConf from the top of my head? The first that springs to mind, is that I got to try RubyMine, a new IDE for Ruby on Rails. At first glance this might look like another Aptana or Netbeans, but the Rails Envy guys gave a stunning demonstration of the power of this new IDE: From TextMate keymapping and navigation, over code completion and refactoring that actually works, to automatic diagramming of models and their relationships, this product looks like a real productivity booster. I’m going to try it out the minute I get home.

Rack kept popping up everywhere. Lots of talks on Rack and Rails Metal (which is really just a wrapper for a “raw” Rack handler), and now Rack suddenly doesn’t feel so scary anymore. It just a way to do cool things on a raw request and/or response without the (full) overhead of the Rails stack. JRuby was another popular topic, as well as clouds - how to deploy to server environment that will seamlessly scale with your needs.

I have been following IronRuby with great interest since the project was started 2-3 years ago, and I was a bit disappointed to hear that the .NET implementation of Ruby is still nowhere near completed. I asked Jimmy Schementi from the Microsoft IronRuby team what took them so long (to be honest, I was a bit rude, sorry Jimmy), and asked that things simply took time. He said that JRuby had been 6 years underway. The positive news, however, was that the IronRuby team is still very committed to making their implementation fully Ruby 1.8 compliant, and that are using Rails to measure their success against.

I’d love to tell you more, but my plane is leaving soon, so you will have to make do with my notes.

Community Day 2009 is free 1-day event May 28 in Copenhagen sponsored by Danish developer communities. Besides my two cents, it also features presentations on Android, Flex, Air, Silverlight, LINQ, Drupal, jQuery and ASP.NET MVC - in other words it looking to be a lot of buzzwords and popular technologies explained. As if that wasn’t enough, the day also include three geek-friendly meals, friendly competitions and lots of free beer.

The course I will be teaching at Copenhagen Business School is called Agile Development in Practice, and builds upon a theoretic platform of agile methods. The course focus is on giving the students practical experience with Scrum and Ruby on Rails through a combination of traditional teaching and working with real-life examples. The course is free to attend for all Danish students, and counts for either 7,5 or 15 ETCS points. Others can also enroll in the course for a fee. The course description is not yet available on the CBS homepage, but I will link to here as soon as it is ready.

But before all that, I myself will hopefully learn many new and useful things about Ruby, Rails and all things geeky at RailsConf in Las Vegas. See you there? :)

Lokalebasen (a Danish website for rental and sale of business property) is (of course) based on Ruby on Rails and uses the notoriously brilliant jQuery as Javascript framework. When the customer asked for a progress bar while uploading assets, I knew there was basically two choices: Polling the server for the progress of the upload, or uploading through Flash. I choose the last option because I believe it is easier to implement, and it gives the added bonus of being able to start the upload in an “ajaxy” way without refreshing the page.

Several ready-made solutions exists, and chose one that was built as a jQuery plugin, was updated recently and was easy to use while being highly configurable: Uploadify. This article is not an Uploadify tutorial - you’ll have to work the out from the documentation and the examples. Rather, it’s about the last piece of the puzzle, how to make Rails play nicely with Uploadify.

Lokalebasen uses attachment_fu for handling assets. Since traditional file upload was already implemented, I had fallback functionality for users without Javascript or Flash - and so should you. All I had to add the controller handling the upload was a detection of the correct content type. Browsers will usually provide this, but Flash does not. And so the controller ended up looking something like this:

The mime-types gem is used to detect the content type - installation and usage is explained here.

I needed the functionality several places, so I wrote a partial I could reuse:

There is a lot going here, so let’s take it from the top. The content_for :head section is the code that will be placed inside the <head&gt part of the page - my layout takes care of that with a yield :head call. So first the Uploadify jQuery plugin javascript file is included, followed by some javascript that applies Uploadify to the file_uploader div seen later in the partial. This includes a lot options, some of which uses variables supplied to the partial. Here is an example of how I call the partial:

I won’t walk you through all the options I supply for Uploadify, but let’s take a look at the important ones: script is where Uploadify will post the uploaded file to. This should be the create action of your asset controller. scriptData is the most tricky one. The option specifies what parameters should be posted to the controller along with the file. 'format': 'json' ensures that the wants.json block is invoked in the controller, instead of the default wants.html. This helps the controller to separate Flash uploads from ordinary uploads. The two other parameters in scriptData will be explained later in the article, is they are the key to get the uploading past security and authentication measures taken. fileDataName extracts the name to use for the uploaded file (e.g. asset[:uploaded_data] for attachment_fu) directly from the fallback form. onComplete makes an ajax get request through jQuery to the same url we are currently on. I use this to render some javascript that updates the page in a wants.js in the controller.

There are several gotchas when you upload files through Flash. The most common one, which also apply to ajax, is the infamous ActionController::InvalidAuthenticityToken exception. You will get this exception on any default Rails installation with authenticity checking enabled. Rails expects any post to an action the include the authenticity_token parameter. It is used to verify the post actually came from the same application, and Rails automatically adds to all the forms and ajax requests it generates. In this case, we have to apply it manually, and this what happens with 'authenticity_token': encodeURIComponent('<%= form_authenticity_token if protect_against_forgery? %>‘). The form_authenticity_token returns a valid token, but first we check if forgery is enabled. If it is disabled (which it usually is in tests), we will get an error if we invoke form_authenticity_token. encodeURIComponent makes sure that any characters in the token is encoded correctly. With this parameter, we should be able to make an authentic post through Flash - or maybe not …

Rails use data in the user session to authenticate requests, and requests directly from Flash does not include the session cookie that Rails use to find the session. Thus we still get the ActionController::InvalidAuthenticityToken exception, even with the authenticity_token parameter added. We have to make a slight hack into how Rails handles sessions to make this work. Place this code in a file in config/initializers to apply the hack, which tells Rails to try to read the session id from a parameter, if it can’t find in a cookie. This will only happen, however, if we add the line session :cookie_only => false, :only => :create to the asset controller. Also, we must supply the session in a parameter, which is what '<%= Rails.configuration.action_controller.session[:session_key]%>‘: ‘<%= u session.session_id %>‘ } do. The unique session key of the application is taken from the Rails configuration, and the session id is taken from session.

With these measures in place, Rails can now properly authenticate our Flash upload request as a legal, secure post. As an added bonus, actions protected behind session-based logins now also just works. And I would guess that most applications require their users to register and login before they can upload files.

Finally, here is a trick if you use http basic authentication e.g. for the administration tool like we do on Lokalebasen.dk. Place an is_admin? flag in the session, as shown in the code below. This will allow even Flash uploads to be authenticated, even if they don’t supply http basic authentication information:

Today I decided to cheat on Rails. And I’m not talking going back to the ugly ex, ASP.NET, or getting back in touch with old flirts such as PHP or Java, no … Once you go Ruby, you don’t go back.

But there are other Ruby web frameworks than Rails. “What? I thougth Ruby was invented for Rails, as a kind of unintentional side effect?” you might say, but it is no so. Until recentl, Merb has probably been the most well-known “Ruby-based framework that is not Rails”, but now the two are getting hitched and as such we have to look elsewhere for alternative Ruby frameworks.

Webby is one such framework. Or to be fair, Webby is so much less than both Rails and Merb, and that’s the whole point. Webby are for simple, static home pages that can be hosted on anywhere. The Ruby framework generates static html files based on layouts and content pieces defined in the project. It doesn’t use a database, it doesn’t parse forms and that is exactly the simplicity you sometimes need.

The two greatest benefits in Webby is:

1. Content is plain text files and can be put in source control painlessly
2. Output is plain html files and be deployed anywhere with just FTP, RSync or SSH

As I see it, this makes Webby the perfect “un-CMS” for a web site maintained by developers. We don’t want to type in long texts in textareas in the browser - we want to do it Textmate or whatever our favorite text editor is called. We want full control over the HTML, we want speed and we want real versioning for our content.

Some times Rails is just plain overkill.

Resources:

• Webby homepage
• Great Webby tutorial (but a bit outdated, make sure to replace references to webby with webby-gen, and references to rake with webby.)
• Another good tutorial

We were all there. The geeks, the journalists, the communication and new media consultants and the Internet entrepreneurs. Copenhagen Twestival was my first experience of meeting the Twitter community, and my guess is it was probably also the largest gathering of Danish Twitter users to date - we were around 120 people. Turns out that the Danish tweet-crowd consists of many well known faces from gatherings such as Copenhagen Ruby Brigade, Barcamp Copenhagen and Reboot.

Copenhagen Twestival was, along with many other similar meetings around the world, a charity event with the purpose of raising money for charity:water - an organization that argues that clean drinking water is the essential foundation upon which developing countries can evolve into something better. I can’t claim that I suffer from any great social conscience, but when Maame Agyeben - a former intern with the organization - told about charity:water, I was truly impressed. Their administration costs is sponsored separately, which makes them able to say that 100% of the general donations goes to building wells.

Red Cross and other global help organizations are doing a great job, but I like the prospects of charity organizations with a more narrow and dedicated purpose being able to pursue their cause globally by innovative use of Internet services. That night, we generated DKK 5,000 from the sale of 500 lottery tickets to win donated gifts, and probably a similar amount from buying overpriced, donated drinks.

© 2009 Rasmus Luckow

The twestival was not just about water and charity. Members of the Danish Twitter community had prepared presentations, and one of them was Mikkel Malmberg a.k.a. mikker with a talk about Twitter - for people who know Twitter. Mikkel was introduced as “the craziest guy on Twitter”, and he showed himself worthy of the title with an entertaining and energetic show. I wouldn’t do his talk any justice by repeating it in text - you will have to see him in person some other time.

The culmination of the evening was the Twitter panel, consisting of Henrik Fohns, journalist from DR, Thomas Madsen-Mygdal, entrepreneur and organizer of Reboot, and Troels Jørgensen, director of Berlingske Online. The format was a number of predefined questions - ideally in 140 characters or less - which each panel member got a chance to reply to. Fohns is a well-known voice from a long-running Danish radio series on technology - Harddisken - and it was good to see him in the flesh. It was also clear that this was a man with great experience in voicing his opinion on media and technology in comfortable, well-phrased sentences, and I for one felt compelled to believe in everything he said just from the familiarity of the voice.

© 2009 Rasmus Luckow

Another familiar voice was that of Mygdal. I know him from his Reboot opening speeches and from some of the many technology projects he is involved with, but I didn’t know how opinionated and loud-mouthed he could be once someone gave him a microphone and asked him to voice his opinions. He reminded me of the hero in the Ruby on Rails community - David Heinemeier Hansson - but where David’s battle is with “enterprise” software development, Thomas’ seems to be with established media and journalism.

The first question was about the future news outlook. Mygdal said that journalists does a poor job, because it is impossible to do what they do. Also that the business model for news papers hasn’t changed in 250 years, which why they are they are now in so much trouble. “It’s pure biology”, he said, “nobody tries anything [..] We are really fucked, but we have to try something and fail.” Fohns compared the volunteer news papers run by all kinds of unemployed people in the 80’s to today’s blogging. It is journalism by the unestablished, he said, and he called it “New Cultural Press”.

© 2009 Rasmus Luckow

Another question was: Do we even need the traditional media? Troels Jørgensen was of the opinion that journalists has far too high wages in Denmark, compared to Sweden, for instance, and that was one reason it is so hard and expensive to run a media house in 2009. Mygdal pointed out that we use the term “new media” every time something new comes along that we doesn’t quite understand. In the mid-90’s, the Internet was called “new media”. He said that we need to reinvent media in a way that really brings the new opportunities together, instead of just trying to coerce “new media” into “old media”.

One final question worth mentioning was on the issue of media subsidy. As Mygdal put it: “We spend 6 billion on media subsidy - the government could finance 2,000 micro medias at 3 million each a year for that money.” However, as Fohns objected, working in small units, you don’t always have the required impact. As an example he mentioned the case of IT Factory, where the freelancer Dorte Toft, who spearheaded the whole uncovering process, were under a lot of pressure from the lawyers of Stein Bagger. That kind of pressure is easier too handle when you are part of something bigger, and have lawyers and other support of your own to back you up.

© 2009 Kristoffer Solberg

I also remember that Mygdal mentioned at some point that Twitter really isn’t something new, that it is simply derived from blogging as a format better suited for people like himself, who might not be that good at formulating long articles. What do you think, perhaps I’d also be better off just keeping to 140 character outbursts? :)

This is by design. Radiant has a fantastic infrastructure for extensions, and rather than imposing a lot of advanced functionality making the software harder to get started with for everyone, it lets each developer make his or her own choices.

Still, even with the official extension registry it can be hard to navigate the many extensions out there. Many people have asked me what I recommend for just getting basics such as reordering, image upload and menu generation. There is no final answer to that question, but this article covers 10 extensions that are compatible with the newest versions of Radiant and gives you functionality you can’t live without.

For everyone

• Reorder: Yes, you really need to install an extension to be able to change the order of your pages in the page tree. I think this will be built into Radiant 0.7 - hopefully!
• Paperclipped: Currently the most popular extension for adding upload of images and other files. Great user interface - highly recommended.
• Copy/Move: Once your website is live, you’ll often find the need to move or copy pages to other places in the page tree - this extension lets you do just that.
• Navigation tags: There is a tag for generating the menu built into Radiant, but it requires you to hardcode the pages. This extension allows you to build your menu in a similar manner, but draws on the actual published pages in the page tree.

For the slightly larger website

• Nested layouts: This extension is a real gem if you ask me. It allows you to have a master layout with header, footer, main menu and so on, and then setup other layouts “nested” within the master with, say, a custom sidebar or headline shared by a bunch of pages.
• Styles and scripts: If you want to be able to change all aspects of your website without deploying new files, there is no way around this extension. It allows you to store stylesheets and javascripts separately from your pages, while still being able to update them in the admin interface.
• Concurrent draft: Allows you to have one published version and one draft version of each page. That way you can work with changes to a page and preview them, without having to actually publish them for everyone to see.

For those who build their own extensions

• Shared layouts: If your extension includes pages that need to use the same layouts as the Radiant pages, this extension is a must. It simply lets you specify a Radiant layout in the controller just like you specify a Rails layout.
• Exception notification: Once you add your own extensions to Radiant it makes very much sense to be notified of any exceptions that occurs. This extension wraps the popular exception notification plugin which has a few compatibility issues with Radiant.
• Settings: I highly recommend that you let your own extensions be configurable through the standard Radiant::Config interface. This extension provides a tab in the admin interface for adding and editing these settings.

Many, many more great extensions exists for Radiant - I haven’t even mentioned my own! And while the official extension registry is a great initiative, you’ll find even more by searching for “radiant extension” on Github.

I wish I could claim to have been playing with Merb for a while and have some real insight into the framework, but to be honest, I haven’t. I still think this a very interesting news, though, and in my opinion this can only be good news for the Rails community. Already, the brilliant Merb guys are optimizing and improving Rails, for instance this 8% speed boost in using respond_to.

So, how can we expect the the merge to affect the Rails framework we know and love? Let’s peek into the possibilities of combining these two frameworks.

One change that seems certain, is changes to the routing system. “Plans are already underway to port the Merb router over to Rails. At the very least, you will have the option to use the Merb DSL syntax instead of the Rails hash-based syntax. We’ll see which one becomes the default.” Katz says. David explains how Merb concepts for rendering resources in different formats will be used in Rails 3, but with more intuitive or “Rails-like” naming.

Another change which is likely to make it into Rails 3 is slices, as indicated by Katz in a response to his own announcement. Slices are “similar to what Rails-Engines promise, except merb-slices are built into the framework” as Ezra Zygmuntowicz explains. This is exiting news! I’ve always been interested gaining leverage by having reusable application slices, and I’ve actively built and used both Rails Engines and Radiant extensions. Engines has previously been frowned upon by leading figures in the Rails community, but it has been improved to work in a quite clean and easy-to-understand manner since the release of Rails 2.0, and are in fact compared to Merb slices here. Radiant extensions are obviously only for Radiant CMS-based websites, but the diversity of these extensions illustrates the potential of getting support for real full-stack application slices into the Rails core. A project like Adva CMS also illustrates how it is possible to build high quality reusable application slices for the common good.

A third change I hope to see as a result of the merge is controller-based mailers and partials. ActionMailer has always been a bit of an ugly stepchild in the Rails framework, and the positioning of a Mailer as a sort-of model, but with templates, doesn’t seem logic to me. Merb has an AbstractController class that both mailers and partials (called parts in Merb) inherit from, which allows for a more intuitive control in rendering mails and parts.

I was curious to find out how the Merb community has reacted to this decision. The Rails community doesn’t seem to be overly concerned. Perhaps it’s because the merge of Merb and Rails are called “Rails 3″. Not “Merb 2″, not “MerbRails” - the names clearly signals that the merge will be done on Rails’ terms. While it has become popular in the Rails community to dissociate one self with David Heinemeier Hansson, I still think people sees him as a good security for not letting the Rails principles go in the merge.

I browsed through the more than 100 comments to Yehuda Katzs announcement of the merge, and while about half of the commenters simply expresses their happiness and agreement with the decision, the objections of the other half falls roughly into three categories: Technical, personal and economic.

The technical concerns are of course fully expected, and some of the more interesting are:

• “Does merging a lightweight framework into a bloated framework make the bloated framework any lighter?”
• “I really hope that merb will be able to continue it’s ‘no-magic’ attitude and bring that to rails without compromises”
• “I would have liked to see merb go further on its own just to push the envelope further”
• “How many planned advancements are being put on hold while Rails catches up?”

The personal objections is about one very visible person: David Heinemeier Hansson. I hold no grudge against David, so I shall only repeat one of the more curious comments in this category: “The big problem, as always with Rails, is DHH: a vainglorious, two-faced prima donna with a massive and fragile ego. He’s good, but not nearly as unique and amazing as he thinks he is. I went to Merb to get away from DHH. Ugh.” If many people in the Merb community feels like this guy, I understand if they are concerned that David will simply steamroller the philosophy of Merb. David has been fast to address these concerns, but the question is if just saying everyone should work on what the care about is enough.

The economic perspective of the merge is where things gets interesting. Rails is trademarked by David and synonymous with 37signals, while Merb is very closely linked to EngineYard. Two commenters really nail it down:

• “How has the ‘Opinionated Software’ philosophy of “Fuck You (DHH)” Rails become aligned with the ‘open’ and democratic philosophy of Merb? Is this some kind of preemptive marketing in advance of a joint investment in both Engine Yard and 37 Signals by a common investor?”
• “My suspicion turns to the fact that almost every Merb core team member is owned by Engine Yard. Something doesn’t smell right.”

It’ll be interesting to follow not just the architectural design choices made on the technical front during the merge process, but also how this will change the positioning of 37signals and EngineYard, and if the two companies are really warming up to some kind of close relationship.

The timeline for a first peek at Rails 3 - the union of Merb and Rails - is said to be RailsConf 2009 - 4 months from now.

Thank you for helping me out, thank you for doing business with me, and thank you for following my ramblings. Let’s do it all again next year!

Now that I’ve had some time to experience self-employment on my own, I’ve come to realize that there are many similarities between being an entrepreneur and being a nissemand. Both is hard, but when and if you reach the happy ending, everything will be good. As a Christmas greeting especially for you, I’ve recorded a song about just that :)

I wish you a merry Christmas and a happy New Year!

All the best,
Casper

My problem was this: I was developing a Radiant extension called tags_multi_site, which allows the tags extension to play nice with the multi_site extension. This required me to scope all tags within a site, so that tags with the same name could exist in different sites, but in the same physical database table.

The tags extension has this validation:

class MetaTag < ActiveRecord::Base
  validates_uniqueness_of :name, :case_sensitive => false
end

I needed to add :scope => :site_id, but I couldn’t touch the code of tags extension itself, since that would terribly un-DRY and not reusable for anyone else. I had to either modify the existing validation programmatically from my own extension or to remove it and add my own.

I went for the last solution. I quickly discovered that validations are saved in an array available as an inheritable attribute on the model (read_inheritable_attribute(:validate)), and that the built-in Rails validation are stored as Procs in this array. One could remove all validations added so far by emptying this array, but I only wanted to remove validates_uniqueness_of to stay as loosely coupled as possible.

Procs can’t tell much about themselves - they are mostly just there to be called. But I knew from the Rails code that each validation Proc is added from inside the class method of the validation. So, I just had to figure out a way to determine the method context the Proc had been declared in to be able to remove the right one.

I realized I could read variables from the Proc’s context by doing an eval with the Proc’s binding applied. I also found an expression somewhere that returned the name of current method by using the stacktrace information in caller.

All in all, the solution ended up like this:

module TagsMultiSite
  module MetaTagExtensions
    def self.included(base)
      base.extend(ClassMethods)
      base.class_eval {
        # HACK: Remove the existing validates_uniqueness_of block
        read_inheritable_attribute(:validate).reject! do |proc|
          if proc.is_a?(Proc)
            method = eval("caller[0] =~ /`([^']*)'/ and $1", proc.binding).to_sym rescue nil # Returns the name of method the proc was declared in
            :validates_uniqueness_of == method
          else
            false
          end
        end

        # Add new validates_uniqueness_of with correct scope
        validates_uniqueness_of :name, :case_sensitive => false, :scope => :site_id
      }
    end
  end
end

It would be easy to make this into a generalized method for removing Rails validations, but I think this issue is pretty rare. Usually people can just change or remove the original validation. Still, this example demonstrates fairly well how the trusting nature of Ruby allow us to make far-fetched metaprogramming hacks to solve our problems.