Perspectives : Writings from The Killswitch Collective

Possibilities and Pitfalls with Adobe Air

Fri, 16 May 2008 11:46:49 -0700

From the Browser to the Desktop

As websites graduate to version 2.0 with their dynamic user-generated data-driven content we are adjusting our vocabulary to talk about them. We are no longer just building sites, we are launching applications. Indeed many applications from the desktop realm are being replicated online. Google Documents, for example, could hypothetically replace the need for something like Microsoft Office, but with the added benefit of everything being a part of the cloud so that a document may be accessed and edited by multiple users from multiple locations, independent of each users' operating system.

This isn't a one way street, desktop applications do not all live in the 'desktop bubble'. At startup many applications check for updates and external information, like iTunes downloaded track information, album artwork and so on.

Lately the line between the internet and the hard drive has become a bit blurred. Several technologies are in development that allow web developers to create what appear to be full fledged desktop applications using HTML, CSS, Javascript, Actionscript — the Web oriented tools we already know. An overly simplified description of this is a browserless Web application that doesn't necessarily use the Web. Google Gears, Mozilla's Prism and Adobe AIR are a few of the efforts put forward recently to move the web onto the desktop to varying degrees.

I recently had the opportunity to try out one of these "horseless carriages". What follows is an overview of my experience with the Adobe Integrated Runtime (AIR), formerly known as Apollo.

The Pieces

There are two pieces to any AIR application. First there's the runtime environment which handles HTML rendering and all of the difficult behind-the-scenes stuff that us web developers would rather not worry about. The second piece is the actual application composed of your regular Web technologies (HTML, Javascript, PDF's, video, Flash, etc).

When a user installs an AIR application for the first time they must install the runtime environment as well. Later, when the user installs another AIR app, they will not have to download the already installed runtime. The whole download and installation process is designed to be "seamless", appearing as if the user is downloading just one item regardless of whether they need to download AIR or not. As I'll explain later, however, it is not always so smooth.

Benefits

So why build an AIR application?

Why put a Web application on your desktop? One of the advantages that all of the aforementioned tools cite is the ability to work offline. Granted, reliable internet access is becoming less and less of an issue, but what good is any Web application when you don't have a working internet connection? Working offline usually means storing information in a database and synching that information with a master database when a connection becomes available later. AIR comes packaged with SQLite for this purpose. Alternatively data can be stored as XML and can even be encrypted. Furthermore, if it is not necessary to store some information online, storing it locally can save some time because data does not need to be sent back and forth. This all makes for a smoother, persistent user experience.

Consistancy

AIR uses the WebKit HTML rendering engine which recently passed the Acid3 test for Web standards, so you can rest assured that your floats will properly float and your padding will properly pad. No need to hack together special code for you-know-who.

OS integration

AIR provides a windowing API that allows you to interact with the operating system's windows. You can set the size and position of windows, restrict them to a range of sizes, dictate whether they can be resized or minimized, display your app fullscreen, or run the app with no window at all. You can even create your own custom window GUI. One of the advantages of having this kind of control is that browser windows often have elements (back/forward and refresh buttons, search bar, etc) that are not necessarily relevant to every application. Sometimes less is more. AIR also allows for other kinds of integration with the desktop including access to the file system, clipboard data, drag and drop events and so on.

The Seams

While all of this is good and exciting and lets web developers pretend that we can build desktop applications, AIR's system is not perfect.

AIR detection

As I mentioned before, any AIR app is composed of two pieces; the runtime environment and implementation code. If the user already has AIR installed it doesn't make much sense to install it again. Adobe provides a Flash movie that they call a "badge" that functions as a button for downloading the application. More importantly, it also performs a bit of magic to determine whether the user has AIR installed already or not. If they don't, it downloads both AIR and your app and installs them together all in one smooth and easy action.

This is all fine and well except for the fact that the badge requires the latest version of Flash in order to do this. A bit of plugin version detection can render an alternative page from which the user can download first AIR and then your app. This isn't so bad except for:

If they don't install AIR first followed by your app second, the installation of your app will fail.
Users often don't know what they have installed on their computer and may try to install AIR unnecessarily.
Explaining to your users why they need to download and install item 'A' first in order to install item 'B' may lead to a bit of required reading and confusion. Such messages are in danger of being ignored as a bunch of legal mumbo jumbo or simply as a waste of time.

Granted, the users who will be tripped up by such things are probably a small minority of users lacking in computer savviness and patience, but you should still be aware of who your audience is. If they are likely to have trouble with the two-piece download then chances are good that their version of Flash Player is not even current enough to do the AIR detection, thus all but defeating the purpose of the "seamless" download feature.

Security Certificates

Because AIR apps can be given access to the user's system and transfer data over the internet there is an obvious security concern. Adobe requires that AIR apps be packaged with a security certificate (hopefully) verifying the authenticity of the application. This is designed to prevent someone else from maliciously altering your app and redistributing it, getting you into a heap of trouble.

You certainly don't want to get into trouble because someone posing as you has done something nasty to your users, but preventing this isn't ideal either. The solution is to purchase a certificate from a certificate authority such as Thawte or Verisign for around $300 a year, but some developers or clients may consider this to be an unnecessary expense. This doesn't actually prevent anyone from creating a fraudulent version of your app, it just proves that you are the one who packaged your app.

The alternative is to create a self-signed certificate, and Adobe provides some tools for easily doing this. The only problem with self-signing your certificate is that when the user installs your app they are presented with this window:

The language here is intentionally ominous. You are most likely creating something innocent, but your users may be scared off by the idea of giving someone of unknown identity unrestricted access to their computer. I don't know that there is a better solution to the security issue but it is something to consider.

Perhaps I'm griping about things that are inevitable and/or insignificant, but there's my two cents. I do think AIR is worth a try, at least to impress your friends with your mad desktop app building skills.

We Are Into Post-Digital Creation Culture

Fri, 16 May 2008 10:53:52 -0700

As designers, we are constantly seeking new, innovative ways to communicate the messages of our clients. This May, our design team traveled to OFFF 2008 in Lisbon, Portugal to soak up some inspiration, see what other designers across the world are creating, and to bring that knowledge back to Killswitch to spark new ideas for future creations.

OFFF is a 3-day design festival exploring the latest ideas in a new visual culture, covering everything from graphic design and visual communication to motion graphics and sonic landscapes to advanced forms of interaction, via physical space or digital space. Rather than thinking in terms of the post-apocalyptic world where machines have taken over—think Terminator or Blade Runner—as we did back in the '80s, the new post-digital creation culture considers what we can create next in this diverse, digital spectrum. Now that we have the technology in place and have studied and explored and created, the wi-fi artists of today are re-examining our relationship with technology to push and blur boundaries and to explore new digital avenues. Artists are turning to programming, programmers are turning to music, and musicians are turning to art. As these areas overlap, new breakthroughs emerge. The same code used to generate colors and patterns can be used to create artwork for the walls of your house. Personal data can be calculated and mapped to create a visual diary of communication patterns. A computer's capture and storing of real-time movement can be used to recreate those movements in a simulated virtual environment. These explorations are opening up brand new avenues of communication and interaction, and have exciting implications for the future of our digital culture.

More than 2500 people attended OFFF this year, and the attendees included designers, artists, musicians, and developers from all over the world. Held at the LX Factory, an immense industrial space tucked away amongst brightly-tiled row-houses and cobblestone streets in the Alcantara area of Lisbon, the event boasted floor to ceiling presentation screens, interactive art installations, and a wealth of DJ entertainment. Every presentation in this talented line-up was inspiring, and each one explored a different area of visual communication. Karlssonwilker made us laugh with all of their crazy design experiences, Alex Trochut amazed us with his illustrative typography, Joshua Davis fascinated us with his dynamically generated works of art, Craig Swann motivated us with his playful outlook on the world, Andreas Müller mesmorized us with his swimming type and fluid forms, Fakepilot caught our attention with his Daft Punk-style intro, Hellohikimori engaged us with their colorful, immersive websites, Hi-Res! amused us with their rejection of the expected, and Fallon entertained us with their simple yet highly original advertisements, proving that a big budget is less powerful than a big idea.

The diverse and groundbreaking ideas from speakers at this event prove that what we think of now as "new media" is just the tip of the iceberg. Today's designers and artists defy classification, reject the limitations of technology, and develop their own standards. OFFF was a truly memorable event and one that moves all of us forward.

Application States with ActsAsStateMachine

Fri, 09 May 2008 14:13:18 -0700

When mapping the flow of an application, we usually have various states for a single object. These states are then joined with lines showing how an object can transition from one state to another. Each state will be unique; it may be just simply have a status flag, or it could open up new functionality within the app. For example, an e-commerce application may have a system for package tracking. When customer pays for a product, that product will have a status of 'paid'. Based on the paid status, the seller will be notified that the product needs to be shipped and the customer will gain the ability to write a review.

Traditionally, we would have to create methods that dealt with switching and checking states. Thankfully that has all changed with the wonderful ActsAsStateMachine plugin. What I like best about ActsAsStateMachine is that it has its own methods in handling states and event transitions that won't get lost with other methods within the model. I will go more into detail soon, but first we need to create a quick application to showcase the awesomeness of ActsAsStateMachine!

Let's create a baseball application that will display scores of current games. Each game will be in the database before it starts, allowing users to view if tickets are available. When the game is live, ticket information will not be needed and a scoreboard with all the innings will be displayed instead. When the game is over, only the final score will appear with information for the next game.

To get started, first install the plugin:

ruby script/plugin install http://elitists.textdriven.com/svn/plugins/acts_as_state_machine/trunk/

Then within our Game model, add the following:

acts_as_state_machine, :column => :game_state, :initial => :pending

Here we are simply telling the Game model to act as a finite state machine. We are setting the column that will hold the Game's state as game_state. By default, ActsAsStateMachine will use the state column. This can cause problems since a state column in most applications will hold location information. So by specifying a column name, we can avoid column problems. The last portion will set the initial state of a newly created Game object to pending. It is similar to creating a migration and setting the column to a default value, but if that default value ever needs to change, a new migration would have to be created. By setting a initial value, we can easily change just that one line. Now lets define all the various states for a game. Based on the app's requirements, a game will have three states: Pending, Live and Final. Defining states is as easy as adding:

state :pending
state :live
state :final

Our Game model now has states and with each state definition new methods are created. These methods may come in handy for state-specific validations or can be used in conditionals within the views that will load certain partials. For example, instead of doing @game.state == "live", we can use @game.live?. With all the states for Game defined, it is time to add events that will transition the game from one state to another. ActsAsStateMachine has it's own methods for creating events, which is basically a loop. We start by defining the event loop, giving the event a name and then specifying transitions within.

event :start_game do
  transitions :from => :pending, :to => :live
end

event :end_game do
  transitions :from => :live, :to => :final
end

With these events we can now transition a game object's state by using @game.start_game! and @game.end_game!. Keep in mind each event can hold many transitions, we can combine the two event methods into one as long as the :from portion is different. It wouldn't make much sense in the context of our example, however, because it is linear.

We have had the app up for a few weeks now and baseball fans are really digging the slick up-to-the-minute scores that we update through AJAX calls. Eventually we will run into our first rain delay, which will lead to problems. Fans will start thinking the app has stopped updating and our servers will keep running expensive AJAX updates over a game that has turned idle. It is time to introduce the rain delay state and event, making our simple app less linear.

state :rain_delay
  
event :rainout do
  transitions :from => :live, :to => :rain_delay
end

With a rain delay, a choice will be made by the umpires. If enough innings have been played, the game can end with the current score being final. Otherwise the game can be canceled and be rescheduled at a later date. Let's add the new canceled state and transitions events from rain_delay. Lets also add a new transition into the end_game event for rain_delay games that have played enough innings to be called final.

state :canceled
  
event :end_game do
  transitions :from => :live, :to => :final
  transitions :from => :rain_delay, :to => :final
end

event :cancel_game do
  transitions :from => :rain_delay, :to => :canceled
end

Let's say if a game is canceled it is still in our database for historical purposes and a new game will be created with some data from the canceled game. Let's also say that the reschedule_game method will create a new game from a canceled game. ActsAsStateMachine lets us attach callbacks like state events. Basically we want to run the reschedule_game method whenever a game's state changes to canceled. To accomplish this, we simply add :enter => methodname after defining the state as so:

state :canceled, :enter => :reschedule_game

Now whenever a game's state switches to canceled, a copy will automatically be made through the reschedule_game method. Besides enter, ActsAsStateMachine also has after and exit options. After would run after the state switch has been made and exit will be executed when the object is transitioning away from the state.

ActsAsStateMachine comes in handy when a object's status goes through many changes. I hope I have shown you how easy it is to define states, create transitions and implement ActsAsStateMachine into a model. Here is what our final code looks like:

acts_as_state_machine, :column => :game_state, :initial => :pending

# States
state :pending
state :live
state :final
state :rain_delay
state :canceled, :enter => :reschedule_game

# Transition Events
event :start_game do
  transitions :from => :pending, :to => :live
end

event :end_game do
  transitions :from => :live, :to => :final
  transitions :from => :rain_delay, :to => :final
end

event :rainout do
  transitions :from => :live, :to => :rain_delay
end

event :cancel_game do
  transitions :from => :rain_delay, :to => :canceled
end

Data Back-up Solutions

Thu, 01 May 2008 07:31:44 -0700

Living with Regret

Many of my articles deal with researching and the effect it has on the company's dealings with clients. Now, I feel that another issue has to take the forefront: system and assets back-up. I have had the worst luck lately when dealing with computers, company data and the need to back things up. Working at a Web firm, it's easy to take backing up for granted because everything already has two copies: all the articles, client assets, help archives, etc. exist both on our local drives as well as on the Web servers. But this is the exception to the rule as most businesses don't have such redundancy in place.

I still can recall my personal data loss tragedies... One day I accidentally erased my first PC's 500MB drive trying to retrieve a paper I wrote for history class. Another day I lost all my documents, media and impressive collection of ms-dos based games to a suddenly defective drive. The memories haunt me...

Thanks to continually dropping technology prices, a back-up array or separate storage solution has fallen within reach of the average home user. Still, people are losing their data in their own personal tragedies every day, simply because data back-ups only gets serious consideration about five seconds too late.

A while ago, I consulted with a company on a new computer setup. Under normal circumstances, this should have been a simple, straight-forward, "Buy, Back-up, Program and Go." Unfortunately, their current computer was using Windows '98 and its drive had crashed an hour before I had gotten there. Once a Windows '98 drive has spun its last sector there's simply no hope. I had the unpleasant honor of explaining that their data and projects had gone to 'a better place', all because they hadn't taken my suggestion to pick up a 80GB back-up drive for an easy $70.

The data of any business is a precious commodity, and working without a back-up system is walking on a tightrope without a net. Thankfully, there are many data storage solutions that can meet the needs and budgets of business and personal users.

Hardware Solutions

One simple solution that a user can get either for business or personal use is a 1TB (terabyte) drive, an amount that is virtually impossible to fill without a vast media collection. While this drive is not lacking in capacity, I would be concerned that a drive failure would result in such an immense loss. Personally, I prefer to spread out all my data on multiple drives so that if one fails I have a copy of it somewhere else.

For a business or user that needs to back-up multiple computers, a networked or wireless drive may be an excellent solution. The D-Link DSM-G600 Wireless G Network Storage Enclosure allows you to place drives on a shared network. Another solution would be an attached network storage like the Iomega StorCenter 1TB WI-FI Network storage drive. The drives are already formatted and ready to go, and have wireless connectivity and network adapters for additional server storage.

For those users that need storage on a tight budget I would recommend one of two choices. A 500GB external drive like the Seagate Freeagent Desktop costs between $90-150. For the more ambitions, you can combine a 500GB hard drive (about $100 and getting cheaper) with an external enclosure (check out the Eagle Consus W-Series SATA to USB and the eSATA External Storage System (ET-CSWESU2-BK) Black).

I recently have been introduced to an innovative storage solution called Drobo, the world's first storage robot. I have to say the concept looks promising, I wish that I could get my hands on one to play with. Based on information from their site, here are some pros and cons of the Drobo:

Pros:

You can swap drives (SATA only please) in and out of Drobo and data is automatically and redundantly redistributed to protect from drive failure. This is like RAID only better: I don't trust RAID based systems because of their rigid nature. With RAID, adding or removing a drive requires a full reboot and, depending on the RAID configuration, a single drive failure could still corrupt the whole array.
No babysitting required, the Drobo takes care of itself.
There's no loss of productivity between files and data while drive swapping.

Cons:

The Drobo's price of $499 and up is a significant roadblock to becoming an early adopter. Keep an eye out for this price to start dropping, however, as the technology spreads.
It only comes with USB 2.0 connections, eSATA and standard networking capabilities would have been welcome features.

While using an external drive is sufficient for many purposes, some users are turning to software solutions that help automate the back-up process.

Software Solutions for Macs

There is an integrated solution that ships with every new Mac called Time Machine. Time Machine makes a full copy of your computer's data when it is initialized and then simply records the changes made to your data. Its automation is paired with a fun, intuitive user interface that let's a user 'fly through time' to find the file that was deleted, edited or saved over. Thanks to its excellent integration within OSX and other peripherals like Time Capsule, Time Machine is the likely choice for backing up Macs.

One other possible solution is MacBackups which does online, offsite back-ups of your Mac.

Software Solutions for PCs

Nero offers a back-up feature in its Nero 8 software. It can automate the back-up process and allows for manual back-ups as well

Norton Ghost is also an excellent option. It's not a tradition back-up program in that you have to restart and load PC-dos in order to make your back-up. The benefit to this approach is that it can restore your entire computer with your programs intact rather than simply your documents.

I hope this is a resource that can help make your back-ups easy and painless, but no matter what, please, PLEASE, back up your files!

Expanding Your Web Typography Arsenal

Fri, 25 Apr 2008 12:18:27 -0700

A long standing complaint among web designers is the lack of variety in typefaces that can be reliably used and guaranteed to display across all web browsers and operating systems. For the most part, designers are stuck with Arial, Verdana, Georgia, Times, or the standard serif and sans-serif implementations, though this list can be supplemented by expanding the font stack. Granted, the standard typefaces are optimized for web and will render well across the the board at various sizes, with anti-aliasing on or off, but occasionally designers need to spice things up with additional typefaces in an accessible, search-friendly manner without resorting to pre-rendered images. Two options currently exist to help remedy the situation: sIFR and Safari Embedded Fonts.

sIFR (Scalable Inman Flash Replacement)

sIFR has been available for a few years and has had a good reception across the web community. It was created as a way for designers to display any typeface on a web site without requiring the visitor to have that typeface previously installed. It uses a combination of Adobe Flash and Javascript to dynamically replace text, and is completely accessible and search engine friendly. The current stable build of sIFR is version 2, with version 3 currently in development, hopefully to be released in a stable form in the near future.

sIFR requires both Javascript to be turned on and the Flash plugin to be installed. If either of these requirements are not met, the default styles designated by the designer will be used and the visitor will never know the difference. However, the wide adoption of Flash and Javascript will ensure it works for most visitors. sIFR is best used in moderation with elements like headlines, rather than entire blocks of body text.

How to use it

After downloading sIFR, the first step is to open the sifr.fla in Adobe Flash, replace the typeface with one of your choosing, and export the file as a Flash movie. This is explained in more detail in the sIFR Documentation. Next, in the <head> of your HTML document, insert links to the sIFR CSS and Javascript files:

<head>
  .....
  <link rel="stylesheet" href="sIFR-screen.css" type="text/css" media="screen" />
  <link rel="stylesheet" href="sIFR-print.css" type="text/css" media="print" />
  <script src="sifr.js" type="text/javascript"></script>
  <script src="sifr-addons.js" type="text/javascript"></script>
  .....
</head>

Before the the closing <body> tag of your HTML document, insert the Javascript to call the sIFR replacement methods on all the elements you want to transform:

.....
<script type="text/javascript">
if(typeof sIFR == "function"){
	  sIFR.replaceElement(named({sSelector:"body h1", sFlashSrc:"blackletter.swf", sColor:"#000000", sBgColor:"#dddddd", sFlashVars:"textalign=center"}));
  sIFR.replaceElement(named({sSelector:"body h2", sFlashSrc:"blackletter.swf", sColor:"#000000", sBgColor:"#FFFFFF"}));
};
</script>
</body>
.....

The sIFR.replacementElement method takes a number of options such as color, background color, link and hover colors, padding, and several more as described in detail in the sIFR Documentation. You may have to play around with these options and tinker with your CSS to perfect your transformations.

View the Example »

You should see something like:

Pitfalls

sIFR does a good job of working across a variety of browsers and degrades rather gracefully when it can't be used. That said, there are a few issues that arise with its use. Occasionally sIFR can slow the rendering of a web site, and can also create a visible 'flash' as the text is replaced by Flash. Additionally, visitors won't be able to copy and paste a combination of sIFR text and normal HTML text.

Embedding Fonts with @font-face and Safari

With the recent release of Safari 3.1 from Apple comes the ability for a web designer to reliably display any TrueType font of their choosing on a web site without Flash or Javascript, allowing them to style it with CSS as they wish. Visitors' browsers will seamlessly download the typeface and render the design in all its glory as was intended by the designer. Surprisingly, Internet Explorer has actually supported font-face embedding since version 4, but unsurprisingly, Microsoft's implementation only works with a proprietary .EOT font format.

How to use it

Implementing the @font-face property is actually quite simple. It acts just like any other CSS selector as shown in the example code below. Define a name for your font-family and then provide an absolute or relative url() to the typeface file. The url() acts just like url() for background-image. Once you've defined the typeface, simply use the new font-family within any selector as you would normally.

@font-face {
  font-family: "OldeEnglish";
  src: url(OldeEnglish.ttf) format("truetype");
}

h1 { font-family: "OldeEnglish"; }

View the Example (works only in Safari 3.1+) »

You should see something like:

Pitfalls

One major downfall to using embedded typefaces is that the technique currently only works in Safari 3.1. However, other browsers will degrade gracefully and use the next font in the font stack. Unfortunately, a designer may be using different line-height, font-size, letter-spacing, or word-spacing specific custom typeface, making the next typeface in the stack unreadable. No word yet on whether future versions of Firefox, Internet Explorer, or Opera will join in the font embedding party, but a designer can hope.

Copyright issues also arise with @font-face. Quality typefaces from type foundries often cost hundreds to thousands of dollars and don't generally include licenses that allow for legal distribution to the public. Since the fonts used with @font-face are required to be publicly accessible, they could potentially be downloaded by any user who has a peek inside your stylesheet. There are many freely downloadable fonts available on the web, but a majority of those are rather low quality and should probably be avoided anyways.

With Great Power Comes Great Responsibility…

The two tools are a welcome addition to a designers arsenal, especially when it comes to web typography. However, these new tools do open the door for typeface abuse and potentially illegible, tacky designs. Unless that's specifically what you're going for, as a designer you should still use sound judgement and restraint. Just because you can, doesn't mean you should. With that said, go forth and experiment!

Helpful Resources & References

Poor Man's Multi-Table Inheritance

Fri, 18 Apr 2008 12:14:29 -0700

A while ago, I was given the task of converting a working Java web application to Ruby on Rails. The word on the street was that Ruby on Rails was great for a 'green' project, lays i.e. starting from scratch - but not so good for a legacy application.

However, since the database I was using already had an auto-increment primary-key column 'id' for every table, I didn't run into that many problems. There was, however, one bit of functionality I puzzled over for a while.

The application was a project tracking application: projects with attached assignments, and each assigment was associated with a document of some sort. The document types weren't really related to each other all that much, except for a few common attributes and the fact that they could be assigned. To protect the names of the innocent, I will pretend the types of items were articles, books and blog posts. If you consider those, they don't have a lot in common. No article or blog post needs an isbn, and no book needs a date posted field. They are all pretty distinct conceptually; the commonality can be found in that each are something an editor might need to work on - i.e. they are all coherent bodies of text.

I looked at the existing Java code. The application had classes Article, Book and Post all derived from Document. But there was no 'documents' table - only articles, books and posts.

Technically this is Multi-table inheritance since each type of object gets its own table. This is not something supported by Rails. Rails supports the idea of Single Table Inheritance (STI): put every record in one table. This often works out very well because it is efficient and simple.

However, I didn't want to force all these records into one table for a variety of reasons. One such reason is I wanted to make sure no Book was created without an isbn - but if I put them all in one table, the isbn field would have to allow for NULL (for articles for instance). Some would argue this an application level concern, but I think if you can guarantee data validity at the database level - and bolster that reliability on the application side - you are much better off than just merely relying on the application.

Another reason was because I've found, when rewriting an application in Rails, the longer I can push forward keeping the original data structure intact the better. That way I can run both applications at the same time as I figure out the functionality of the first. In the ideal world, the functionality of the original app would be fully detailed in a spec somewhere. This project, unfortunately, was deeply rooted in the actual world.

The currently working Java application was using an ORM, just like Rails does. The ORM for this project was something from the Apache group called the ObjectRelationalBridge or OJB for short. I looked into the code to see how it was achieving this multi-table inheritance. Basically it was using a simple table to keep track of what the next unique id should be for a given 'type'. Some databases support sequences that do this, but not MySQL 3.

The name of the table was sequences and it looked roughly like this:





  sequences
  
    id
    type_name
    value
  
  
    1
    document
    5825
  


Whenever it was time to create a new Article, Book or Post, the database went to this table looking for the 'value' in the row with the 'type_name' = 'document', used that value to assign an id in a table corresponding to the object, and incremented the value. So the next Article would get an id of 5826 which would be stored in the id column of articles, the next Book would get an id of 5827 in the id column of books and so on. Pretty simple.

The other tables were structured something along these lines (this is a simplification):

projects

  id
  subject
  start_date
  end_date
  status

assignments

  id
  document_id
  document_type
  start_date
  end_date
  status
  project_id

articles

  id
  title
  author_id
  published

books

  id
  title
  author_id
  isbn

posts

  id
  title
  author_id
  slug

So how do I go about duplicating the functionality in Rails? Ideally, I'd like not to have to normalize all data into one big table, and ideally, I'd like to do something that doesn't mess with the internals of Rails, simply using the conventions that are already there. Over the years, I've found meddling with the internals of a framework can come back to bite you. Call me paranoid.
First Try
So, working in the most basic Rails idioms, I start off with something like this:




  class Project  < ActiveRecord::Base

      has_many :assignments

    end

    

    class Sequence  < ActiveRecord::Base

    end

    

    class Article  < ActiveRecord::Base

      before_create :generate_key

    

      def generate_key

        type_name = "document"

        key = Sequence.find(:first, :conditions => [ "type_name = ?", type_name])

        new_id = key.value + 1

        key.value = new_id

        key.save

        self.id = new_id

      end

    end

    

    class Book  < ActiveRecord::Base

      before_create :generate_key

    

      def generate_key

        type_name = "document"

        key = Sequence.find(:first, :conditions => [ "type_name = ?", type_name])

        new_id = key.value + 1

        key.value = new_id

        key.save

        self.id = new_id

      end

    end

    

    class Post  < ActiveRecord::Base

      before_create :generate_key

    

      def generate_key

        type_name = "document"

        key = Sequence.find(:first, :conditions => [ "type_name = ?", type_name])

        new_id = key.value + 1

        key.value = new_id

        key.save

        self.id = new_id

      end

    end


  
That will take care of those Document objects getting their correct id, then I just have to make the Assignment reference it. This will work fine as a belongs_to since there can only be one match per row.


  class Assignment  < ActiveRecord::Base

      belongs_to :project

    

      belongs_to :article, :foreign_key => 'document_id'

      belongs_to :book, :foreign_key => 'document_id'

      belongs_to :post, :foreign_key => 'document_id'

    end



That's all fine and good, but I wanted to clean up my code for 3 reasons:

  I've had to copy and paste the generate_key and before_create :generate_key code 3 times already. Not very DRY.
  There is nothing in the code itself to indicate that there is a relationship between a Book, an Article and a Post.
  I have to type in belongs_to for each type of object. I figure there must be a way to make this more succinct.



Second Try
First order of business: fix all those redundant generate_key methods. Well, how do you go about adding both class method (before_create) and an instance method to a class? Answer: a Module.
The Rails library likes to use the base.extend(SomeModule) convention by defining ClassMethods and InstanceMethods submodules. This works great and is a good convention to follow. If there are not many instance methods, though, I've found calling module_eval within ClassMethods will work just as well (see below).


  module GeneratedKey

    

      def self.included(base)

        base.extend(ClassMethods)

      end

    

        module ClassMethods

    

        def has_generated_key(object_name)

          object_name = object_name

    

          # add the before_create hook and make sure

          # we can access the object_name in instance

          # methods

          class_eval <<-CODE

               before_create :generate_key

    

               cattr_accessor :object_name

               @@object_name = object_name

          CODE

    

          # add the generate_key instance method

          # NOTE: i've skimmed over worrying about Symbol

          # vs. String for clarity

          module_eval <<-CODE

            def generate_key

              type_name = object_name.to_s

              key = Sequence.find(:first, :conditions => [ "type_name = ?", type_name])

              new_id = key.value + 1

              key.value = new_id

              key.save

              self.id = new_id

            end

          CODE

    

        end

      end

    

    end

  
  
This means when I put has_generated_key :some_value in the preface of a class definition, the class will call the generate_key function before it runs create to generate the id value from the sequences table. Now I can set up my classes using inheritance. The only odd thing about that is that I have to set the table name on subclasses (otherwise it will always look for a 'documents' table).


  class Document < ActiveRecord::Base

      include GeneratedKey

      has_generated_key :document

    end

    

    class Article < Document

        set_table_name "articles"

    end

    

    class Book < Document

      set_table_name "books"

    end

    

    class Post < Document

      set_table_name "posts"

    end


  
  
The only thing left is to clean up that belongs_to :book, belongs_to :article etc. stuff in the Assignment class. Once again, I can just factor it out into a module.

  
    module GenericAssociations

      

        def self.included(base)

          base.extend(ClassMethods)

        end

      

        module ClassMethods

      

          def belongs_to_type(object_name, implementations=[])

      

            object_name = object_name

      

            # take the array of implementations and do belongs_to for

            # each one

            implementations.each do |implementation|

              code = <<-CODE
        belongs_to  :#{implementation}, 

                                           :foreign_key => '#{object_name.to_s}_id'

                CODE

              class_eval code 

            end

      

            # build up an if for each type of object i.e. 

            # if article

            #   return self.article

            # end

            # if book

            #   return book

            # end

            # etc...

      

            if_loop = ""

            implementations.each do |implementation|

              if_loop += <<-CODE

                  if self.#{object_name.to_s}_type == "#{implementation}"

                     return self.#{implementation.to_s}

                  end

              CODE

            end

      

            # add the 'document' method

            code = <<-CODE

                 def #{object_name.to_s}

                    #{if_loop}

                 end

              CODE

      

            module_eval(code)

      

          end

      

        end

      

      end




This creates a method belongs_to_type that is called during class definition, taking the type (as a Symbol) and an Array of the allowable subclasses as parameters. It also adds a method whose name is derived from the type (in this case document) that will loop through all the values and pick out which kind it is based on a *_type field value. Now I can just write this code for my Assigment class:


  class Assignment < ActiveRecord::Base

       include GenericAssociations

      

        belongs_to :project, :foreign_key => 'project_id'

        belongs_to_type :document, [:book, :article, :post]

       end





So the only major surgery I might have had to do on the original database design was to add a document_type field to the assigments table. But that's it and, in my case, there was already a field by that name anyway because it was still necessary for the UI. Now I can write code like this to get the Document of an Assignment (and because of duck-typing - any field I need I can just reference when I need it):


   project = Project.find(1)

          

          project.assignments.each do |assignment|

            print assignment.document

          end




I can still retrieve only books, or only articles:


     articles = Article.find(:all)

       articles.each do |article|

         print article

       end

       

       books = Book.find(:all)

       books.each do |book|

         print book

       end

 
 
And I can still create an Article, Book or Post the same way I would any other object:



    article = Article.new

      article.save
  
  
Download files here: multi_table_article.zip
Note: The download includes a Rakefile in which you need to set up the db, username and password that matches your own. Then run rake. The default task runs some tests using a Ruby version of doctest, something from the Python world I'd like to see used in the Ruby world. The basic idea of doctest is that you can copy the results of an interactive interpreter session (in Ruby's case IRB) into comments in your Ruby code and rerun those transcripts as a form of regression testing. For example:

#doctest Check that 1 + 1 = 2
>> 1 + 1
=> 2
>> 2 + 3
=> 5
=end


I included a slightly modified version so that I could run the test from Rake. For a more official version see http://code.google.com/p/ruby-roger-useful-functions/wiki/DocTest