If you’re going to have to stop your site for a maintenance or deploy break and care about your users (and SEO!), you should setup a custom 503 page. AskApache provides some documentation on this, but the examples require creating a PHP page. One of the commenters proposed a non-PHP version, but it’s complicated and didn’t work for me.

So, this is the simplest way to set-up a custom “we’ll be back shortly” error page in Apache 2 that also tells Googlebots to retry after 1 hour:

ErrorDocument 503 /503.html
RewriteEngine On
RewriteCond %{REQUEST_URI} !^/503.html$
Header always set Retry-After "3600"
RewriteRule .* - [R=503]

Read on for explanation and a more advanced example.

The above lines should be placed in you Apache’s site config file (e.g. /etc/apache2/vhosts.d/<your-site-name>_vhost.conf) somewhere under DocumentRoot directive. The first line sets a custom file for HTTP 503 status. The path you provide here is relative to DocumentRoot, so if you have:

DocumentRoot /var/sites/my_site/current/public
ErrorDocument 503 /503.html

then the file should be at /var/sites/my_site/current/public/503.html. Having a regular HTML means that you do not need anything except Apache itself to serve it. Inside it you can provide a message about the cause of the break and when you expect your site to be back up.

Next line (line #2 in first example) turns the RewriteEngine on, which is needed to process the following directives. Line #3 excludes from processing all the requests that go to our 503 page. Without it we would get an endless loop of redirections (which would not be endless in Apache, of course, but after exceeding the redirection limit would cause an error instead of producing the page).

Line #4 sets Retry-After header for bots, which is set here for 3600 seconds. If you expect your break to be much shorter, you can use a lower value. The last line sets a 503 response for all requests that made it up to here (i.e. not excluded by line #2).

Let the developers in

Often you need to allow some people (the developers or the client) to play with site even if it’s unavailable to the rest of the Internet. To do so, you can exclude them from getting the 503 page by entering their IPs:

ErrorDocument 503 /503.html
RewriteEngine On
RewriteCond %{REMOTE_ADDR} !^1.2.3.4$
RewriteCond %{REQUEST_URI} !^/503.html$
Header always set Retry-After "3600"
RewriteRule .* - [R=503]

The only thing new here is line #3, which excludes all requests coming from IP 1.2.3.4. You can use this directive as many times as you need.

Troubleshooting

If the above doesn’t work, first try following:

• Double-check the 503 file location.
• Assure that the owner of apache process can access and read this file.
• Make sure that you have mod_headers and mod_rewrite activated.

This is my take on implementing a very simple persistent consumer-producer style queue using database table. The producers insert records to the table and consumers process them. There can be many producers and/or consumers working simultaneously. They can be separate processes or threads. There is no explicit locking.

First, a disclaimer: if you want a robust, stable and efficient queue, you should probably use a full fledged queue mechanism. The following code works with Ruby on Rails and MySQL.

The queue table should contain two additional columns that will be used by the queue mechanism: STATUS and PID. The STATUS column defines a processing status for each record — we need at least three:

class Thing < ActiveRecord::Base
  STATUS_READY       = 1
  STATUS_IN_PROGRESS = 2
  STATUS_DONE        = 3
  ...

STATUS_READY means that the record is ready for processing by a consumer, STATUS_IN_PROGRESS is set when a consumer is working on this record and after that it’s STATUS_DONE. Alternatively, the consumer could just remove the record, it doesn’t matter for the algorithm.

The PID column is the key to this concept. I assume that each consumer can be identified with a unique number. If you use separate processes, this can be the operating system’s PID ($$ in Ruby). For threads, you can use Thread.current.object_id. If none of these is available you get any number for each customer as long as your scheme guarantees that each number will be unique across all simultaneously working consumers.

The producers part in this algorithm is trivial: they just have to insert records with STATUS_READY.

The queue mechanism must ensure that each record will be processed by only one consumer. That’s what the PID is used for:

class Thing < ActiveRecord::Base
  ...
  def self.get_for_processing pid
    update_all(
      { :status => STATUS_IN_PROGRESS,
           :pid => pid },
      { :status => STATUS_READY },
      { :limit  => 1 })
    find_by_status_and_pid STATUS_IN_PROGRESS, pid
  end
  ...

The above method first updates one record from STATUS_READY to STATUS_IN_PROGRESS and sets PID column to given value. This means that the record is reserved for the consumer identified by this PID. Then the reserved record is returned by find_by_status_and_pid call. This is equivalent to issuing following SQL queries:

UPDATE things
   SET status = <STATUS_IN_PROGRESS>,
       pid    = <pid>
 WHERE status = <STATUS_READY>
 LIMIT 1;

SELECT *
  FROM things
 WHERE status = <STATUS_IN_PROGRESS>
   AND pid    = <pid>;

The UPDATE is atomic so there should be no collisions. It reserves one record if there are any available. The reserved record will not be reserved by any other consumer.

One important thing: each consumer must change the status of processed record to STATUS_DONE (or remove it) before it asks for another one. Otherwise the find_by_status_and_pid will return the same record over and over again (although update_all will reserve another record with each call).

When there are no more records to be processed, get_for_processing returns nil. It’s up to consumer to decide what to do then (wait, raise an exeception, etc.)

If you want the records processed in an order other than default (which is lowest-id-first for MySQL), you can use :order clause, for example to implement a LIFO queue:

class Thing < ActiveRecord::Base
  ...
  def self.get_for_processing pid
    update_all(
      { :status => STATUS_IN_PROGRESS,
           :pid => pid },
      { :status => STATUS_READY },
      { :limit  => 1,
        :order  => 'created_at asc' })
    find_by_status_and_pid STATUS_IN_PROGRESS, pid
  end
  ...

I18n layer, introduced in Rails 2.2, is said to be “the simplest thing that ever could work”. Too bad they didn’t go for “the simplest thing that could be practical to use”. These two can be very far apart. I have a hard time imagining a real-world app using only bare Rails’ I18n engine.

Another unpleasant thing is that Rails 2.2 broke GetText compatibility, which prevents many projects from migrating to Rails 2.2 or later versions.

Well, not anymore. Thanks to clever guys Masao Mutoh and Michael Grosser, it’s finally possible to get Rails 2.2 running with GetText. Read on for details.

This post is only a compilation of information that can be found at http://github.com/mutoh/gettext/tree/master, http://github.com/grosser/fast_gettext/tree/master, http://github.com/grosser/gettext_i18n_rails/tree/master and some other pages. These are by all means excellent pages, yet at some places imprecise or contradicting each other. It took me quite some time to make it work together, hence this post.

Warning: I assume basic knowledge of how GetText is used in Rails project, what are .po and .mo files etc. This post is not a tutorial on using GetText in general. You can find excellent tutorials by Masao Mutoh at http://www.yotabanana.com/hiki/ruby-gettext-howto-rails.html.

Installing

GNU gettext

First, install a version of GNU gettext in a version suitable for your machine (Mutoh’s page says version 0.10.35 or later, at this moment the current stable version is 0.17 and for MSWin you can use precompiled version 0.14.4 from GnuWin32 project). Make sure gettext’s bin directory is added to your $PATH!

Racc

Racc is Ruby yacc, i.e. a parser generator. I’m not sure if it’s necessary, so you can skip it at your own risk. If you decide to install it, download http://i.loveruby.net/archive/racc/racc-1.4.5-all.tar.gz, untar and follow instructions in README.

Gems

Add following to your config/environment.rb:

Rails::Initializer.run do |config|
  #...
  config.gem "locale"
  config.gem "grosser-gettext",
     :version => '2.0.0', :lib => 'gettext', :source => "http://gems.github.com"
  config.gem "grosser-fast_gettext",
     :version => '0.2.8', :lib => 'fast_gettext', :source => "http://gems.github.com"
end

and run

rake gems:install

If anything fails, try installing manually, i.e. with

sudo gem install ...

Warning: installing GetText 2.0 gem breaks earlier versions of GetText gem you might have installed. You can probably get the following to work with GetText 1.93, but I didn’t try it.

gettext_i18n_rails plugin

Install it with

script/plugin install git://github.com/grosser/gettext_i18n_rails.git

Configuring

Initialization

Create a new file config/initializers/fast_gettext.rb and put this in it:

FastGettext.add_text_domain 'app',
    :path => File.join(RAILS_ROOT, 'locale')

(or stick it at the end of config/environment.rb if you’re lazy).

RAILS_ROOT/locale is where GetText assumes to find its .po and .mo files and it’s better to leave it this way. The text domain name ('app' above) can be any other name — preferably the name of your project — but remember to change it in the following examples, too.

ApplicationController

Add this to your ApplicationController:

  include FastGettext::Translation
  before_filter :set_gettext_locale
protected
  def set_gettext_locale
    FastGettext.text_domain = 'app'
    FastGettext.available_locales = ['en','pl'] #all you want to allow
    super
  end

Line 1 makes all the GetText functions (the _, n_, N_ etc.) available to your controllers. Line 2 installs a filter to setup FastGettext for each request. Remember to edit the list of available locales in line 6. Finally, the super call in line sets the FastGettext.locale based on:

• params[:locale],
• session[:locale],
• cookies[:locale],
• request header HTTP_ACCEPT_LANGUAGE (in that order)

Once determined, locale is saved in session[:locale].

ApplicationHelper

In order to have GetText functions available in your helpers and views, add this to app/helpers/application_helper.rb:

  include FastGettext::Translation

TestHelper/SpecHelper

Add this to your test/test_helper.rb (or spec/spec_helper.rb) to make your tests/specs work:

FastGettext.text_domain = 'app'
FastGettext.available_locales = ['en','pl'] #all you want to allow

Haml support

GetText does not support Haml ‘out of the box’, so if you happen to use Haml, there’s one more thing to configure (otherwise you can skip this step). Create a new file lib/haml_parser.rb and put this in it:

require 'gettext/utils'
require 'gettext/tools/rgettext'

begin
  require "#{RAILS_ROOT}/vendor/plugins/haml/lib/haml"
rescue LoadError
  require 'haml'  # From gem
end

module HamlParser
  module_function

  def target?(file)
    File.extname(file) == '.haml'
  end

  def parse(file, ary = [])
    haml = Haml::Engine.new(IO.readlines(file).join)
    code = haml.precompiled.split(/$/)
    GetText::RubyParser.parse_lines(file, code, ary)
  end
end
GetText::RGetText.add_parser(HamlParser)

Now GetText is able to parse Haml, too!

Running

You’re finally ready to test if your configuration really works. Add something like:

<%= _('Hello World') %>

in any of your views. Then run:

rake gettext:find

If you get an error

Could not find RubyGem gettext (>= 2.0.0)

edit vendor/plugins/gettext_i18n_rails/tasks/gettext_rails_i18n.rake and comment out the line 3 that says

gem 'gettext', '>=2.0.0'

(you already have gettext gem, but it’s called grosser-gettext).

On successful run you should get a message that GetText created a template file locales/app.pot. Now create subdirectories in locales/ for each locale you want to support and copy this file into it, changing the extension to .po. So, for English and Polish, you would do:

$ mkdir en
$ cp app.pot en/app.po
$ mkdir pl
$ cp app.po pl/app.po

After that, edit the .po files and provide translations of your text in respective languages (I assume you’re familiar with .po file format). Then:

$ rake gettext:pack
locale/en/app.po -> locale/en/LC_MESSAGES/app.mo ... Done.
locale/pl/app.po -> locale/pl/LC_MESSAGES/app.mo ... Done.

As a side note, you might want to add locale/*/LC_MESSAGES/*.mo files to .gitignore or svn:ignore since they are generated by GetText but be sure to add any .po files you create to your code repository.

Now, restart your web server (changes in .mo files are not automatically reloaded) and navigate to the page where you used the _() function. You should see your text translated to your default locale. If your application does not yet feature any elegant way to switch locale, add ?locale=.. to URL and reload. Your text should now be translated to the new language.

That’s all, folks. Hope it works for you. If you find anything missing or incorrect, please let me know.

I tried to install PostgreSQL on Windows XP using “PostgreSQL One-Click Installer” and got a cryptic message box telling about “error.installing.runtimes”. Googling for this message yielded nothing helpful so I thought I’d post my solution of this problem. I checked Windows’ Event Log and under System tab found a failure event from Windows Scripting Host telling that, basically, I tried to run a script but the host is inactive.

Well, to tell the truth, I inactivated it myself, using the xp-antispy proggy. The solution is to run xp-antispy, find “Deactivate Scripting Host” under “Misceallaneous Settings” and turn it off (make it red). After that PostgreSQL installs without errors.

After installation you can deactivate Scripting Host again, it looks that it’s not needed once PostgreSQL is installed.

Small tip: when you happen to be running Rails in a console that doesn’t understand ANSI codes (those pesky ←[4;36;1m and ←[0;1m that clutter your display), like for example Windows’ cmd, you can turn them off with:

if RUBY_PLATFORM =~ /mswin32/
  ActiveRecord::Base.colorize_logging = false
end

Put this in config/environments/development.rb and restart script/server.

Took me a while to find it, so I thought I’d post it for posterity :)

Some time ago my boss told me that two of his colleagues are building their top secret, Next-Big-Thing site in Rails. They asked him if we (the company) could audit their code. This struck me as a really strange thing to do, given they are nowhere near launching their site. I told my boss: “Sure, we can audit their code, but do they really want to waste their money on this right now?”

Don’t get me wrong, I do care about code quality more than most programmers. I’m all for automated unit testing, high test coverage, using code metrics, profiling, automating builds with continuous integration and so on. We practice most of these things here at Jarorcon. And I would be more than happy to examine someone’s code and point the problems in it (and get paid for it).

Cost-benefit analysis

But still, when you do these things (like maintaining 100% test coverage) you have to take both costs and benefits into account. You can’t get fanatic about it. If it’s easy and enjoyable for you, great. But if you spend several hours struggling to get that one last line of your code tested, you’re probably overdoing it. Ask yourself what is the cost of those hours of your work (in terms of your employer’s money or in terms of lost opportunities if working for yourself)? Is having 100% test coverage going to benefit you more that it costs?

The definition of success

How do you define the success of the site you’re building? Is it great code quality? Is it 100% test coverage? I think it’s rather having many users that like the site or, even better, having many paying users. Do you think your users will appreciate the perfect quality of your code? I hate to say it but most of them couldn’t care less about it, as long as your site works reasonably fast and is reasonably stable. And if you’re motivated and competent enough, you’re going to make it.

Launch first, worry later

Launch first. Worry later. Make your code work. Make sure somebody is going to use it. Check if people like your idea. See whether you can get profitable from it. Then worry about auditing the quality of your code, optimizing its performance, beautifying the design, adding more features and so on. Why waste money on audits if you know that most startups fail? This is the same as premature optimization. First make it work, then optimize (for performance or quality).

Of course, if you’re a beginner, there are many things that you could (or even should) do. Learn as much as you can. Read documentation, blogs, forums, books. Experiment. Ask for advice. Try to solve real problems (like: your site comes to a grinding halt with five concurrent users). Fix errors and bugs. Look for security vulnerabilities. Practice TDD or BDD if you feel like it. Set up continuous integration and measure test coverage if you care about it. But don’t overdo it. Don’t prematurely optimize for quality. Remember: your success will not depend on the quality of your code alone.

And just one thing: audit sounds very enterprisey. It’s extremely funny when a two-person startup asks for an audit.

Welcome to the final part of my RailsConf Europe 2008 coverage. On the third day I attended Ruby and Rails Symposium: Versions, Implementations, and the Future, Genomes on Rails and Small Things, Loosely Joined and Written Fast. The keynote was a little bit disappointing, but the other talks were both inspiring, albeit in different ways.

Ruby and Rails Symposium: Versions, Implementations, and the Futures

David Black’s keynote, or a Symposimi, as he called it, started with a show of hands. David asked what version of Ruby are people using on their production site. Almost all of the audience raised hands for 1.8.6, I noticed only one guy using 1.8.7 and maybe two using 1.9.0. This is not that surprising as 1.9.0 is a “development release”, not intended to be run in production environments. It’s more interesting why 1.8.7 didn’t achieve more popularity. It’s supposed to be stable, backwards compatible, has many bugfixes and some new features backported from 1.9.0. There have been also many vulnerabilities discovered in Ruby, so everybody should recently have installed some new version and why not 1.8.7? But I digress.

Live coding session during David Black's keynote

David showed then some more prominent differences between 1.8.6 and 1.9 version in a live coding session. These included:

• differences in block parameters handling (1.9 doesn’t overwrite previously existing local variables when a block happens to have identically named parameters),
• new lambda syntax, i.e. the -> operator, which allows lambdas to have optional parameters as in func = ->(a,b=1){puts a + b},
• enumerators,
• new hash syntax: {a: 1, b: 2, c: 3} which is equivalent to {:a=>1, :b=>2, :c=>3}, i.e. creates a hash with symbols as keys.

This is hardly news for anybody not living under the rock for the last few months, there have been many announcements and blog posts on the upcoming features. I think it would be more interesting to hear something about Ruby 2.0.

Genomes on Rails

Matt Wood started with introducing the Wellcome Trust Sanger Institute, where he works. The institute was involved in Human Genome Project and is currently running many other scientific projects about genomes, DNA and other things that generally require massive computation on even more massive data.

Human genome took 15 years to decode and was comparable with decoding a 3 billion letters message. The project costs were about $3 billion. To date they have decoded genomes of 40 species. They are also trying to find cures for various diseases, from diabetes to malaria.

Rails is used to power the web pages that provide access to research results. Matt told us that most of the models consist of “virtual fields”, that is key-value pairs stored in separate table. This is not that hard and that slow as it may seem and has several advantages, like the ability to automatically generate the UI based on the database contents. Since they query large tables in their Rails apps, they use their own plugin called denormalizer.

Me, enjoying the desserts

At the end of the presentation somebody from the audience asked the question that I’m sure everybody wanted to ask: “Do you do any of those computations in Ruby?” “No.” Matt replied, “that would be crazy. The computations are done in C. Ruby (and Perl) are used to instrument the processes and for the web pages.” Be sure to check out Matt’s presentation.

Advanced RESTful Rails

This was the second talk by Ben Scofield that I have been to. I think it was very valuable for anyone doing RESTful applications in Rails. Ben started with showing some situations that might not be easy to handle RESTfully. These include singleton resources, namespaces, nesting, polymorphism and custom routes.

RESTful development consists of two steps: identifying resources and selecting methods to expose. Ben offered some tips for identifying resources. Firstly, when in doubt add a resource. It is better to have too many of them that too little. Secondly, respect the middleman. So, a many-to-many relation (like friendship) is almost certainly a resource, even if you don’t have a model for it. And lastly, resources are not identical with models. Most of the models are resources but not all resources have models.

In the next part, Ben showed some example solutions for things like password resets, homepages, previews (as in preview comment before posting), searching, wizards (multi-step actions), bulk actions (updating many resources at once) or transactions. Check out his presentation if you’re interested.

Small Things, Loosely Joined and Written Fast

This was one of most entertaining talks on the RailsConf. Justin Gehtland put on quite a show, with lost of running, waving hands and screaming (don’t be afraid, not Steve Ballmer style). He had also very funny slides with references to Star Wars. He compared big, complicated applications with the Death Star: they are heavy, costly, have too many responsibilities and easily break. Then he showed the Rebel Fleet – a chaotic cloud of small, cooperating ships playing different roles. Of course, some of them can get hit but it’s much more difficult to destroy the whole fleet than one ship, even as big as the Death Star. And it’s easy to replace the small ships with new ones.

Justin proceeded then to show us what this “Rebel Fleet approach” could look like in case of Rails applications. His example was a simple students portal with two functions: lectures enroller and dormitory picker. Those two functions were implemented as separate Rails apps, sharing as little as possible (students data and their preferences). Justin also set up a Single Sign-On server for them (a RubyCAS server) and a message queue (ActiveMQ) for communication between the apps. If this sounds to you as interesting and inspiring as to me, be sure to check out Justin’s blog entry with code from the talk and setup instructions.

It seems that I got too carried away writing about DHH keynote and forgot to mention other session I’ve been to that day. The first one was Hacking the Mid-End: Unobtrusive Scripting and Advanced UI Techniques in Rails, then Rails Software Metrics and Modeling Denormalization – The Speed You Need, the Order You Crave. I’m going to cover each one below.

Hacking the Mid-End

In Hacking the Mid-End: Unobtrusive Scripting and Advanced UI Techniques in Rails Michael Bleigh argued that there is a growing area between back-end (which is Model & Controller layers in MVC) and front-end (which is View) that he calls Mid-End. In most Web 2.0 applications, the architecture is really something like MVC+I, where I is for Interaction. This area contains all the non-trivial code in the presentation layer that usually can’t be done by HTML/CSS designers. This includes various AJAX calls, progress bars, fancy file uploaders, drag’n'drop support and so on.

RailsConf message board

Michael said that Mid-End developer facilitates cooperation between front-end and back-end, providing helpers and tools for the front-end designer and building on a structures provided by back-end developers. Mid-end developers goals are to make the application Fast, Accessible, Intuitive, and Responsive. Then he showed two examples of what he understands by that. The first was about making some slow action more responsive. In the original version after clicking the link the user had to wait about 10 seconds before the resulting page loaded.

Michael’s recipe was to make the link take the user to another page that displayed a warning that you might have to wait a little bit for the results. The page loaded the results in background using AJAX call and then displayed them. For the sake of accessibility, if JavaScript was unavailable, the page presented a link to ‘Continue’.

The second example was about making simple dynamic tabs. When user has JS enabled only one of the tabs is visible and clicking a tab header switches the visible part. With no JS all the information is displayed as a list of sections with headlines and clicking a tab header jumps to the appropriate section.

Be sure to check out Michael’s presentation if you’re interested in mid-end and UJS (Unobtrusive JavaScript).

Rails Software Metrics

Next session was Rails Software Metrics, presented by Roderick von Domburg. Roderick started with saying that he talks only about tools, not some prescribed best practices. The first tool he covered was, quite surprisingly, rake stats. The results provided by this tool are not very interesting as such, but the key here is that you should graph them over time to make them much more useful.

Roderick showed graphs of lines of code, test-to-code ratio, average methods and lines per class or average lines per methods, all provided by rake stats. Combining the graphs of these metrics may tell you many useful things about your code (you are testing too little or too much, your methods are too long) without installing any other tools.

The next tool covered was flog, which measures code complexity. Flog works in a “decidedly unscientific” way, assigning arbitrarily chosen values to various constructs (6 points per eval, 1.2 point per if) and reporting totals and averages for your classes and methods. And again, while results of running flog once are useful (you can see whether there are methods that require immediate refactoring), it becomes really cool when graphed over time. You can observe negative tendencies and take countermeasures when appropriate.

One of the registration hostesses with the RailsConf Europe T-Shirt

Rcov was next but since we use it in all our projects, there was nothing new for me. I’m always surprised when people say (like Roderick did) that it’s really hard to get 100% code coverage (I sometimes suspect they didn’t really try it, they just think it’s too hard) and you really shouldn’t try too hard because it’s not worth it and 100% code coverage doesn’t prove anything anyway. They say that with 100% code coverage you test many trivial pieces of code that are not worth it anyway while many other non-trivial pieces are covered only accidentally.

This is mostly true except for the “it’s too hard” part. My team uses TDD methodology and we have no problems with achieving 100% code coverage. We don’t find it too hard or too wasteful either. Oh, and by the way, it’s much easier to keep coverage at 100% if you have 100% from the start.

Roderick then covered briefly heckle, which mutates your code and checks if tests fail. Heckle is still in experimental phase and it’s not something you would want to run on every build but it’s fun to play with, nonetheless. The next tool was saikuro, which is a cyclomatic complexity analyzer. It’s similar to flog but has a more scientific approach. It also generates nice HTML reports similar to rcov’s, so you can inspect any code that generates warnings.

The last tool covered was metric_fu, a plugin (or set of rake tasks to be precise) for CruiseControl.rb that runs all or selected metrics on your projects. I’m definitely going to have a look at it.

Modeling Denormalization

In Modeling Denormalization – The Speed You Need, the Order You Crave Duncan Beevers from Kongregate talked about how to use denormalization techniques to make your data retrievable faster. Denormalization means duplicating data from one model to another and storing the results of each calculation in the database once you calculate it. This technique is present in Rails in form of counter caches.

If your application is write-heavy, you should not go overboard with adding index. Each index slows down writes. Another advice was that real tables with calculated data are better than triggers and views. The problem with triggers is that one update can fire several triggers and you don’t have control about it. It becomes a real issue when you have 20,000 users updating their statistics each second (if I remember the number Duncan gave right). In this case batch processing is much better.

Duncan’s presentation had a little unexpected ending because he fainted after showing the last slide. Some people from the first rows helped him up and gave him a glass of water and he was OK in a minute. That accident awarded him much more cheerful reception from the audience.

I don’t know if this is of any interest to you, but most of this article was written while traveling back from Berlin to Wrocław after the conference. Ah, the joys of modern technology.

The second day of RailsConf Europe 2008 started with David Heinemeier Hansson’s keynote on legacy software and was by far the most interesting and enlightening of the talks that I attended yesterday. DHH was mainly talking about legacy but I think the main message he was trying to get through was that a programmer should never stop learning, and I totally agree with that. I really regret I haven’t written about this before because now it will look like another DHH fanboy desperately trying to get to the me-too camp. Nonetheless, a couple of my own thoughts first and then on with the show.

What do you feel when you look at the code you wrote 3 years ago? 6 months ago? A month ago? Do you feel the need to throw up? Do you think to yourself: “What a mess! Who wrote it?” If yes, there’s no need to be ashamed. You should be proud of yourself, because that reaction shows that you have grown up, that you have learned, that you now see there are problems with your code you haven’t seen 6 months ago. This means that the code you write now is much better. And, hopefully, 6 months from now you will look at the code you wrote today and have the same reaction of disgust.

A really funny thing happened to me not too long ago. While I was browsing the codebase of one of our projects, I noticed a truly awful piece of code. A nightmare from hell. A couple of lines screaming REFACTOR ME NOW (which I did immediately) at the top of their lungs. After refactoring I wrote an email to our team showing the original code, explaining what was wrong with it and asking to never do it again. I made it clear that I wasn’t blaming anyone, I only wanted to educate them. After sending the email I decided to run svn blame to see who did that. I kept telling myself I only did it so I can maybe help or educate the poor guy, but the real cause of anxiety probably was “who is such a stupid loser?” So I ran svn blame and you know who was it? Me. 4 months ago.

A scientific legacy diagram

OK, back to RailsConf keynote. DHH started with asking: what is legacy software? Then came several definitions: Legacy is not a specific technology (DHH quotes italicized), which means you write legacy software in any technology, including Ruby on Rails. Legacy is a function of you (your perception, tastes, knowledge) over time, so the same code may be legacy to some people but perfectly good for other. In short legacy is “an old stuff we don’t like”.

DHH showed next a hand-sketched diagram of how a feeling of legacy rises in him in every project he works on and I think most of us can relate. When you start a new project, you feel you write best code ever but as time passes you evolve to this sucks feeling and then to I can’t take it any more. Eventually you think the best option would be to rewrite it from scratch. Is the code at fault? Does it really rot just by itself? No. The code doesn’t really change, your perception changes. Which is good, because Legacy shows you that you have grown.

What you write today will become legacy

If you want to develop your skills and feel happy about yourself at the same time, you must acknowledge and embrace that What you write today will become legacy. It’s even worse when you’re starting to learn some new technology, because When you’re green, everything turns legacy over night. You learn so much every day that it kind of obsoletes what you wrote yesterday. This may be a problem to some people but There’s no other way. What to do when it bothers you? Just try to get over it and remember: you will not be a noob for ever.

'The name GlobalController is almost as good as ApplicationHelper' - DHH

DHH switched then to an editor and showed us some old code he wrote for Basecamp. He talked about what was wrong with that and what would he do now to refactor it. A big chapeaux-bas for courage and honesty. Then he came back to the presentation and talked a little bit what to do when you happen to work with a project you feel is a legacy. He mentioned that Broken Window Syndrome from Pragmatic Programmer may be a little devious here, because you may not be able to “fix” all the problems with legacy software at once. Instead you should try to fix and refactor problems one by one, while developing new features etc.

One of the opinions that I sometimes semi-jokingly quote is that “every software project constantly gravitates towards a point where complete rewrite is necessary”. And yet, as DHH quotes Joel Spolsky, “the single worst strategic mistake a software company can make: rewrite the code from scratch.” I agree with both statements. So, what to do? Embrace!

Panel discussion with DHH and Rails Core Team members

The first day was a registration and tutorial day. The registration went smoothly, there was no gigantic queue that people waited in for half an hour like last year. My feeling is that there is less people this year but probably the organization is also better. Read on for a relation on the tutorials I attended and evening’s panel discussion.

The first tutorial, Better Living Through Resourceful Plugins was very interesting. Ben Scofield talked about how to solve one of the biggest pains with Rails development (at least in my experience): problems with reusing bigger chunks of functionality. Ben’s solution is to use “Resourceful Plugins” which basically are ordinary plugins with some clever generators and included modules. This way we can have all the layers in the plugin (the models, controllers and views) and still be able to customize them in the app. You can take a look at Ben’s example resourceful plugin Bloget. This technique will certainly make my life easier.

The second tutorial was even more interesting. In the brillant and witty Meta-programming Ruby for Fun & Profit Neal Ford talked about programmable programs, humane interfaces, using method_missing and const_missing (the latter for a dynamic class factory), implementing various design patterns and aspect orientation (which is easy to achieve with meta-programming) or how to mimic features from other languages that are not available in Ruby (like Java’s final keyword to prevent extending a class). Be sure to check Neal’s presentation for funny and clever, Matrix inspired slides.

I was also very glad to notice that Neal used an example of generating test methods in a loop that was very similar in idea to my old Looping in a no man’s land post.

In the second part of the tutorial, Pat Farley took over and dug into gory details of Ruby implementation that are important when using meta-programming techniques. This part was much more difficult and not that attractive as Neal’s part, but also interesting. Pat showed many fragments of Ruby’s implementation C source, each time preceding them with a slide with a woman bleeding from her eyes. My favorite quote from Pat’s talk: the superclass of a metaclass is the metaclass of the superclass.

David Heinemeier Hansson, Jeremy Kemper and Michael Koziarski

The day ended with a panel discussion featuring David Heinemeier Hansson, Michael Koziarski and Jeremy Kemper. I was a little bit disappointed, because it mostly consisted of chaotic and superficial answers to unrelated questions from the audience. There were some interesting thoughts but I expected a little bit more from a “panel discussion”.

Thanks to my employer Jarorcon, I will be attending RailsConf Europe 2008 in Berlin, Germany. Hopefully it will be at least as good as last year. I also hope to get some more t-shirts than last year (only one).

I’m especially looking forward to attending the tutorials: Better Living Through Resourceful Plugins and Meta-programming Ruby for Fun & Profit. The Object Databases with Ruby on Rails and Extending Ruby with Class talks also look very interesting. There is of course plenty of other interesting talks but I’m still undecided which ones to attend.

I will be also present at Bratwurst on Rails for some serious beer quaffing. I hope the wurst will be better than last time. Don’t hesitate to come up and chat with me if you want.

This is a quick followup to my breadcrumb solution. If your application is internationalized, I think you might be interested in the code presented below. If not, stick with the original version.

Without further ado, here’s how to make breadcrumbs work nicely with Ruby-GetText:

class ApplicationController < ActionController::Base
  ...
protected
  def add_breadcrumb_without_translation name, path = ''
    @breadcrumbs ||= []
    path = eval(path) if path =~ /_path|_url|@/
    @breadcrumbs << [name, path]
  end

  def add_breadcrumb name, path = ''
    add_breadcrumb_without_translation _(name), path
  end

  def self.add_breadcrumb name, path, options = {}
    before_filter options do |controller|
      controller.send(:add_breadcrumb, name, path)
    end
  end
end

As we can see, there are three methods now. We have the add_breadcrumb_without_translation method in case we wanted to add something like @category.name to the breadcrumb trail. The other method, add_breadcrumb uses GetText’s _() function to translate the name parameter. The third method, which defines a filter, is same as before.

And here’s how you would use it:

class ApplicationController < ActionController::Base
  add_breadcrumb N_('Home'), '/'
  ...
end
class ThingsController < ApplicationController
  add_breadcrumb N_('Things'), 'things_path'
  add_breadcrumb N_('Create a new thing'), '', :only => [:new, :create]
  add_breadcrumb N_('Edit a thing'), '', :only => [:edit, :update]

  def show
    @thing = Thing.find(params[:id])
    add_breadcrumb_without_translation @thing.name, ''
  end
  ...
end

Caveat: this works with GetText only. If you want to use any other I18N framework, you need to replace GetText’s _() and N_() functions with your framework’s equivalents. The _('string') function provides the translation of given string in current locale, while the N_('string') just declares to GetText that the string is one of the translation keys, but it should not be translated right here. This is required when breadcrumbs are defined at the top of the controller class, because this code is interpreted while the class is being loaded, but we need the translation to occur for each processed request with appropriate locale.

As far as I know, Globalize’s equivalent for _('string') is 'string'.t, but I have no idea how to replace N_(). I’d appreciate any comments from people using Globalize and other frameworks on how to make this work with those frameworks.

Being a long time Monty Python fan, I couldn’t resist to share these hilarious mid-80’s Compaq commercials with John Cleese.

I Wouldn’t Watch This Commercial

…made from 386 chips and 32 bits of a bus!

How To Spell Compaq

Computers Often Make People Quite Angry!

Portable 2 Compared to This Fish

The fish weighs 22 pounds, which makes it extremely portable… (can anyone tell me what joke John Cleese says at about 0:50, before bursting in hysterical laughter?)

BORING!

That Trendy Computer

My horoscope advises against travel!

The Finger Trick

Instead, I’m going to take off top two joints of my index finger.

I’ve Got A Reputation!

Intro to Ads

…but Cheese will do.

Does It Have A Handle?

WE Have Bruno

Forget All Our Earlier Commercials

One Million Pound Ransom!

Via Dark Roasted Blend.

Most projects I work on require some implementation of breadcrumbs. Unfortunately most solutions that I found take the very simplistic approach: they split the URL and present each part as a link. I really have a hard time imagining that this can be sufficient for any non-trivial app.

I also found session-based implementation, but according to the above mentioned Wikipedia article classification these are path-style breadcrumbs, while I need location-style with a little bit of attribute-style mixed in where needed. That is, the breadcrumbs should normally reflect the page’s location in some (virtual) website hierarchy. Sometimes, while browsing things that are naturally hierarchical (like forum threads/posts, category trees and so on), the breadcrumb trail should also reflect this hierarchy. Read on to see my take on this problem.

The requirements

First, let’s formulate the requirements for the breadcrumbs solution.

1. It should be a list of links with descriptions, except for the last element, which should not be clickable because it represents current page.
2. It should have syntax that is easy to use, ideally something like: add_breadcrumb 'Description', some_path
3. It should allow us to add arbitrary number of elements, both statically and dynamically.
4. The static parts should be similar to filters:
   1. declared at one place (e.g. at the top of the controller) not littered around actions or views,
   2. inheritable (so you can declare home link only once, in your ApplicationController),
   3. with easily recognizable order,
   4. and support for filter options like :only or :except.
5. The dynamic parts can be added at any time during the request processing, from actions, filters of views, if necessary.

Looks like a lot of hard work? Maybe. But my priority was flexibility and ease of use, not necessarily ease of implementation. I want to be able to do things like this:

Simple example

class ApplicationController < ActionController::Base
  add_breadcrumb 'Home', '/'
  ...
end
class ThingsController < ApplicationController
  add_breadcrumb 'Things', 'things_path'
  add_breadcrumb 'Create a new thing', '', :only => [:new, :create]
  add_breadcrumb 'Edit a thing', '', :only => [:edit, :update]

  def show
    @thing = Thing.find(params[:id])
    add_breadcrumb @thing.name, ''
  end
  ...
end

With this setup, we get breadcrumbs like Home > Things for things index, Home > Things > Create a new thing for new thing or Home > Things > some name for show action.

Notes

• We need to quote *_path and *_url (like this: 'things_path') when outside of actions due to the way these methods are implemented in Rails. I stretched requirement #2 here but I think this is really only a minor inconvenience. When you forget to do this, you’ll get an undefined method error. The quoted string will be eval-ed when the request is processed, which is of course not the cleanest solution, but works for me.
• When the added element is guaranteed to be the last, we don’t have to provide the URL for it.
• Although it may seem that :new is sufficient for the new thing form, we need to add :create to have the breadcrumb defined when the validation fails and the form is redisplayed (same for :edit and :update, respectively). This may look like a redundancy but that’s how Rails works. Alternatively you can add the breadcrumb from the new.html.erb template or inside the :create action. But I prefer to have them declared in one place if only possible.
• If you use add_breadcrumb in your ApplicationController, you must do it after the methods are defined (it should be under those methods).

Dynamic example

Now for something a little bit more dynamic, let’s assume we have a hierarchy of categories and while browsing a category we want the breadcrumb to show all the ancestor categories:

class CategoriesController < ApplicationController
  add_breadcrumb 'Categories', 'categories_path'

  def show
    @category = Category.find(params[:id])
    set_breadcrumb_for @category
  end
  ...
private
  def set_breadcrumb_for cat
    set_breadcrumb_for cat.parent if cat.parent
    add_breadcrumb cat.name, "category_path(#{cat.id})"
  end
end

This lets us have breadcrumbs like Home > Categories > Root > Parent > Child for tree-like category hierarchies. The set_breadcrumb_for method traverses all the parents of the category recursively until it finds the root category. I agree that the "category_path(#{cat.id})" part looks a little bit messy, but I couldn’t find any cleaner way to do this with the eval solution I mentioned above. Any suggestions welcome.

The implementation

Now for the implementation. It’s really quite trivial for the above defined set of the requirements. Just drop these two methods in your ApplicationController:

class ApplicationController < ActionController::Base
  ...
protected
  def add_breadcrumb name, url = ''
    @breadcrumbs ||= []
    url = eval(url) if url =~ /_path|_url|@/
    @breadcrumbs << [name, url]
  end

  def self.add_breadcrumb name, url, options = {}
    before_filter options do |controller|
      controller.send(:add_breadcrumb, name, url)
    end
  end
end

We need two versions of add_breadcrumb method. The first one (which is an instance method) is responsible for constructing the actual breadcrumb list. It is called several times during request processing. As we can see @breadcrumbs is just a list of two element lists, containing description and a URL.

The second version is a class method that we can use in declarations at the top of our controllers. It just defines an unnamed before_filter which, when called, uses the first version to add breadcrumb element. This way we get all the goodies (:only, :except, ordering) for free.

How to display the breadcrumbs? Put something like below to your layout and add HTML tags and styles as needed.

<% if @breadcrumbs %>
  You are here:
  <% @breadcrumbs[0..-2].each do |txt, path| %>
    <%= link_to(h(txt), path) %> >
  <% end %>
  <%= h(@breadcrumbs.last.first) %>
<% end %>

And that’s it. I hope it works for you. Any suggestions and improvements welcome.

UPDATE: I just posted a followup about how to make breadcrumbs work in an internationalized application.

UPDATE #2: you can have problems with using add_breadcrumb in your ApplicationController, as noted by Vinay in the comments below. See notes above how to fix this.

Duplication of code is one of the worst code smells. It should be refactored in order to keep DRY if only possible. This is generally easy. But what if the code itself is not duplicated, but its structure is? That could be a little bit more difficult, but with Ruby’s metaprogamming facilities it’s not that hard. Read on to see how.

The problem

In our project, we have a module called Factory that produces object needed by tests. It generally contains pairs of methods, new_something and create_something, like this:

module Factory
  def self.new_user options={}
    User.new({
      # some default values
    }.merge(options))
  end

  def self.create_user options
    u = new_user options
    u.save!
    u
  end

  def self.new_role options={}
    Role.new({
      # some default values
    }.merge(options))
  end

  def self.create_role options
    r = new_role options
    r.save!
    r
  end

  def self.new_permission options={}
    Permission.new({
      # some default values
    }.merge(options))
  end

  def self.create_permission options
    p = new_permission options
    p.save!
    p
  end

  def self.new_group options={}
    Group.new({
      # some default values
    }.merge(options))
  end

  def self.create_group options
    g = new_group options
    g.save!
    g
  end
  # ...snip...
end

Basically, the new_something methods merge provided and default options and return new, unsaved objects. In place of “some default values” there is always a list of attribute values that are needed for an object to pass validation (like login and password for user). This list is of course different for each type.

Notice the pattern with create_something methods?¹ Yes, they always do the same thing: call the paired new_something method, save the object and return it (although the type of the object is different). How to refactor this pattern and remove the duplication? There are several ways to do it. Let’s look at one of them.

The solution

My proposed solution is not to write the create_something methods at all. Instead, provide a method_missing implementation that will take care of creating objects. Like this:

module Factory
  def self.method_missing name, *args
    if name.to_s =~ /^create_(.+)/
      obj = self.send("new_#{$1}", *args)
      obj.save!
      obj
    end
  end

  # ...snip...
end

Now, if we intercept a call to create_something, we extract the ’something’ with a regular expression and call the appropriate new_something method, passing all the arguments just as the original methods did. Then the object is saved and returned, as before. This part is 3 lines of code, but we can make it one line:

module Factory
  def self.method_missing name, *args
    if name.to_s =~ /^create_(.+)/
      returning(self.send("new_#{$1}", *args)) { |o| o.save! }
    end
  end

  # ...snip...
end

Or, if we (ab)use the Symbol#to_proc idiom (and forsake a little bit of readability), we can shorten it further to:

module Factory
  def self.method_missing name, *args
    if name.to_s =~ /^create_(.+)/
      returning self.send("new_#{$1}", *args), &:save!
    end
  end

  # ...snip...
end

What if one of the create_something methods differs from the pattern? E.g. create_user method might need to assign the created user to a role in order to let it login into the application. That’s no problem at all. Just write your create_user method as before and let it do all you need it to do. The method_missing method will not be called when create_user is not missing. The general rule is: method_missing handles the typical cases and create_something methods are necessary only when something extra is needed.

¹ There is also a pattern in the new_something methods, of course, but eliminating it is left as an exercise for the reader (and you still have to provide the default values somewhere).

Here’s a small TextMate tip I discovered today. Normally, some TextMate functions don’t work too well with Ruby code. Word selection and keyword completion ignore Ruby-specific characters like : or ? or !. For example, if you used somewhere method like blank? and then you type bl and press Esc, TextMate will complete it as blank, ignoring the ? at the end. And don’t even get me started about when you double click blank? and the ? is not selected.

To change it, go to the Preferences (CMD-,) and select Text Editing tab. At the bottom, there’s an editbox labeled Word characters containing a single _ by default. Add characters :?! to this editbox, close the window and you’re done. Enjoy!

There’s one caveat, however. This setting is global and affects word selection and keyword completion in all files. If you edit many other types of files, that could be a problem.

So, you’re young and you’re a programmer. Maybe even a successful one. You have a cool job: the salary is good, the tasks are challenging and your coworkers are both intelligent and funny. Perhaps you’re not “just” a programmer, maybe your job title is something like “developer/designer” or “leading programmer”. I bet your parents are proud of you and most of your non-geek friends envy you. You have probably already created something you’re proud of: some cool app or a web framework. But…

Have you ever thought who do you want to be when you’re 35 years old? When you’re 50? Are you sure you’d still be passionate about churning code and keeping up with latest technologies when you’re 50 or older? Think about it: how many programmers do you know that are a) younger than 30, b) older than 40? I’m certain “a” is much larger than “b”. Have you ever thought why is it so? Is there something about programming that makes most people grow out of it?

Maybe programming is too exhaustive and people grow weary of it and burn themselves out after 10 or more years? Maybe you loose the ability to create and manipulate large abstract structures in your mind when you grow older? Maybe it’s the need to constantly learn? What if there’s a point beyond which you’re simply not able to learn any new language or technology?

Maybe it’s just, paradoxically, the boredom? When you think about it, most developers spend big part of their time doing tedious, repeatable tasks (and I’m not talking here about Java developers only). Or maybe our profession is so young that people born too early simply missed the opportunity to become programmers? (I would like to read some research on this topic but couldn’t find any.)

Whatever it is, most programmers seem to leave programming and switch to other activities somewhere between 35 and 40. I’m 34 and I still have enough passion for programming to sustain next couple of years, but then what? If you’re someone like the person described in first paragraph, perhaps you should sometimes think about next step of your career? What can you do to make it as pleasant and satisfying as your current job? Let’s iterate through some options:

Management

Quite popular “career path”, especially in bigger companies. You could be promoted to “team leader”, then to “director of I.T. department” or even CTO. It all depends how many levels of hierarchy are currently above you. Another direction, if your company prefers some kind of matrix management, is becoming a PM (Project Manager), but I’m not sure if many programmers would consider that a promotion.

However, most programmers lack the skills that a good manager should posses, especially interpersonal skills (some people think that “programmer” and “sociopath” are synonymous). On the other hand, it’s easier to become pals with an ex-programmer and such a manager will have better understanding of your difficulties.

Start your own business

A manager and a programmer, all in one. There is plenty of information how to start a start-up. And founding a successful start-up that is later bought for big bucks is a new version of American dream. The biggest downside of this is that most start-ups fail.

Consulting

Not really esteemed profession. In theory, consultants are experienced developers that help other companies in case of trouble with their software. In practice, consulting often means just parachuting some suicidal commando programmers in attempt to rescue a sinking project. Most of the time, to miserable effect. And the phrase “code written by consultants” has become a synonym for WTF.

A security (encryption, SEO, …) expert

A much better esteemed version of consulting. If you are really an expert in some field of IT, you could earn a nice income by freelance consulting or working for some big company. See also next one.

Write books, speak at conferences

Really nice and easy job (or so I heard), but only if you have something to say. Having a widely recognized name helps, too. If you’re an author of popular application, framework or library, good for you. At the very least, write a popular blog.

Translator

As most of the world’s IT literature is written in English, this is only applicable in non-English speaking countries. But this is quite an easy job (been there, done that), and you don’t have to have anything to say, unlike the previous one.

Architect

Mostly present only at enterprise class systems development. A man with a vision, projecting the architecture, choosing technologies, planning the overall technical structure, writing the code conventions and similar important documents that make you totally enterprisey. A PITA in general, especially if not participating in everyday code development.

Business analyst

If you have no problems with talking to business people (not very common among programmers), grok UML and like to “write programs in English”, you could go for business analyst.

Tester, sysadmin, deployment specialist

These people normally coexist with programmers, especially in bigger companies. But I haven’t heard of any programmers becoming one of them, while they quite often become programmers.

Scientist

If you’re theoretically inclined and grok things like Big-O notation or NP completeness, that could be a fulfilling job for you. Computer science is still young and there’s probably still much to be discovered.

Full switch

You can quit programming and start doing something completely different. It’s up to you. I’ve read that nowadays people should be prepared to change their profession several times in their lifetime. Who knows, maybe programming will be obsolete in 10 or 20 years from now?

Welcome to the followup of my Tales from the WTF company. If you haven’t read the first part yet, I’d suggest you do. Otherwise you’ll miss important background info and a really funny story, too. This part starts where the last part ended, around noon of the second day.

Let me introduce you to our manager: Jola (name changed), a woman in her late thirties with no technical or managing education. She was earlier providing HR and legal services for the company, but shortly before I started work there she was asked by Johann (name changed), our German CEO, to become the manager.

I guess that Jola was brought to the company because the CEO was not satisfied with the achievements of his Polish branch: their application was slow, massive, bug-ridden and adding new features took ages (he told me about this on the recruitment interview). He also told me that he was looking for a more experienced developer to mend their ways and that was going to be my role after employment.

Tuesday

Around noon of the second day Jola called my team to a meeting. She told us that she received a phone call from Johann and he expected our team to do following tasks ASAP: make changes to the layout of some email sent by the application and make some report (that was already done) accessible from their webpage. The guys had some questions about the details of those tasks but she couldn’t answer them. Instead, she noted the questions word for word and said she was going to call Johann to ask him and then she would give us the answers.

After the meeting we went back to our normal activities: I resumed browsing the project source and they resumed chatting about movies on TV, watching game trailers and funny flics on youtube.com, showing me the webpage selling some paintball guns they bought recently and other fun activities. I wondered when they were going to start working on the tasks they were given, but I figured that those tasks was probably so easy they can do them anytime. At the end of that day I asked my mentor if he could give some task so I could help them finish faster and he said he would look for something appropriate.

Wednesday

Next morning I was assigned my first task: check to see if a particular utility class could be made faster. This class was another piece of classic WTF-ery. Its main purpose was to parse XML file the hard way, because who needs any stinking built-in Python classes when you can use regexps and individual character manipulations? After parsing the contents of XML file were stuffed into nested instances of this class that exposed a dictionary-like interface.

I started by making a suite of characterization tests first as not to break anything unintentionally. This was the first time that any tests were created for their system so it took me a while setting them up. I asked them why there were no tests and their answer was: tests are a waste of time. When I started arguing (being a TDD fan myself), my mentor just cut short the discussion with: when Johann calls you and starts yelling at you, you won’t have time to write those stupid tests.

The yelling part left me with no further arguments and I really started wondering what a mess I have gotten myself into (it was only my third day of work at this company). I resumed my work and by the end of the day I managed to make retrieving values from the above mentioned XML parsing class about 20 times faster on average. It was really easy, though, because this class stored the data internally in a dictionary but the lookups on it were done by sequentially iterating through all the keys to find matching one. All I did was replacing the iteration with normal dictionary lookup.

The guys said that the iteration was probably necessary for something in the past, but they could not recall what could it be. They figured that the cause was probably gone, since the system still worked fine after my changes. I was told I should commit my work to the SVN, but not the tests, because they “didn’t want them to clutter their repository”.

Thursday

Next day I asked my mentor if I could replace the regexp based XML-parsing with some standard classes to make it cleaner and easier to extend. He said no, because their parsing works just fine, thank you. It just “does what it’s intended to and there’s no need to extend it” (although the code was literally ridden with special cases, multi-storey ifs, workarounds and bugfixes that proved it was changed and extended many times already). He also stated that their solution was surely faster than any library could be, because “it did only what was needed and any library always does many unnecessary things”. I was told that he would find me another task and I was to leave that XML parsing alone.

Before he could find anything, Jola rushed into our office. She was very angry and told us (almost shouting) that she just had a very unpleasant phone talk with Johann and he demanded that the task he gave us on Tuesday be done today or else. Because of that she wanted us all to work today as long as it’s needed to finish those tasks, even if it takes us whole evening or night. I was quite shocked by this kind of management but other guys seemed used to it. They told her that they’d had some difficulties but now they were nearing the finish and there’s nothing to worry about.

After she left, I saw them working probably for the first time in four days. Of course, they were still doing many things unrelated to work, but at least they were trying to make some progress. I asked my mentor if he could give me something to work on so I can help them finish faster, but he told me that they have already divided the work and it’s too small to be divided further (which seemed to be true because the tasks Johann gave us looked really easy). He said that since he was too busy with his work to find me another task I should just browse the code and try to learn what it does.

At 17:00 I asked them again if I could help them anyhow, but they told me they were almost finished, just fixing some minor bugs. I decided to go home then, because it made no sense to me to sit there and just wait for them to finish.

Friday

Next morning Jola asked me to come to her office. I was expecting some kind of reprimand for not staying at work with the other guys (they stayed until about 20:00 that day) and tried to prepare some explanations. She gave me a talk about how they, being a small startup, should be working twice as hard as the bigger companies and then she said that she had to fire me and had my walking papers ready.

After first shock I tried to explain to her why I left earlier and that it’s too harsh to fire somebody for something like that, but then it struck me: I didn’t want to work there anymore. So I just said: “I see that you have already made your decision, so there is no use in arguing”, grabbed my things and left.

Some time ago I had a short episode of working for a Polish branch of a Germany based software company. In this entry (and probably a few following) I’m going to share with you a couple of WTF moments, so if you’re in for a few good laughs, read on! There is also part II of this story.

Monday

The first day started quite normal: I was introduced by the company manager to all 7 programmers, divided in two teams. I was assigned to the smaller, 3 people team. My first task was to build a computer for myself from parts scattered around the company: the box was here, the harddisk there and the monitor had to be taken “temporarily” from one of the servers.

After my computer was up and running, my teammates engaged in a fierce quarrel about which distribution of Linux I should install on my box. As I learned each of them was running a different one and in the second team the situation was looking similar. I chose Ubuntu because the guy sitting next to me (who was assigned as my “mentor”) was using it and he had the install CD ready.

Then the other guys started to remind him that he had several problems with this distribution (some related to work and some completely unrelated but that seemed irrelevant to them) and he fought back arguing that they had also trouble with their distros and it was at least as bad as his own if not worse. From this argument I understood that they had continuous problems with running their app on their systems (as in “it works on my box, why doesn’t it work on yours?”) and spent quite a lot of time trying to fix them. It also seemed that each of them used their own set of incompatible tools and scripts which they developed or configured individually.

Don’t get me wrong: I’m not trying to prove that they were completely stupid. It was just the opposite: they were smart, friendly, helpful and fun to talk with. We spend a lot of time talking about their hobbies, cars, games, movies, music and books. But at the same time I started to get a feeling that they were completely amateurish in their work.

To the end of first day I managed to get Ubuntu running, installed Eclipse and some other tools and checked out the project from the SVN. In the meantime, my mentor gave me a talk about the architecture of their system which seemed awfully complicated to me but I decided to keep my comments to myself at least until I get to see and understand the code. The system was written in Python and its main purpose was to process requests from the web app and issue queries to many different vendors, gather the results and send them back to the web app. He also told me that they had a big problem with the system being much too heavy and slow.

Tuesday

Next day I started browsing the source and felt my heart sinking like, well, something that is sinking really fast. So fast it’s going to fall into pieces when it smacks into the bottom of the sea. I hoped that their system would be elegant and beautiful just because of being written in Python. Instead it looked like if someone was trying create Python’s equivalent of worst PHP anti-patterns. Most of the classes were several thousand lines long and contained code dealing with everything for one vendor. Each of those behemoths sported methods of at least 200 lines long but 500 wasn’t rare at all.

After taking a closer look I noticed that most of the code was carefully copied/pasted from one place to another. Each of those methods processed one kind of request from start to end: initialized database connection with hardcoded username and password, constructed and issued the query, processed and formatted the results, caught exceptions and so on. I regret not running any metrics on this steaming pile of excrements but my guess was that after the duplicated code would be properly refactored into separate methods, it would be 3 to 4 times smaller. Do I have to add that the system wasn’t stained with a single line of test code?

I started asking the guys about those problems and their answers shocked me even more. The conversation ran something like this:

Me: Why don’t you guys use separate functions to avoid all this code duplication?

Them: Don’t you know that functions induce time overhead? Calling them and returning just takes too much time.

Me: AFAIK this overhead is negligible in most cases. Have you run some profiler to see if calling functions is really a bottleneck here?

Them: Of course we have. But you see this Python profiler is really stupid. It didn’t tell us anything useful.

I had a hard time believing this but not being an expert in Python profiling myself I decided to leave this path for now and concentrate on other aspects:

Me: But don’t you think that this copied/pasted code looks like a mess?

Them: Not at all. You have all the code right before your eyes. You don’t have to go looking for a function definition to see what it does.

Me: What if the duplicated code contained some bug? Don’t you think fixing it would be a problem?

Them: How can this be a problem when Eclipse has search&replace function?

That’s it for part one, but stay tuned! There is part II of this story.

There is plenty of stuff written about caching in Ruby on Rails. You can easily cache anything from objects returned by a query to fragments or even whole pages. Especially storing full pages (known as page caching) in a directory when Apache¹ can grab them is really efficient. And there are quite decent tutorials about it.

Sadly, most of the tutorials assume that you live in a small, cozy, speak-english-or-die type of world and your only contact with foreign languages is when you order “pommes frites” at MacDonald’s.² The rest of us, working on multilingual applications, might have a lot of problems with implementing page caching. Fortunately, it’s not that difficult. Read on to see for yourself.

The problem

The main problem is that default Rails caching mechanism tries to map page URL directly to a path on the disk. This works in most of the cases, of course, and the rewrite rules in Apache configuration are simple. But if your application might provide different content for the same URL, depending on other data (like session settings), you’re in trouble.

There are many things normally stored in session that can alter what you see on a given page, even if at first glance you might think that the page content is fairly static. Things like whether you are logged in or not, what is your role in the application (admin/regular user), what language you prefer to see the page in and so on.

Tutorials on Rails caching will tell you that in this case you can forget about page caching. If you cannot guarantee that the URL in question will always provide the same content, page caching might be a problem.

The solution

To solve it, you have to do two things:

1. Make sure that every piece of information that can alter the page content is included in cached path. That is, instead of cache/index.html, your page should probably be stored under something like cache/en_GB/not_logged_in/msie/index.html.
2. Make sure that every piece of said information is retrievable by Apache or it won’t be able to find the cached page. Retrievable by Apache means URL or cookie. URL can’t change (else we wouldn’t have this problem), so our only option is a cookie.

In the following examples I’m going to present a simple recipe on how to implement a “language-aware” caching. I assume that you know how to cache and expire pages in Rails and you know what to cache. If that’s not the case, please at least read “Ruby on Rails Caching Tutorial” first (link below). I also assume that you run a configuration where Apache is serving static content and proxying dynamic content to a cluster of mongrels.

Move your page cache

This has nothing to do with multiple languages but it’s a good practice anyway and all the following examples depend on it, so I’d recommend that you do this. By default Rails stores cached pages right inside your application’s public directory. This is not the best choice IMHO because it’s hard to differentiate real static pages from cached dynamic pages, which makes it difficult to purge the whole cache. Add following line in your environment.rb.

config.action_controller.page_cache_directory =
  RAILS_ROOT + "/public/cache/"

Store language in a cookie

First, we must guarantee that the language chosen by user is stored in a cookie. How exactly you implement the choosing part is up to you. In our application, there’s a before_filter that checks many things like session, domain, subdomain, ACCEPT_LANGUAGE header etc. When the language is determined, we set a cookie like this:

class ApplicationController < ActionController::Base
  before_filter :set_language
  ...
private
  def set_language
    lang = ...
    cookies[:lang] = lang.locale_code
  end
end

Now, every request that makes it to Rails, will have a cookie with the language set. Be careful about the “makes it to Rails” part. If your link for changing language points to a cached page (I have been bitten by this), the change will not work, because the page will be served by Apache and you application server will not even see it.

Also note that even if the user prefers e.g. Italian, but your application has no Italian version and you serve them English version instead, you should save the real language of the content in the cookie, or else you will have duplicate pages in cache. This implies, obviously, that your code should be aware what languages your application is localized in.

Add language to cached page path

Next thing we have to do is to add language information to cache path. We can do this by overriding cache_page and expire_page class methods of ApplicationController like this:

class ApplicationController < ActionController::Base
  ...
  class << self
    def cache_page content, path
      super content, GetText.locale.to_s + path
    end
    def expire_page path
      Language.all_localized.each do |lang|
        super lang.locale_code + path
      end
    end
  end
end

I tried to use our freshly baked cookie[:lang] in cache_page method, but this didn’t seem to work well with tests, so I took the easiest around it with GetText.locale.to_s. If you use some other library in your application, you’ll have to find its own way to determine the locale (it shouldn’t be to hard).

In expire_page method we have to clean all versions of saved pages, not only the current one. Language.all_localized returns a list of all languages that we have localized our application in (all three of them), you probably have something similar in your code.

Configure Apache to find the cached pages

The last part is to setup Apache rewriting rules so it can find the cached pages using the language saved in our cookie. In the Apache configuration file for you application (something like /etc/apache2/sites-enabled/YourAppName), add:

RewriteEngine On
RewriteCond %{HTTP_COOKIE} lang=(en_GB|de_DE|pl_PL) [NC]
RewriteRule ^([^.]+)$ /cache/%1/$1.html [QSA]
RewriteCond %{DOCUMENT_ROOT}/%{REQUEST_FILENAME} !-f
RewriteRule ^/(.*)$ balancer://mogrel_cluster%{REQUEST_URI} [P,QSA,L]
<Proxy balancer://mogrel_cluster>
  BalancerMember http://127.0.0.1:3000
  ...
</Proxy>

Basically, these rules tell Apache to read cookie lang and use it in cache lookup. The crucial part is /cache/%1/$1.html, where $1 is the URL requested and %1 is the value of the cookie.

Now you’re ready to restart Apache and enjoy your multilingual application at much higher speed!

Troubleshooting

So, you’ve done everything exactly as above and nothing happens? Or even worse, Apache or Mongrel crashes? Here are some problems I have encountered and solved:

• Check if you have really deployed your application with all the changes and restarted Mongrels and Apache. Yeah, I know you couldn’t have possibly miss it, but please check anyway. I have forgotten to deploy this or restart that a couple of times myself.
• Make sure that your browser lets you see the response headers so you can check whether the page was served by Mongrel (dynamically) or Apache (cached) and page loading time. For Opera I recommend Developer Console and there’s Firebug for Firefox.
• If you would like to experiment in development mode³, don’t forget to turn caching on in development.rb with:

  config.action_controller.perform_caching = true

• Make sure you have set your application’s DocumentRoot correctly in Apache configuration file for you application. It should look something like:

  DocumentRoot /var/proj/YourAppName/current/public

  Also see next bullet.

• You have set DocumentRoot and now you’re getting a 500 error? Don’t panic. Check your /var/log/apache2/error.log file. If you see the following error: Option FollowSymLinks not allowed here (or similar, or something about symbolic links), add following lines above the DocumentRoot setting:

  <Directory /var/proj/YourAppName>
         Options FollowSymLinks
         AllowOverride All
  </Directory>
      

If you have any other problems, don’t hesitate to ask. I’ll try to help if only my limited knowledge of Apache configuration allows me to. If anything is problematic or can be done better, I’d be very glad to hear it. If you use something other than Apache/Mongrel Cluster/GetText and managed to implement this solution, please share.

Resources

For Google-impaired, here is a short list of resources. There are of course many more of them, but the ones below contain all the information you need to setup what I present here. If you had read them earlier, you wouldn’t have to read this article :)

• Rails Envy: Ruby on Rails Caching Tutorial
• The Junction » conditional use of page cache in Rails
• Fresh .htaccess Examples: Cookies, Variables, Custom Headers

¹ Or any other fast HTTP server you happen to be using, of course. But the examples are for Apache only, sorry.

² This is supposed to be a joke. If you had to look here, it’s probably not that funny.

³ Unfortunately, if you followed my recommendation and changed default cache placement, it won’t work with Mongrel. The cached pages are stored where they should be but not read back by Mongrel, because it ignores this setting. This seems to be a known problem but I couldn’t find a fix for it. You’ll get the information about caching and expiring pages in development.log and this should be sufficient in most cases. You can also try to setup an Apache server for your development use.