AirBlog - Home

GPS-style Latitudes and Longitudes on Rails Forms

2008-05-22T09:15:00Z

The Problem

Latitudes and Longitudes (credit: NASA)

Quite a few plugins exist to help you geocode post codes or zipcodes, and calculate the distance between two points. However few, if any, help you with latitudes and longitudes on forms, with input elements that match your GPS, and intelligent validation.

This is now solved.

The Situation

I’m building a web application that holds cruising information for offshore sailors. Much of the information is located, in the sense that it applies to a specific point on the Earth’s surface. A report on an anchorage, for example, might say something like, “Beware the submerged rock to starboard at the entrance; strong katabatic winds in spring; herds of wildebeest ashore.” So we need the sailors to supply latitudes and longitudes on most of the forms they fill in.

The only way to travel (credit: Horse’s Mouth)

The consensus among existing geo plugins is to treat latitudes and longitudes as floats, storing them in the database as decimals. However that’s not how people handle latitudes and longitudes. For excellent historical reasons, we think in degrees, minutes and seconds. Or, if you use a GPS — and all sailors do — degrees, minutes and decimal minutes (milli-minutes).

If you want people to enter the latitude and longitude of an anchorage on your site, and to enter them correctly, you need to let them just read it off their GPS. And if they enter an invalid value, you need to flag whether it’s the degrees, the minutes, or the milli-minutes — not simply say the whole lot “is invalid”.

The Solution

Buy the Rails 2 Plugin Patterns Peepcode PDF. Using the PDF I was able to write the plugin right, first-time. No trial and error: straight to the solution. The time it saved was more than worth $9. And the author’s a great guy ;-)

So, install my GeoTools plugin:


$ script/plugin install http://opensource.airbladesoftware.com/trunk/plugins/geo_tools/

(I’ll move all my plugins to Git soon, but they’ll remain available in Subversion for the forseeable future.)

Run a database migration to add latitudes and longitudes to the relevant tables. Let’s say we are talking about buried treasure:


  def self.up
    create_table :treasures do |t|
      t.string :name
      t.boolean :display_on_map, :default => true
      t.with_options :precision => 15, :scale => 10 do |c|
        c.decimal :latitude
        c.decimal :longitude
      end
      t.timestamps
    end
  end

Show me the treasure

Note we store latitudes and longitudes in the conventional way, so you can use other geo plugins too.

Tell your models what to do:


  class Treasure < ActiveRecord::Base
    acts_as_location
  end

Add latitude and longitude fields to your forms:


<% form_for @treasure do |f| %>
  <p>
    <label for='treasure_name'>Name</label>
    <%= f.text_field :name %>
  </p>
  <p>
    <label for='treasure_display_on_map'>Display on map?</label>
    <%= f.check_box :display_on_map %>
  </p>
  <p>
    <label for='treasure_latitude'>Latitude</label>
    <%= f.latitude_field :latitude %>
  </p>
  <p>
    <label for='treasure_longitude'>Longitude</label>
    <%= f.longitude_field :longitude %>
  </p>
<% end %>

Done.

You can also easily display a latitude and longitude:


<p>Name: <%=h @treasure.name %></p>
<p>Location: <%= @treasure.location %></p>

And that will produce:


<p>Name: King Solomon's Mines</p>
<p>Location: 12°34.567′S, 98°76.543′W</p>

Bonus

Happily for you, my AirBudd accessible form builder plugin is fully compatible with GeoTools. So instead of the form shown above, you can write this:


<% airbudd_form_for @treasure do |f| %>
  <%= f.text_field      :name %>
  <%= f.check_box       :display_on_map %>
  <%= f.latitude_field  :latitude %>
  <%= f.longitude_field :longitude %>
<% end %>

And that’s compatible with HAML too.

So now we have meaningful, GPS-style latitudes and longitudes with minimal effort. And treasure.

Relational Databases Are Not Relational

2008-05-06T14:51:00Z

I’ve been meaning to write about this ever since reading Databases in Depth, a punchy presentation of relational theory by C.J. Date. I’m sure you already know this, but Date worked closely for many years with E.F. Codd, the man who introduced the relational model in his 1969 paper Derivability, Redundancy, and Consistency of Relations Stored in Large Data Banks.

Anyway, here are some highlights from the book:

The term “relational” has nothing to do with relating two tables on a common set of columns.
Relations are multi-dimensional. Don’t let the term “table” fool you into thinking they are two-dimensional.
Nulls are not values.
SQL is not a set-oriented language (it is bag-oriented).

I used to think I had a pretty good understanding of databases until I read that book. Now at least I know how little I know. I think that’s progress.

If you work with databases — and that includes anybody writing Rails code — I recommend you read the book. Think of it as part of your edumacation. After all, I doubt you’ve read many other database books recently :-)

So why write this now? Well, I was reading about CouchDB and found in the comments a highly intelligent¹ contribution from somebody called Breton. Here it is:

There’s a few myths floating around in this article and in the comments. I normally don’t have much luck diffusing myths, but hopefully if the people read this have the ability to think critically, and do their own research instead of knee-jerk react, then it should go alright.

Myth 1: SQL is relational. It turns out this is rubbish. SQL is so much not relational that the committee in charge of SQL had to remove the words “relation” and “relational” from the standard. This is easily verified: find the standard and do a simple find. What’s not relational about it? In short: in SQL, tables and rows are not sets; the order of records and columns are significant; SQL allows duplicates, and introduces three valued logic with the NULL — all violations of the relational model which introduce bugs, inconsistencies, and a significant risk of data corruption.

Myth 2: Relational Databases are flawed. Truth: There’s no way to know since there’s never been a widely used relational database. There are some who argue that should the relational model ever be implemented in a DBMS system, it would outperform current database systems in terms of speed and stability. It seems to me this is probably true, but then, what do I know? (Though some vendors claim that they produce relational database systems, this could not possibly be true as long as such systems use SQL).

Myth 3: Systems like CouchDB are in every way better than relational database systems.

Again, there’s no way to know since there isn’t a widely available and usable relational database. But a truly relational database system would hold significant advantages over a “flat” data storage system such as CouchDB. Assuming, of course, that it is utilized properly, a relational database is essentially a large scale inference engine. Meaning that if you can reason about a subject using formal logic, you can reason about data on the subject on a large scale using the relational algebra or relational calculus. This is amazingly powerful, but since most people never bother learning about the relational model they never take advantage of it.

And then, to wrap it up:

A good analogy might be claiming that Web Standards, semantic html, and seperation of presentation and content are unworthy concepts because they happen to be difficult to achieve in IE6. Don’t blame the inadequacies of the implementation on the concept itself.

Indeedy.

¹ I know it was intelligent because it agreed with me.

Small Business

2008-04-30T08:14:00Z

The silly thing is that a fair amount of these small businesses (10% or so) will end up growing into some pretty large companies. The doggy daycare that I take my dog to occasionally started out as just one guy with one location (he even slept on the floor next to the dogs for the first year). Now they’ve got more than a dozen locations in three states, and the guy is a millionaire.

Just do what you love, and even if you’re not trying to become a millionaire, it might just happen anyways.

Erik Peterson commenting on Quit your job!

Well, now I know what to do if the software doesn’t work out :-)

Urgency

2008-04-18T15:04:00Z

Emergency is the only urgency….If your deliveries are that critical to the hour or day, maybe you’re setting up false priorities and dangerous expectations.

Jason Fried, Urgency is poisonous

Static Typing

2008-04-15T08:21:00Z

In most cases a statically typed language is a premature optimization that gets extremely much in the way of productivity.

Pragmatic Static Typing, Ola Bini

I Have Seen The Future Of Dance Music

2008-04-09T18:40:00Z

Bird? Dinosaur? Dance music generator

And his name is Giles Bowkett. Or, rather, its name is Archaeopteryx.

With more layers of indirection than Enron’s accounts, this is lambda central. Unlike the accounts, this isn’t obfuscation — it’s adaptability. At its heart, Archaeopteryx is a probabilistic MIDI generator. The lambdas vary the probabilities randomly, or perhaps probabilistically; it really depends on the last lambda.

Anyway, don’t take my word for it. Get yourself some Reason, a copy of Practical Ruby Projects, and … something else whose name I’ve forgotten (pipes Archaeopteryx’s output into Reason).

Right now Archaeopteryx generates pretty convincing drum & bass, and techno too. Giles has vision for this, so watch that space.

Scotland on Rails 2008

2008-04-08T10:22:00Z

Update: here are my slides.

Well the last people I expected to see when I wandered down to breakfast on the first day were the Russian national women’s hockey team.

This conference was very good. I encountered a lot of intriguing new ideas, many friendly and interesting people with whom I’d love to spend more time, and (not at the conference) a cousin I last saw thirteen years ago in Western Australia!

The venue next door

You can’t really go wrong holding a conference in Edinburgh. It’s a magnificent city, and because my grandfather grew up there I can walk around telling myself I’m not a tourist (I tell myself a lot of things). And you’re never far from a pub, er, castle.

BDD and SDD

The talks I heard were all good. The most immediately useful to me were those on testing: Tammer Saleh on behaviour driven development with Shoulda, Bryan Helmkamp on story driven development and Webrat, and Jim Weirich and Joe O’Brien on mocking.

To date I’ve found writing tests irksome; worthwhile, but clunky. However, I’ve been using old-school Test::Unit, so I think now it’s time to upgrade. (Not convinced yet by SDD, but time will tell.)

Erlang/OTP

Picnic, anyone?

I was pleased Erlang/OTP slipped into the schedule. Gordon Guthrie ran through the concepts and architecture of Erlang/OTP systems, locating them within their historical context. Guthrie was surprisingly irreverent, and his talk was all the better for it.

Apparently in the UK telephone system’s first year of operation on Erlang/OTP, its downtime was 31 milliseconds. That’s 99.9999999% availability. Respect.

JRuby

As somebody who spent five years writing J2EE applications, I have no desire to interact with the Java language again. But the Java platform — that’s a different kettle of ball games. The JVM, with its dynamic optimisation, native threading and tuned garbage collection, is a sophisticated and fast runtime environment. A Java-based Ruby implementation can take full advantage of those capabilities.

So although I don’t care that JRuby lets me write Swing in Ruby, I sat up and listened when Charles Oliver Nutter and Thomas Enebo showed a threaded Ruby program using all its machine’s cores. And I was intrigued by the idea of Rails application deployment to a single Glassfish process.

Big Names, Delivering

The weather begins to bite

Other speakers that stood out for me were Jim Weirich on Ruby class design, Michael Koziarski speaking frankly about the quality of Rails’ internals, and David Black with his extended music analogy.

Highlight

But the most stimulating talk was Giles Bowkett’s on code generation and metaprogramming. Few could mash up so amusingly Archimedes, Jessica Alba, respect for Lisp, disrespect for Lispers, code generation and sombreros. Superb.

Overall

I had a much better time at Scotland on Rails than at both RailsConfs Europe. And this was only the first one. I’m looking forward to Scotland on Rails 2009.

The Highland Fling 2008

2008-04-07T19:39:00Z

Pulled out of the bag at the eleventh hour by the inimitable Alan White, The Highland Fling was a fun, interesting one-day conference about “The Browser and Beyond”.

Three features made the conference work so well: it was small, ensuring a convivial atmosphere; the talks came one after the other, not in parallel, so you didn’t miss anything; and the traditional Q&A was enlivened considerably by Paul Boag’s compèring.

The most intriguing talk for me was Simon Willison’s on Comet, a set of techniques for pushing live updates to web pages. Calling them techniques lends thems an air of respectability but, in reality, these are a shifty bunch of hacks that mislead browsers in various startling ways. Somehow, extraordinarily, this all works reliably, and across platforms too. Even better, the nastiness has been swept under the carpet by the Dojo JavaScript library, which you can drop innocently into your webapp.

Best of all, the Bayeux protocol defines a standard communications protocol between Comet clients and Comet servers. Immediately this separates the difficult, infrastructural parts of Comet from the rest of your application and, in theory, gives you implementation independence.

Simon showed a few examples of Comet in action, including Google’s updating spreadsheets and his own slideshow tool. HTTP’s client-request, server-response rhythm is so foundational that it seemed almost magical watching changes made in one browser show up, without polling, in another.

Of course, the nature of the technology requires many concurrent client-server connections, a profile for which general web servers such as Apache are not designed. This, I think, is my excuse finally to wheel out an Erlang server to see for myself what Comet can do.

It was also good to see the FreeAgent crew out in force, especially as they took me out for dinner afterwards. Thanks!

Professionalism

2008-04-07T08:29:00Z

Apart from the food, the great joy of French restaurants in England is French waiters who are serious professionals and do not try to be your friend. They have been brought up to respect clients for being exigeant, and to despise them for being undiscriminating. So when the English describe a mediocre dish as ‘lovely’ or ‘very nice’ and never make a fuss about the cuisson of their steak, they are treated with the hauteur they deserve.

Le Dossier, Hortense de Monplaisir (translated by Sarah Long)

Hmm, I never thought I’d say this, but perhaps I need to act more like a Frenchman. Not in despising people, but in trying to be your clients’ or customers’ friend. Regularly not charging for small pieces of work soon adds up — or rather, it doesn’t — and does not pay the bills.

And if I don’t value my time, nobody else will value it for me.

Reassuringly expensive

Henrik Knudsen Site Wins Award

2008-04-02T15:30:00Z

Award-winning work

We were delighted to hear that the site we built for Henrik Knudsen, an award-winning photographer, has itself won an award.

Specifically, it was chosen for PDN’s Photography Annual 2007, a collection of the best portfolio sites of professional photographers.

Credit for the slick Flash front-end belongs to Homemade Robot. We built a content management system to power the Flash; and a client management system, with private client areas, where Mr Knudsen can display his photoshoots to his clients.

We’ve learned that a photographer demands rather more of an image uploader than a random forum user with a small passport photo. We’re running a heavily customised version of attachment_fu, with Background Job doing sterling work in, well, the background.

All in all, a good team effort.

90% Under Any Conditions

2008-03-31T18:07:00Z

I also came to realise that trying to nail everything perfect in training is pretty useless. All you’re doing is learning to do statics in perfect conditions. …Don’t even try to beat your record, instead force yourself to do a good, solid, 90% performance under any conditions. Then try to create the perfect conditions in the competition. Do your personal bests there.

Jome, Post Competition Pondering

Heathrow Terminal 5 Debacle

2008-03-29T11:11:00Z

A passenger contemplates the failure of the multi-million pound baggage-handling computer system on Terminal 5’s first day:

Perhaps they have mended the elastic band by now.

Alan Bowman

Note To Self: Why Some JPEGs Don't Render in Firefox or IE

2008-03-28T16:18:00Z

If you find some of your JPEGs render in Safari but not in Firefox or IE, check the images’ colour models.

They come in two flavours: RGB and CMYK. Firefox and IE won’t render the latter. Safari handles both.

Moving Between Lists With acts_as_list

2008-03-19T11:51:00Z

How do you move an item managed by acts_as_list from one parent to another? Moving items within a list is well documented, but there’s scant information on moving between lists.

I wrote about this previously in a pre-Rails 2 world. This is an update for Rails 2 and — happy days — it’s simpler.

Intra-List Movement

Here’s the basic set-up. This is all you need for intra-list movement.


class Category
  has_many :products, :order => :position
end

class Product
  belongs_to   :category
  acts_as_list :scope => :category
end

Inter-List Movement

When we move a product between categories, we need first to remove it from its current category’s list; and afterwards to insert it at the correct position in its new category’s list.

This is slightly tricky because the instance methods acts_as_list adds to your model update records in the database directly, triggering callbacks you don’t necessarily want triggered.

So instead of using before_save and after_save callbacks to tinker with the old and new categories’ lists, you need to get involved at the point where you change the product’s category.


class Product
  belongs_to   :category
  acts_as_list :scope => :category

  def category_id=(category_id)
    p = position
    remove_from_list if (p && valid?)
    super
    insert_at position_in_bounds(p) if (p && valid?)
  end

  private

  def position_in_bounds(pos)
    length = category.products.length
    length += 1 unless category.products.include? self
    if pos < 1
      1
    elsif pos > length
      length
    else
      pos
    end
  end
end

The Controller

Assuming your GUI for editing a product has:

a dropdown list of categories to which the product can belong;
a dropdown list of positions within its category’s list;
AJAX that refreshes the positions when a different category is chosen;

— then your controller would look like this:


class ProductsController
  def update
    @product = Product.find params[:id]
    new_position = params[:product].delete(:position).to_i
    if @product.update_attributes params[:product]
      @product.move_to_position new_position
      redirect_to product_url(@product)
    else
      @product.position = new_position
      render :action => 'edit'
    end
  end
end

The only difference from a normal update is the special handling of position. Why do we treat position differently? Because acts_as_list executes SQL updates directly on the database, independently of our model’s updates. We only want this under-the-covers SQL update to take place if the model’s own update goes through successfully.

For this to work, we need to define one further method on our model.


class Product
  def move_to_position(position)
    insert_at position_in_bounds(position)
  end
end

Conclusion

By its nature, acts_as_list needs to update multiple records when you change a model’s position. This update saves your model, which may come at an inconvenient time for you. It’s easier, therefore, to avoid the usual lifecycle callbacks and instead operate at the point where the parent is changed.

Easy Long-Running Tasks In Rails

2008-03-14T12:00:00Z

Contains 80 Ruby programmers

On Monday night I spoke at the London Ruby User Group on handling long-running tasks in Rails. No fights broke out so I considered it a success.

In a month or so, I’ll return to my people and give an expanded version at Scotland on Rails. The skepticism and incredulity I encountered at LRUG will guide me as I hone my material.

I’m not posting my slides because, by design, they make no sense on their own. If you’d like them anyway, get in touch and I’ll send them to you.

Incidentally, for anyone who was there, my conclusion was: Background Job, also known as BJ, by Ara T Howard.

Here’s an example of using BJ to upload files to Amazon S3 via attachment_fu.