BuildingWebApps Articles

Web 2.0 Expo: TV and Radio with an API

2009-04-08T17:00:00Z

National Public Radio (NPR) is changing what it means to be a news organization. While traditional news organizations want to keep their content close, NPR has taken the approach of making content widely available via an API – an approach they call “brand and release.” They’ve made 250,000 stories, going back 13 years, available through their API.

Zack Brand from NPR said that the NPR API is getting about 2 million requests per month, and there are 1,300 registrants (you have to register to get access to the API). Content is available in a variety of formats; so far, 51% of requests use XML, 20% RSS, and 23% widgets.

(Another notable new organization that has been making some content available via an API is the New York Times, which has an article search API, among others.)

Also participating in this session was Robin Sloan from Current.tv. Current made interesting use of Twitter streams as part of its presidential debate coverage. The hash tag they created for people to tag their posts, #current, was the third most popular Twitter tag during the debates, bested only by the tags for the candidates themselves.

Current built an application to provide a mash up of various data sources, including Digg, on election day. In true agile fashion, they made multiple software updates even after the show began broadcasting!

Web 2.0 Expo: Web Developer Tools

2009-04-08T17:00:00Z

Ben Galbraith and Dio Almaer of Ajaxian and the developer tools group at Mozilla gave a wide-ranging talk on web developer tools. They noted that the web often seems more like a hack than a platform — it’s amazing that developers are able to make web apps do the things they do. This is especially true with Ajax raising the bar for interactivity, and sites turning into applications instead of documents. They’re out to make the web a better platform.

Some future technologies that have them excited:

HTML5 canvas
Fast JavaScript — kicked off by Chrome, Firefox’s TraceMonkey
Web workers, giving web apps the ability to have background threads
Desktop integration, such as Fluid, Prism, Adobe Air, and Titanium

As part of its efforts to improve the web as a platform, Mozilla is working on an open web tools directory, as well as a variety of development projects.

Ben and Dio noted that Firebug blew away existing tools and set a new standard for web development tools, providing a comprehensive set of tools in the browser itself. Other browsers have followed with IE8 and Safari 3.0 both providing good tools.

Mozilla Labs has a relatively new project called Bespin, a web-based code editor that is intended to be a showcase for HTML 5. This project is still young, and it won’t run on an flavor of IE for a while, but it looks very promising.

Mozilla Labs is also working on a grid-based layout system using JavaScript and HTML5 canvas; so far, there’s not much on the web site about this project, but an announcement is due soon.

Web 2.0 Expo: Social Media

2009-04-08T17:00:00Z

The conference sessions at Web 2.0 Expo had a major emphasis on social media. I only attended a couple of these talks, about which I have brief comments below; at the end of the article, I have links to several others.

Social Media Marketing – why it fails and how to fix it

This one felt somewhat remedial to me, with the essential points being:

Be authentic. You need to be a person, not just a representative of a company.
It’s hard to change the marketing culture in an organization to deal well with social media. (A point that I was glad to gloss over, being in my tiny organization that doesn’t have this sort of problem.)
It’s a conversation. (If in doubt, go read The Cluetrain Manifesto.)

The Whuffie Factor

Taking a completely different approach to similar material, Tara Hunt gave what I found to be the most inspiring and engaging talk of the conference: The Whuffie Factor.

Since both the slides and the video have been posted, I’ll let her speak for herself.

Slides

Whuffie at Web 2.0 Expo

View more presentations from Tara Hunt.

Video

The Whuffie Factor: The 5 Keys for Maxing Social Capital and Winning with Online Communities (Tara Hunt) from Steffan Antonas on Vimeo.

Other Social Media Talks

Web 2.0 Expo San Francisco Spring 2009

2009-04-05T17:00:00Z

March 31 – April 3, San Francisco

Last week’s Web 2.0 Expo seemed like a successful event, with a good-sized crowd despite the economic malaise – due in part, no doubt, to unusually aggressive discounting and promotion. With multiple tracks across four days (one day of workshops and three of conference sessions) there was much more to see than any one person could possibly attend.

Here’s a few articles that we’ve written about talks at the conference:

Many of the presentations are available online, as slides and/or videos:

And to go beyond the presentations and get more flavor of the event:

Enhancing Conditional Routing in Rails

2008-08-26T17:00:00Z

Rails’ routing infrastructure supports the concept of conditional routes: preconditions that must be satisfied before a particular route will trigger. Rails 2.1 supports one built-in condition, HTTP method checking, which is of some use but rather limited. What I needed was to be able to limit certain routes to only trigger when a particular host-name was used to access the application.

I thought I’d have to write messy additional logic until a little comment tucked away in ActionController::Routing::RouteSet and ActionController::Routing::Routing caught my eye. Here I briefly show you how to leverage this functionality for your own purposes.

The Goal — Conditional Routes in routes.rb

Let’s work backwards and see the result I was aiming for. I wanted to expand the existing capabilities of the routing engine and be able to restrict routes to specific hosts. The conditional routing option works by adding a parameter to your route specifications. Here are some examples:

map.with_options(:controller =&gt; 'feeds', :conditions =&gt; {:hosts =&gt; MY_HOSTS}) do |feed|
  feed.feeds_articles '/feeds/articles', :action =&gt; 'articles'
  feed.feeds_podcast '/feeds/podcast', :action =&gt; 'podcast'
end

map.resources :podcasts, :conditions =&gt; {:hosts =&gt; MY_HOSTS}, 
   :member =&gt; {:show_notes =&gt; :get, :transcript =&gt; :get},
   :collection =&gt; {:admin =&gt; :get} do |podcast|
     podcast.resources :comments, :member =&gt; {:report_as_ham =&gt; :get, :report_as_spam =&gt; :get}
   end

or even

map.connect ':controller/:action/:id', :conditions =&gt; {:hosts =&gt; MY_HOSTS}

In Rails 2.1, however, no such option :hosts exists, only an option to check the HTTP method via :method.

The Implementation

I haven’t really ever needed to use the conditional routing support before, and didn’t really think about it due to it only supporting the HTTP method check. For that reason, I originally thought I’d have to write my own logic, either patching existing Routing routines (nearly right!) or by writing new stuff that could get messy (bad idea).

During a last scan through the code for the keyword “conditions”, I saw this comment:

# Plugins may override this method to add other conditions, like checks on
# host, subdomain, and so forth. Note that changes here only affect route
# recognition, not generation.

Good, a place to start afterall! The solution is elegant as it only requires overriding two simple routines. You can do this in your own app by writing code that gets loaded at startup. Here is one implementation in its entirety:

require 'action_controller'

module ActionController
  module Routing
    class RouteSet
      def extract_request_environment(request)
        { :method =&gt; request.method, :host =&gt; request.host }
      end
    end

    class Route
      def recognition_conditions
        result = ["(match = #{Regexp.new(recognition_pattern).inspect}.match(path))"]
        result &lt;&lt; "conditions[:method] === env[:method]" if conditions[:method]
        result &lt;&lt; "conditions[:hosts].include?(env[:host])" if conditions[:hosts]
        result
      end
    end
  end
end

My code is very simplistic and tuned for my needs, but gives you an example of where to patch in. Here, I simply supply a list of host names I care about, and check the incoming host against that list.

Use extract_request_environment to parse out and store any data you will want to use in your conditional checks. This data will be available in the env hash later on.

recognition_conditions generates an Array of String objects that contain the Ruby code that will be used to build dynamic conditional test methods when the routing engine compiles the routes data in routes.rb.

I drop the source file into my project’s pre-existing lib/plugins/action_controller_extensions/lib directory as action_controller_extensions.rb and include an init.rb loader stub in my lib/plugins/action_controller_extensions directory:

require 'action_controller_extensions'

My app deals with loading up such “plugins” at startup. You may have a different set-up. You can get the same effect by putting a require for the main source file in your startup code.

It would be great to see other generally useful conditionals contributed by the community.

Startup Camp and Foo Camp

2008-07-20T17:00:00Z

I feel lucky to have been able to attend last week’s Startup Camp and Foo Camp. These are unusual, invitation-only events, with extraordinary collections of people. Getting an invitation requires some mix of accomplishment, connections, and luck.

They are exclusive events not for the sake of exclusivity, but because they only work at a limited size. O’Reilly Media, which hosts the events and foots the bill (there’s no registration fee), gets to pick the attendees from its diverse range of colleagues and contacts.

Startup Camp

This was the first-ever Startup Camp, created by O’Reilly’s venture fund, O’Reilly Alpha Tech Ventures. OATV set up a two-day program, with a variety of startup veterans to give talks and lead discussions, and invited startups to apply. We were fortunate to be one of the 7 startups accepted — doubly so because getting into Startup Camp provided a much-sought-after invitation to Foo Camp as well.

The companies invited to Startup Camp spanned an incredibly broad range, from custom jewelry for tweens (WhirlyBelle from Replicator) to open-source server management software (Puppet from Reductive Labs) and open-source synthetic biology (Ginkgo BioWorks).

The presenters included Tim O’Reilly and Dale Dougherty (O’Reilly), Bryce Roberts (OATV), Esther Dyson, Evan Williams (Blogger, Twitter), Marc Hedlund (Wesabe), Michael Arrington (TechCrunch), Mark Fletcher (Bloglines), Dave McClure (500 Hats), Howard Morgan (First Round Capital), and Kathy Sierra (Creating Passionate Users).

Since this was an off-the-record session, you won’t see much reporting of the content, and I can’t add much to that either. Keep it in mind next summer if you find yourself leading a new startup and want to apply.

Dave McClure’s Startup Metrics for Pirates presentation is one talk whose slides have been made public. And the “Entrepreneurial Proverbs” session was inspired by older blog posts by the two presenters, Evan Williams and Marc Hedlund.

Foo Camp

As exciting as Startup Camp was, it was a prelude to the much larger Foo Camp.

Foo Camp was created by Tim O’Reilly and his colleague Sara Winge in 2003, and John Battelle wrote one of the first articles about it. The name nominally stands for Friends Of O’Reilly, and it is also a play on the use of “foo” as a stand-in variable name in programming examples (a practice that, incidentally, dates back to the 1960’s). Tim wrote about why Foo Camp last year.

The business rationale for Foo Camp is that it gives the O’Reilly team the opportunity to talk with hundreds of leading-edge thinkers, as they look for ideas for books and conferences.

There’s actually camping at Foo Camp: while many attendees stay at local hotels, a lot of them camp on the back lawn, and inside the office buildings, at O’Reilly. (For me, it’s only a five-minute drive, since O’Reilly is in my home town of Sebastopol, CA.)

O’Reilly aims to have about 250 people at Foo Camp, which requires turning away a lot of past attendees so they can invite lots of new people each year.

Among the well-known entrepreneurs and technologists attending this year were Jimmy Wales, Joshua Schacter, Steven Souders, Adrian Holovaty, Tom Coates, Scott Berkun, Ze Frank, Dries Buytaert, and Caterina Fake. That’s just a random selection of the better known names. There were dozens of other well-known folks, and dozens more inspired, creative folks who have lower profiles.

Most of O’Reilly’s editors and conference directors were there, as well as many of its authors. OATV’s portfolio companies were also well represented.

Foo Camp popularized the “unconference” format, in which the attendees create the program. The sponsors provide a chart with a grid of rooms and meeting times, and the attendees fill it in as they desire.

The unconference format is best known from the proliferation of Bar Camps, which were inspired by the early Foo Camps. (More geek humor here, as in foobar.)

When this format was new, people were often hesitant to propose sessions, but no longer. The schedule board was 80% full within minutes. There’s so many parallel tracks, and so many fascinating people, that you can only see a fraction of what goes on and meet a scattering of people.

One of my favorite sessions was on The Future of News. Both news, as journalism, and newspapers, as businesses, are in a period of dramatic change and stress. Presenters included Monica Guzman of the Seattle Post-Intelligencer, John Markoff and
Nick Bilton from the New York Times, Steven Levy from NewsWeek, and
Carl Malamud.

Other interesting sessions I joined covered topics including ubiquitous computing, curation vs. crowd-sourcing, pragmatic thinking and learning (Andy Hunt), personal genomics (Esther Dyson, 23andMe), and aggregation vs. copyright.

Tim O’Reilly debated Michael Arrington on whether it is important for Microsoft to develop its own search technology, or if getting it from Yahoo is a reasonable strategy. Danny Sullivan moderated. And yes, that is an inflatable elephant.

Here’s the pair of blog posts that inspired this session:

Why Search Isn’t the Point, by Tim O’Reilly
The Importance of a Competitive Search Market, by Michael Arrington

Retrospection

I have no doubt that this event serves O’Reilly well, but it nevertheless is a great contribution to the community. Rarely is such a diverse collection of extraordinary people brought together under such casual, low-pressure surroundings.

Looking back on Foo Camp, there are so many people I wish I had been able to spend time with, and sessions I wish I had attended. I’ll just have to hope for another invitation in years to come.

As someone who spent a decade running conferences, I at first found the unconference format unsettling. The completely self-organizing nature of the event means that its quality is determined entirely by the attendees. But with a crowd like this one, that’s a good thing.

More Foo Stuff

Setting up Rails on Tiger (Mac OS X 10.4)

2008-07-19T17:00:00Z

This guide walks you through setup instructions for preparing a Mac OS X 10.4 (aka Tiger) development machine to be used for general Ruby on Rails coding. This baseline setup is what we use for our LearningRails online course.

You will end up with a development machine with the following baseline components:

Ruby and all basic Ruby utilities
Ruby Gems package manager
Subversion client
Git client
Native development tools (Xcode, C compiler)
MacPorts native code package manager
MySQL database client utilities and server
Gems for Ruby on Rails, Capistrano, Mongrel, Mongrel Cluster, and MySQL
Programmer’s editor or IDE

Note: In the command sequences we illustrate here, command line prompts are shown as a dollar sign ($).

Prerequisites

This guide assumes you have a Macintosh computer running the current Tiger operating system with up-to-date System Update patches applied. It also assumes you have not set up alternate Ruby on Rails tools prior to running through this guide. If you have, then small adjustments may be required as you walk through the following instructions.

You will need to have access to an Internet connection to complete various download steps.

You will need to have administrator access to your computer to complete this guide. We will be using the sudo command to run various command line programs and some of the Mac OS X native installers will also ask you for your password.

It is helpful if you have access to your operating system installation discs.

The Recipe

Follow this recipe in sequence. If you have previously installed a particular component, you can usually skip the associated step.

If you are planning on upgrading to Mac OS X 10.5 (Leopard), you should do so now and save some time setting up the Ruby environment. Leopard comes with a current version of Ruby and it makes setting things up much easier. If you follow this guide and then upgrade to Leopard later, it is pretty simple to deactivate (or remove) the redundant components that are no longer needed.

Native Development Tools (X11 and Xcode 2.5)

MacPorts will use native development tools when installing many of the utilities listed in this guide. You will also need a native compiler to build many of the gems’ native libraries you are going to use. Apple provides a free native compiler tool set called Xcode. If you have your Tiger installation DVD, load it now. If you don’t have an installation DVD, you can download the Xcode 2.5 tools at Apple’s Developer Web Site. (Note: Apple developer accounts are free.)

Open the Xcode Tools folder (or DMG file if you downloaded the package). Double click on the XcodeTools.mpkg installer and select a standard install. This will take a few minutes to run:

As an optional step, some tools require that the X11 window manager application be installed. Under Tiger, this is an optional install. You can find X11 on your Tiger installation DVD or download it from Apple.

MacPorts

MacPorts is a native code package manager for Macintosh software. This guide uses MacPorts to setup the Ruby tools, MySQL, and the Git distributed version control system. There are many other tools available in the MacPorts library, so it is well worth checking out.

Download the Tiger Universal version (1.6.0 at the time of this writing) and double click the MacPorts DMG file to open it up. Double click on “MacPorts-1.6.0.pkg” to start the installer and select the default options.

After MacPorts completes installation, you need to adjust your command line PATH environment variable so you can run the port command.

Fire up the Terminal program and enter the command:

	$ open .bash_profile

Note that there is a period in front of “bash_profile”. The bash shell configuration file should open in the TextEdit program. If you don’t have a .bash_profile, you can create a new one in your text editor and save it in your home directory.

(By the way, we recommend iTerm as a nice open source replacement to the Apple Terminal program.)

Inside of .bash_profile, find the line that starts with export PATH=, if present. You are going to insert the new directories used by MacPorts into your path:

	export PATH="/opt/local/bin:/opt/local/sbin:$PATH"

If you don’t have a line that exports your PATH, use the text exactly as above. If you do already have such a line, add the /opt/local/bin:/opt/local/sbin: (note colons) after the first quote, but before any other paths. Here is an example:

	export PATH="/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/local/sbin:$PATH"

Save the file and close TextEdit. Open a new terminal window and have MacPorts update itself with the command:

	$ sudo port selfupdate

Ruby and Ruby Utilities (irb, ri, rdoc)

Tiger comes pre-installed with a version of Ruby that is out of date for day to day use. You will use MacPorts to upgrade to the latest production version of the Ruby toolset. In a terminal window type:

	$ sudo port install ruby
	Password:
	---&gt;  Fetching ncursesw
	---&gt;  Attempting to fetch ncurses-5.6.tar.gz from http://ftp.gnu.org/gnu/ncurses
	---&gt;  Verifying checksum(s) for ncursesw
	---&gt;  Extracting ncursesw
	---&gt;  Applying patches to ncursesw
	---&gt;  Configuring ncursesw
	---&gt;  Building ncursesw with target all
	---&gt;  Staging ncursesw into destroot
...
	---&gt;  Installing ncurses 5.6_0+darwin_8
	---&gt;  Activating ncurses 5.6_0+darwin_8
	---&gt;  Cleaning ncurses
	---&gt;  Fetching openssl
	---&gt;  Attempting to fetch openssl-0.9.8e.tar.gz from http://www.openssl.org/source/
...
	---&gt;  Fetching ruby
	---&gt;  Attempting to fetch ruby-1.8.6.tar.gz from http://www.ibiblio.org/pub/languages/ruby/1.8
	---&gt;  Attempting to fetch ruby-1.8.6.tar.gz from http://mirrors.sunsite.dk/ruby/1.8
	---&gt;  Verifying checksum(s) for ruby
	---&gt;  Extracting ruby
	---&gt;  Applying patches to ruby
	---&gt;  Configuring ruby
	---&gt;  Building ruby with target all
	---&gt;  Staging ruby into destroot
	---&gt;  Packaging tgz archive for ruby 1.8.6_0+thread_hooks
	---&gt;  Installing ruby 1.8.6_0+thread_hooks
	---&gt;  Activating ruby 1.8.6_0+thread_hooks
	---&gt;  Cleaning ruby

Your output may be slightly different depending on the versions of software at the time you run these commands. The listing here was edited for brevity.

You can check that Ruby is installed with:

	$ which ruby
	/opt/local/bin/ruby
	$ ruby -v
	ruby 1.8.6 (2007-03-13 patchlevel 0) [powerpc-darwin8.11]

You should seem similar responses. The important one is the first one which reports back the path of the program. If you are using the MacPorts Ruby, it will be located in /opt/local/bin/.

Ruby Gems Package Manager

You next need to install the latest version of gem.

	$ sudo port install rb-rubygems rb-termios

Check the version that gets installed:

	$ gem -v
	0.9.4

You need 1.0.1 or newer. If you have an older version, you can update with the command line: sudo gem update --system.

Installing a Subversion client

Subversion will be used to access your source code repository during development and deployments. You will need a current version of the Subversion client and you can use MacPorts to install it:

	$ sudo port install subversion +tools

Installing Git via MacPorts

Git is all the rage in the Rails world now and has pretty much replaced Subversion as the version control system of choice. That said, both are in common use. Currently Leopard doesn’t install git by default, so we’ll use MacPorts to quickly install git:

 	$ sudo port install git-core +doc +svn

This command installs the core git tools, the man page documentation, and integration with Subversion. This last is useful if you plan on migrating from or need to work with a legacy Subversion repository. The installation will take a while; it has a lot to load.

Besides your own project version control, you’ll typically use git when loading Rails 2.1 and various 3rd party plugins.

Installing MySQL via MacPorts

By leveraging MacPorts to install MySQL, maintenance of the software is slightly easier, especially when you want to upgrade over time. We are using MySQL on our development machine as we prefer to have identical software across our environments. Rails 2.0.2, 2.1, and newer uses SQLite by default, which is fine for development and experimentation, but not appropriate for production code.

To get started, type into your terminal window:

	$ sudo port install mysql5 +server

This command downloads and installs the baseline MySQL client programs and server software. Next, you want to configure MySQL’s server so it launches when your computer boots up:

	$ sudo launchctl load -w /Library/LaunchDaemons/org.macports.mysql5.plist

launchctl is an Apple tool that administers the system daemon that controls the boot process and background programs. Here you are loading the instructions for how to manage MySQL.

A fresh MySQL installation requires its database storage area to be initialized, so you do that next:

	$ sudo mysql_install_db5 --user=mysql

When you configure the storage area with this command, you’re making sure it is owned by the user “mysql”.

MySQL creates a special system file used for program to program communication, called the “socket” file. By default, the MacPorts installation of MySQL server creates this in the directory “/opt/local/var/run/mysql5/mysqld.sock”. Ruby on Rails applications can deal with this just fine if you change the settings in your database.yml file to include a socket entry that points to the correct place. However, we are going to tweak things so all applications can find the file in a fairly standard place: /tmp/mysql.sock with little or no modification.

First, you need to move the default configuration file, my.cnf, to the correct place:

	$ sudo mv /opt/local/etc/my.cnf /opt/local/etc/mysql5/my.cnf

If the installation program didn’t put a file into /opt/local/etc/, try this instead:

	$ sudo mv /opt/local/share/mysql5/mysql/my-medium.cnf /opt/local/etc/mysql5/my.cnf

Now, you need to edit the configuration file to change where the socket file is stored:

	$ sudo pico /opt/local/etc/mysql5/my.cnf

If you aren’t familiar with the pico command line editor, we explain the few commands you will need here.

Inside of pico, use your arrow keys to move down to the line where you first see “[client]” and make the following changes (this is just a small part of the whole file):

	...
	# In this file, you can use all long options that a program supports.
	# If you want to know which options a program supports, run the program
	# with the "--help" option.
	
	[mysqld_safe]
	socket          = /tmp/mysql.sock

	# The following options will be passed to all MySQL clients
	[client]
	#password       = your_password
	port            = 3306
	socket          = /tmp/mysql.sock

	# Here follows entries for some specific programs

	# The MySQL server
	[mysqld]
	port            = 3306
	socket          = /tmp/mysql.sock
	...

You are adding the “[mysqld_safe]” section (2 lines) just above “[client]” and then changing the two instances of the "socket = " lines in the “[client]” and “[mysqld]” sections to be /tmp/mysql.sock. Once done, press Control-X, answer Y when asked to save, and press return to accept the default file name (“my.cnf”).

Now you start the server up manually:

	$ cd /opt/local ; sudo /opt/local/lib/mysql5/bin/mysqld_safe &amp;

You can confirm that MySQL is running by trying to fire it up:

	$ mysql5 -p -u root
	Welcome to the MySQL monitor.  Commands end with ; or \g.
	Your MySQL connection id is 1
	Server version: 5.0.45 Source distribution

	Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

	mysql&gt; exit

When you reboot your computer, MySQL should start automatically in the future.

Gems

Tiger requires that you install the base collection of gems you will be using:

	$ sudo gem install rake rails capistrano mongrel mongrel_cluster

All installed gems (including Ruby on Rails and its dependencies, Rake, Capistrano, Mongrel, and Mongrel_Cluster) will get installed at their latest versions.

The MySQL adapter gem needs to be installed, and it is a little finicky due to our use of MacPorts.

If you are running Tiger on an Intel processor, use this command (on one line):

	$ ARCHFLAGS="-arch i386" sudo gem install mysql -- --with-mysql-config=/opt/local/bin/mysql_config5

and if you are on a PowerPC processor, use this command:

	ARCHFLAGS="-arch ppc" sudo gem install mysql -- --with-mysql-config=/opt/local/bin/mysql_config5

Once the command completes, you should be all set with the baseline gems you will need for the LearningRails courses.

Code Editing Tools

While you can get by with using a plain text editor like TextEdit, or even Apples Xcode IDE, you will have much high productivity if you use a programming editor that is highly tuned to Ruby on Rails development.

We use the commercial TextMate programmer’s editor for much of our day to day work. TextMate is highly extensible through a collection of community supplied “bundles”. Many add-ons accelerate development by enhancing the editor (for example, adding language specific short cuts to reduce your typing) or by tying in to other utilities, such as Subversion or Rake, to allow you to quickly get tasks done without leaving the editor’s environment.

There are a variety of good open source or free programmer editors available too. On the open source side, Leopard comes pre-installed with both vim and emacs. jEdit is a very extensible open source editor written in Java. TextWrangler is a free programmer’s editor from BareBones.

Whatever editor you choose, be certain that it provides easy navigation among a large number of open files. Working with Rails applications generally involves dealing with a lot of small files, and that process needs to be efficient.

If you prefer an all-in-one tool, you should look at one of several integrated development environments that exist for Ruby. We use Netbeans in our LearningRails courses, but you should check out the numerous other options listed at BuildingWebApps.com.

Setting up Rails on Leopard (Mac OS X 10.5)

2008-07-18T17:00:00Z

This guide walks you through setup instructions for preparing a Mac OS X 10.5 (aka Leopard) development machine to be used for general Ruby on Rails coding. This baseline setup is what we use for our LearningRails online course.

You will end up with a development machine with the following baseline components:

Ruby and all basic Ruby utilities
Ruby Gems package manager
Subversion client
Git client
Native development tools (Xcode, C compiler)
MacPorts native code package manager
MySQL database client utilities and server
Gems for Ruby on Rails, Capistrano, Mongrel, Mongrel Cluster, and MySQL
Programmer’s editor or IDE

Note: In the command sequences we illustrate here, command line prompts are shown as a dollar sign ($).

Prerequisites

This guide assumes you have a Macintosh computer running the current Leopard operating system with up-to-date System Update patches applied. It also assumes you have not set up alternate Ruby on Rails tools prior to running through this guide. If you have, then small adjustments may be required as you walk through the following instructions.

You will need to have access to an Internet connection to complete various download steps.

It is helpful if you have access to your operating system installation discs.

The Recipe

Follow this recipe in sequence. If you have previously installed a particular component, you can usually skip the associated step.

Ruby and Ruby Utilities (irb, ri, rdoc)

Leopard comes pre-installed with Ruby 1.8.6 and its associated utilities. You can use these programs as is. To check them out, open a Terminal window and type:

	$ which ruby
	/usr/bin/ruby
	$ ruby -v
	ruby 1.8.6 (2007-09-24 patchlevel 111) [universal-darwin9.0]

You should seem similar responses. The important one is the first one which reports back the path of the Ruby interpreter program. If you are using the built-in Ruby, it will be located in /usr/bin/.

Ruby Gems Package Manager

Leopard comes with a pre-installed version of gem. Be sure you have the latest version:

	$ gem -v
	1.0.1

You need 1.0.1 or newer. If you have an older version, you can update with the command line: sudo gem update --system.

Native Development Tools (Xcode 3.0)

You will need a native compiler to build many of the gems’ native libraries you are going to use. You will also occasionally build other native tools via the MacPorts tool described below. Apple provides a free native compiler tool set called Xcode. If you have your Leopard installation DVD, load it now. If you don’t have an installation DVD, you can download the Xcode 3.0 tools at Apple’s Developer Web Site. (Note: Apple developer accounts are free.)

Open the Optional Installs folder, and then the Xcode Tools folder. Double click on the XcodeTools.mpkg installer and select a standard install. This will take a few minutes to run:

MacPorts

MacPorts is a native code package manager for Macintosh software. This guide uses MacPorts to setup an installation of MySQL and the Git distributed version control system. There are many other tools available in the MacPorts library, so it is well worth checking out.

Download the Leopard Universal version (1.6.0 at the time of this writing) and double click the MacPorts DMG file to open it up. Double click on “MacPorts-1.6.0.pkg” to start the installer and select the default options.

After MacPorts completes installation, you need to adjust your command line PATH environment variable so you can run the port command.

Fire up the Terminal program and enter the command:

	$ open .bash_profile

(By the way, we recommend iTerm as a nice open source replacement for the Apple Terminal program.)

Inside of .bash_profile, find the line that starts with export PATH=, if present. You are going to insert the new directories used by MacPorts into your path:

	export PATH="/opt/local/bin:/opt/local/sbin:$PATH"

	export PATH="/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/local/sbin:$PATH"

Save the file and close TextEdit. Open a new terminal window and have MacPorts update itself with the command:

	$ sudo port selfupdate

Installing Git via MacPorts

 	$ sudo port install git-core +doc +svn

Besides your own project version control, you’ll typically use git when loading Rails 2.1 and various 3rd party plugins.

Installing MySQL via MacPorts

By leveraging MacPorts to install MySQL, maintenance of the software is slightly easier, especially when you want to upgrade over time. We are using MySQL on our development machine as we prefer to have identical software across our environments. Rails 2.0.2, 2.1 and newer uses SQLite by default, which is fine for development and experimentation, but not appropriate for production code.

To get started, type into your terminal window:

	$ sudo port install mysql5 +server

This command downloads and installs the baseline MySQL client programs and server software. Next, you want to configure MySQL’s server so it launches when your computer boots up:

	$ sudo launchctl load -w /Library/LaunchDaemons/org.macports.mysql5.plist

launchctl is an Apple tool that administers the system daemon that controls the boot process and background programs. Here you are loading the instructions for how to manage MySQL.

A fresh MySQL installation requires its database storage area to be initialized, so you do that next:

	$ sudo mysql_install_db5 --user=mysql

When you configure the storage area with this command, you’re making sure it is owned by the user “mysql”.

First, you need to move the default configuration file, my.cnf, to the correct place:

	$ sudo mv /opt/local/etc/my.cnf /opt/local/etc/mysql5/my.cnf

If the installation program didn’t put a file into /opt/local/etc/, try this instead:

	$ sudo mv /opt/local/share/mysql5/mysql/my-medium.cnf /opt/local/etc/mysql5/my.cnf

Now, you need to edit the configuration file to change where the socket file is stored:

	$ sudo pico /opt/local/etc/mysql5/my.cnf

If you aren’t familiar with the pico command line editor, we explain the few commands you will need here.

Inside of pico, use your arrow keys to move down to the line where you first see “[client]” and make the following changes (this is just a small part of the whole file):

	...
	# In this file, you can use all long options that a program supports.
	# If you want to know which options a program supports, run the program
	# with the "--help" option.
	
	[mysqld_safe]
	socket          = /tmp/mysql.sock

	# The following options will be passed to all MySQL clients
	[client]
	#password       = your_password
	port            = 3306
	socket          = /tmp/mysql.sock

	# Here follows entries for some specific programs

	# The MySQL server
	[mysqld]
	port            = 3306
	socket          = /tmp/mysql.sock
	...

Now you start the server up manually:

	$ cd /opt/local ; sudo /opt/local/lib/mysql5/bin/mysqld_safe &amp;

You can confirm that MySQL is running by trying to fire it up:

	$ mysql5 -p -u root
	Welcome to the MySQL monitor.  Commands end with ; or \g.
	Your MySQL connection id is 1
	Server version: 5.0.45 Source distribution

	Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

	mysql&gt; exit

When you reboot your computer, MySQL should start automatically in the future.

Gems

Leopard conveniently pre-installs the base collection of gems you will be using, but you need to make sure they are up to date:

	$ sudo gem update

All installed gems (including Ruby on Rails and its dependencies, Rake, Capistrano, Mongrel, and Mongrel_Cluster) will get updated.

The MySQL adapter gem needs to be installed, and it is a little finicky due to our use of MacPorts.

If you are running Leopard on an Intel processor, use this command (on one line):

	$ ARCHFLAGS="-arch i386" sudo gem install mysql -- --with-mysql-config=/opt/local/bin/mysql_config5

and if you are on a PowerPC processor, use this command:

	ARCHFLAGS="-arch ppc" sudo gem install mysql -- --with-mysql-config=/opt/local/bin/mysql_config5

Once the command completes, you should be all set with the baseline gems you will need for the LearningRails courses.

Code Editing Tools

While you can get by with using a plain text editor like TextEdit, or even Apple’s Xcode IDE, you will be more productive if you use a programming editor that is highly tuned to Ruby on Rails development.

We use the commercial TextMate programmer’s editor for much of our day-to-day work. TextMate is highly extensible through a collection of community supplied “bundles”. Many add-ons accelerate development by enhancing the editor (for example, adding language specific short cuts to reduce your typing) or by tying in to other utilities, such as Subversion or Rake, to allow you to quickly get tasks done without leaving the editor’s environment.

If you prefer an all-in-one tool, ook at one of the integrated development environments for Ruby. We use Netbeans when we aren’t using TextMate, but the numerous other options listed at BuildingWebApps.com are worth a look.

Podcasts and Screencasts on Ruby on Rails

2008-06-17T17:00:00Z

There’s a variety of screencasts and podcasts available for Ruby on Rails developers. Here’s a quick rundown of the major ones, and how they differ.

Podcasts

Audio podcasts are great for listening on the go, and for things such as news and interviews.

Tutorial: Learning Rails

Our own Learning Rails series consists of 8 podcasts that cover the fundamental concepts behind Ruby on Rails.

People: Ruby on Rails Podcast

The longest-running podcast in the Rails world is the “official” Ruby on Rails podcast, first created by Scott Barron but produced for most of its life by Geoffrey Grosenbach. This is a great series of interviews with many of the leading developers in the Ruby and Rails world.

News: Rails Envy

The Rails Envy podcast comes out every week and provides a fantastic summary of the latest developments in the Rails world. It’s put together by Gregg Pollack, Jason Seifer, and Steven Bristol, who diligently track a wide variety of Rails blogs to provide you with a distilled and entertaining weekly update.

Screencasts

Screencasts let you watch what’s going on on the screen while the presenter explains what they’re doing. It’s like looking over the shoulder of a developer while they work. Screencasts are a great teaching tool.

Learning Rails

Our Learning Rails screencast series shows how to build a simple web site using Ruby on Rails, step-by-step. Designed for people who are new to Ruby on Rails.

Envycasts

Envycasts is the latest entrant into the Rails screencasts business. They’re created by the Rails Envy folks, Gregg Pollack and Jason Seifer, who bring their trademark wit and creative production to advanced technical screencasts. There’s nothing else like them. Priced at $9 each.

Railscasts

Ryan Bates has producing more than 100 free Railscasts screencasts. They’re short episodes focused on a single feature of Rails, and are a great way to learn how to do specific things with Rails.

Peepcode

Geoffrey Grosenbach’s Peepcode are the gold standard for Ruby on Rails screencasts. At $9 each, they aren’t free, but they’re still a great value. They’re typically about an hour long and deeply explore specific topics, from Git to rSpec.

Pragmatic Screencasts

The Pragmatic Programmer, well known for their Ruby and Rails books, has teamed with Mike Clark of Pragmatic Studio, a leading provider of Rails training, to produce the Pragmatic Screencasts. The 20 to 30 minutes screencasts cost $5 each. So far, most of them are not about Ruby or Rails, but there is a series by Ryan Bates on “Everyday Active Record.”

RubyPlus

Bala Paranj has produce more than 70 free screencasts on various Ruby and Ruby on Rails techniques at RubyPlus.org.

Coderpath

Miles K. Forrest recorded a few early Rails screencasts at coderpath a couple years ago. He’s been quiet since, but he’s talking about restarting the series.

Zenunit Sensei

A short series of Rails screencasts, free for now with some talk of paid screencasts in the future, at Zenunit Sensei. From Australia, apparently by Julian Leviston.

The Rebuilding and Scaling of YellowPages.com

2008-06-01T17:00:00Z

John Straw, chief software architect at YellowPages.com, gave an excellent talk at RailsConf about YellowPages’ conversion to Rails. We’ve pointed to YellowPages in the past as being one of the highest-traffic Rails sites, proving that Rails can scale.

John’s talk covered the scaling issues, but the talk was just as much about the process of successfully doing a big rewrite of a critical application at a large company. (YellowPages.com is part of AT&T.)

You can download John’s presentation from the RailsConf site.

With 2.5M searches per day and more than 170 million page views per month, YellowPages.com is now the biggest site AT&T runs, generating more traffic than att.com.

Why the rewrite?

The previous version was written in Java in 2004 and 2005 by consultants, and had fundamental design problems. This version had 125K lines of code and no automated tests, making new features hard to implement. The Rails version ended up with fewer than 20K lines of code, including tests.

The Java site also had lots of usability issues and SEO problems. As an example of the difficulty of adding features, John noted that it took three months to add a rating feature.

The requirements for the new version included:

Absolute control of URLs
No sessions
Be agile
Develop easy-to-leverage core business services

The new product was built by a cross-functional team of 20 people, including project managers, user experience experts, advertising people, search experts, and content and community managers. There were never more than 5 developers. The entire team sat together for the duration of the project.

The architecture they designed has three tiers: a web tier that delivers the front-end web experience; a services tier that responds to requests from the web tier; and a search cluster that performs the actual searches.

The team built an initial Rails prototype in early 2007 that looked like the existing site, just to get some experience with Rails. (Only one of the team members had any prior Rails experience.) They also built prototype search code in Python. They then started a new Rails prototype with designs from user experience team. They also built a Django prototype to explore that option, and evaluated EJB3/JBoss as a service tier platform.

Why Rails?

The team rejected Java for the front end in part because of its inadequate URL control. In terms of Rails vs. Django, John called the decision a near toss-up. Platform maturity was an important attribute that led them to choose Rails. They also felt that it had better automated testing integration and a clearer path to moving parts of it to C if necessary for performance. Ultimately, the development team simply felt more comfortable with it.

John had initially expected they would use Java for the service tier, but after an evaluation of EJB3 the team felt there were no real advantages over Ruby or Python for their application. All the reasons for choosing Rails for the web tier applied equally to service tier, and having a single software environment has obvious advantages.

Keeping the project moving

The success of this rewrite had as much to do with adeptly managing the process as with technology. One key to keeping it moving was giving one person decision-making authority. Another important factor was freezing development on the existing site, so they wouldn’t have a moving target. An ad-hoc rule they came up with was that if you can’t figure out quickly how you’d like to change something about the existing site, then don’t change it.

Another important process was early and frequent communication with the sales team. A previous site redesign had nearly failed because of lack of support from sales. The project lead, who came from the user experience team, met with 20 to 40 salespeople a week to review the proposed changes. This gave them the buy-in they needed for the site to be successful from a business perspective.

The site was made available to friends and family as a closed beta on 4/26/07, an open beta on 5/17/07, and then went live at the end of June, less than six months after beginning work on their first Rails prototype. This was the first time AT&T had released a beta of any kind.

A few things were farmed out to other teams, including HTML/CSS coding, rewrite rules for legacy URL translation, and performance evaluation for the production deployment configuration.

System architecture

The web tier, service tier, and search cluster are each fronted by an F5 load balancer. The web tier initially used Apache with 16 Mongrels on each server, while the service tier uses Apache with 30 Mongrels and memcached on each server.

The communication between tiers uses stateless HTTP transactions. The service tier provides a set of RESTful services that return JSON to the web tier. The search cluster uses the FAST ESP search engine.

The entire system consists of 25 machines, each with two dual-core, 64-bit processors. Two of the 25 are used for the database. This compares to 21 servers for the previous Java-based solution. There are two data centers with identical setups; each is designed to handle the entire load, so they provide geographically distributed redundancy.

They run Solaris on the database machines and CentOS 5 on all the others. John called Solaris “a mistake they wouldn’t repeat,” not because of any particular problems with it but because of a lack of system administrators in their organization who had experience with it.

They use Oracle for the database engine, which had issues with the large numbers of connections created by the large number of Mongrels. As a result, memory usage on the database servers was high, and these machines were upgraded to 12G of RAM.

Performance optimization

The performance goals, which were achieved, were:

Sub-second home page load time
4-second average search time
Never dies

In the course of performance optimization, they considered HAProxy and Swiftiply but chose to go with the F5 because they had the hardware and understood how to use it.

They wrote Mongrel handlers to pick requests off from the web tier and send them to the service tier without involving Rails. They also wrote a C library for parsing search cluster responses and turning them into hashes.

In the web tier, they switched to Erubis for rendering views. They found asset download times to be a bigger issue than the speed of the framework. Following the Yahoo performance guidelines, they minified the JavaScript. They also switched from Prototype to jQuery.

They used the asset_packager plug-in (now made obsolete by Rails 2) and moved image serving to an Akamai edge cache.

They found that Apache was slow serving the 42-byte single-pixel GIFs that they use as analytics tags, which drove a shift to Nginx for the web tier.

After this tuning, performance was better than the Java site. In terms of availability, all site availability issues in first six months were due to database problems.

All things considered, it was a very successful rewrite. While the problems with the prior Java site cannot all be blamed on the technology, it is clear that Rails gave the team significant advantages with no loss of performance.

New Crop of Rails 2.0 Books

2008-05-28T17:00:00Z

In 2007, more than a dozen Ruby on Rails books debuted — only to be almost instantly made out-of-date by the release of Rails 2 toward the end of the year. In many respects, books written for Rails 1.2 are usable with Rails 2.0, but they can be problematic. If they use the scaffold generator in their examples, or dynamic scaffolding, the examples simply won’t work as written. And there are many small ways, such as the enhanced syntax for migrations, in which a Rails 1.2 book will teach a way that works, but is no longer optimal.

There are now some great Rails 2.0 books out, making life a lot easier for new and experienced Ruby on Rails programmers. Here’s a quick rundown of the recent books.

For Beginners

If you’re new to Rails and don’t have a lot of programming experience, Patrick Lenz’s Simply Rails 2 provides a great start. It explains all the concepts clearly and doesn’t assume much software development background. The example site built throughout the book is a Digg clone, which serves well to illustrate all the key topics.

Getting Started with Rails, for Experienced Developers

If you have some web application and object-oriented programming experience, then you may want a book that goes deeper and explains things more fully, but doesn’t take time to explain programming basics. Agile Web Development with Rails, which was for some time the only Rails book, is a great book for developers with some experience.

The second edition of this book, which is the newest available in print, is based on Rails 1.2, and the nicely detailed “Depot” shopping-cart example fails under Rails 2.0. The depth of this book also creates many places where the differences between the versions is significant.

Fortunately, the third edition is now available as a beta book. You can download today’s version as a PDF file, in which most of the critical updates have already been made, which comes with frequent updates, and also pre-order a printed copy so you’ll have one as soon it comes out the fall.

Going Deeper

After a slew of tutorial books in 2007, most of which are written for Rails 1.2, there’s been a recent surge in deeper, more advanced books that add a tremendous richness to the available Rails books.

The Rails Way is great reference work for Rails developers. It is not a book to start with, but it’s one I’d want to have by my side for reference once I had my bearings.

Advanced Rails Recipes includes dozens of short, focused articles explaining how to accomplish a particular Rails task. There’s a tremendous amount of accumulated community knowledge in this book, which was written by Mike Clark with contributions from many people in the community.

Practical REST on Rails 2 Projects, by Ben Scofield, is the first book to deeply explore the use of RESTful web services as implemented in Rails 2. It even includes an example of a Facebook application.

Deploying Rails Applications is the first book to really tackle Rails deployment in all of its complexities. With a cast of authors that includes Ezra Zygmuntowicz, Bruce Tate, Clinton Begin, Geoffrey Grosenbach, and Brian Hogan, this book encapsulates a lot of hard-earned knowledge and will save a lot of people a lot of pain.

Easy Text Formatting with Textile

2008-05-09T17:00:00Z

When I’m writing content for the web, I hate dealing with HTML coding. HTML is rather verbose as a markup language, and having to include closing tags is messy and error-prone.

We’re all pretty much stuck with delivering HTML code from our web sites, but that doesn’t mean we have to write in it. There are various markup approaches that are superior to HTML when it comes to content creation, and which can be used as source code from which to create HTML. Two that are widely used are Textile and Markdown.

Textile was originally developed by Dean Allen for the TextPattern content management system and is now widely used in wikis and blogs. Markdown, created by John Gruber and Aaron Swartz, is an alternative that is conceptually similar but with a different syntax. Many of the popular blog engines provide a choice of Textile or Markdown (or HTML) for posts and comments (this site offers Textile).

In this article, I’ll show the basics of Textile markup and how easy it is to use it in Rails applications.

What is Textile?

Textile strives to make text markup as clean and simple as possible. You don’t have to put <p> in front of each paragraph; bare text is automatically surrounded by <p> and </p> tags. To make a first-level heading, just start the line with @h1. @. For example:

h1. This is a heading and will be wrapped in &lt;h1&gt; and &lt;/h1&gt; tags

This is a text paragraph and will be wrapped in &lt;p&gt; and &lt;/p&gt; tags.

This is another paragraph.

And I bet you can guess how to make a second-level heading, or a third-level heading.

You never need to use close tags; a pair of carriage returns automatically triggers the appropriate end tag. Quotes are automatically converted to open and close quotes; hyphens are converted to n-dashes (if there is a space on either side); and double hyphens are converted to m-dashes.

To make text bold, surround it with asterisks; to make it italic, with underscores:

*This text will render in bold*
_This text will render in italic*
_*This text will render in bold italic*_

To add a link to a piece of text, surround the text in quotes, and follow it by a colon and the URL:

"text to be linked":http://thisistheurl.com

To include an image, type its URL surrounded by exclamation points:

!http://domain.com/path/to/image.jpg!

To create a bullet list, start each line with an asterisk and a space, like this:

* First item
* Second item
* Third item

Want a nested bullet list? Just indent the asterisk by three spaces.

There’s more, but this should give you a feel for it. You can also use any HTML you want for things that Textile doesn’t cover — HTML code is simply passed through. For more details, see the Textile Reference. You can try out Textile online at the Textile home page.

Implementing Textile

There are Textile implementations for various environments. In my case, using Ruby on Rails, Textile is implemented by whytheluckystiff ’s RedCloth gem. (The current implementation does have some flaws, and a much-enhanced version called Super RedCloth is in development.) To install, just enter the following in the console:

gem install RedCloth

With RedCloth installed, you create a new RedCloth object and pass some Textile-marked-up text to it:

textile_styled_text ="h1. This is an example of a heading in Textile"
textile_object = RedCloth.new(textile_styled_text)

Then, when you want to render this as HTML, you simply use:

html = textile_object.to_html

Making Textile Even Easier

That’s pretty easy, but you can make it even easier. There’s a Rails helper “textilize,” but thanks to the acts_as_textiled plug from Chris Wanstrath, it’s even easier than that. Install this plugin:

ruby script/plugin install
 svn://errtheblog.com/svn/plugins/acts_as_textiled

And then all you have to do is declare a model attribute as Textile-formatted in your model class:

acts_as_textiled  :field_name

That’s it — everything just works! (Remember, though, that you need to restart the server for the model change to take effect.) Textile marked up text is stored in the database. Form fields automatically show unrendered textile. But any other use of the model attribute automatically delivers the rendered HTML instead of the Textile source.

Markup without Coding

You can also simplify the entry of Textile markup by using the textile_editor_helper from Dave Olsen and Chris Scharf. This plug-in renders a set of icons for the common markup tasks in your form view, just above the text entry area:

When you click an icon, JavaScript code inserts the appropriate markup into your text.

To use this, first install the plugin:

ruby script/plugin install
 http://svn.webtest.wvu.edu/repos/rails/plugins/textile_editor_helper

rake textile_editor_helper:install

And then replace the text_area tag in the form in which the user enters the Textile-formatted text with textile_editor:

&lt;%= textile_editor 'object', 'field' -%&gt;

textile_editor takes all the same options as text_area.

and at the end of the form add:

&lt;%= textile_editor_initialize -%&gt;

Finally, if you don’t already include prototype.js, you’ll need to add that to your layout:

&lt;%= javascript_include_tag 'prototype.js' %&gt;

Presto! Now you have a row of icons above the text area so your users don’t have to remember any markup at all. They’ll still see the markup in the text area (this is not a wysiwyg editor), which will help them learn the markup code.

Web 2.0 Expo Highlights and Factoids

2008-04-28T17:00:00Z

Last week’s Web 2.0 Expo had an overwhelming amount of content. Like any large conference, the quality was uneven, but there were some great talks and a lot of good ones. Among the main-session talks, Clay Shirky gave a wonderful talk on the implications of the web. I especially liked his view on the “cognitive surplus” created by the shift from rural to urban lifestyles, and how this has historically been consumed by alcohol, and then by television. Now this cognitive surplus fuels wikipedia, and all the other forms of user participation on the web. Where does the time come from? Just a fraction of the time spent watching television.

I’m halfway through his new book, Here Comes Everybody: The Power of Organizing without Organizations, and it promises to be a worthwhile read.

The most entertaining talk of the conference, by a long shot, was from Fake Steve Jobs, also known as Dan Lyons in his day job at Forbes. The Secret Diary of Steve Jobs is one of the best pieces of technology satire around.

Video of Dan’s talk at Web 2.0.

Videos of all the other keynote presentations are also available.

Among the most technical talks, and the only one with any real Ruby on Rails content, was Gregg Pollack’s excellent talk on The Art of Testing Web Applications. (We proposed several Rails-related talks, but they didn’t make the cut; apparently the organizers chose to avoid most technology-specific talks this year.)

Many of the presentation files have been posted, and more are likely to be added soon.

Here’s an assortment of random factoids from my notes:

70% of current.com users are on their computer at the same time they’re watching TV
There’s 2.43 billion photos on flickr
28 million people a month share a video on YouTube
MySQL is downloaded 70,000 times a day

AIM stats:
- Delivers 2 billion instant messages every day
- Has had as many as 14 million simultaneous users
- AIM sees a usage drop when there’s a popular show on TV, and then a peak when it ends

Ning stats:
- Ning has about 250,000 individual social networks
- 70% of the networks are active (used in last 30 days)
- Adding 1 million registered users per month
- Adding 1,500 new networks a day

MySpace stats:
- 117M unique users last month
- 100 billion rows of data in the database
- 85 gigs of bandwidth
- 5 million concurrent users
- 200K to 400K new users per day
- 11% of all on-line minutes are spent on myspace
- 50 million messages sent per day

WordPress stats:
- 54 million unique visitors in the U.S. each month — one in four people
- 99.999% of WordPress blogs receive under 10,000 pageviews a day
- In aggregate, there are 10+ million pageviews a day to permalink pages (45% of traffic)
- An amount of content equivalent to 1.5 wikipedias is created on WordPress each month

Tim Bray: Ruby is the Leading Language for Web Applications

2008-04-24T17:00:00Z

In his keynote talk at the recent Silicon Valley Ruby Conference, Sun’s Tim Bray asserted that “PHP and Ruby are the languages of choice for new web apps.” Coming from most people, this wouldn’t be a remarkable comment, but given that Tim is Sun’s director of web technologies, it is worthy of note. Java wasn’t even on Tim’s list, much less his recommended solution.

Tim raised two major concerns about PHP: security and maintainability. He also pointed out that the object-oriented features “seem bolted on,” and don’t feel right as compared to Ruby. He did note that there are some great PHP applications, such as MediaWiki, WordPress, and Drupal.

Tim asserted that Rails is ahead of Java in terms of maintainability because you have so much less code. And, of course, Rails is best for time to market, which can be all-important to the success of a project.

As for when to avoid Rails, Tim cited these situations:

If the IT group will only deploy Java or .NET
When you need a lot of experienced developers quickly
If you have a complex database schema you don’t control
For an application that does a lot of computation

Tim asserted that “waterfall development just doesn’t work any more.” Some principles for success he cited:

Be human
Update often
Link
Don’t try to be sticky
Look good
Balance hubris and humility
Free the conversation

Setting up Rails on Windows XP

2008-04-22T17:00:00Z

This guide walks you through setup instructions for preparing a Windows XP development machine to be used for general Ruby on Rails coding. This baseline setup is what we use for our LearningRails online course.

You will end up with a development machine with the following baseline components:

Ruby and all basic Ruby utilities
Ruby Gems package manager
Subversion client
MySQL database client utilities and server
Gems for Ruby on Rails, Capistrano, Mongrel, Mongrel Cluster, and MySQL
SSH Terminal Program
Git client (UPDATED)
Programmer’s editor or IDE

Note: In the command sequences we illustrate here, command line prompts are shown as C:\>.

Prerequisites

This guide assumes you have a Windows computer running the current Windows XP operating system with up-to-date service patches applied (SP2 or higher). It also assumes you have not set up alternate Ruby on Rails tools prior to running through this guide. If you have, then small adjustments may be required as you walk through the following instructions.

You will need to have access to an Internet connection to complete various download steps.

You will need to have administrator access to your computer to complete this guide. Some of the Windows installers may ask you for your password.

The Recipe

Follow this recipe in sequence. If you have previously installed a particular component, you can usually skip the associated step.

Ruby and Ruby Utilities (irb, ri, rdoc)

The One-Click Ruby Installer does a lot of work for you by installing Ruby, Ruby Gems Package Manager, Rake, all of the other standard Ruby tools, and even the open source SciTE programmer’s editor. Additionally, the installer configures the command line interface path information, so the Ruby tools are ready to use in the Command Prompt program.

Download the latest installer (1.8.6 r26 as of this writing) and double click on it to get started.

Select all of the default settings and let the installer complete its work. Once done, open a Command Prompt (aka DOS Command Line) window by selecting the Start menu, then the Run… menu item, and then typing cmd and pressing return.

You can check that Ruby is installed by typing the command:

	C:\&gt; ruby -v
	ruby 1.8.6 (2007-09-24 patchlevel 111) [i386-mswin32]

You should seem similar responses. If you get an unrecognized command error, try closing your Command Prompt window and opening another one.

Ruby Gems Package Manager

You next need to install the latest version of gem.

Check the version that gets installed:

	C:\&gt; gem -v
	0.9.4

You need 1.0.1 or newer. If you have an older version, you can update with the command line: gem update --system.

Installing a Subversion client

Subversion will be used to access your source code repository during development and deployments. You will need a current version of the Subversion command line client and you can use the official Windows installers on subversion.tigris.org.

Download the latest “Windows installer with the basic win32 binaries” option on the site. Double click the setup program and select the default options.

Once the installer is done, open a new Command Prompt window and check the installation:

	C:\&gt; svn --version
	svn, version 1.4.6 (r28521)
	   compiled Dec 20 2007, 16:33:06
	...

Installing MySQL via the Offical MySQL Installer

You will be installing MySQL via the official Windows Essentials installer from MySQL.com. This installer handles all of the setup steps for you. After downloading the community edition (open source) Windows Essentials setup program, double click it to start:

Select the default (“Typical”) settings and location and let the program install itself. After it completes, a few ads will be shown, then a final dialog allowing you to configure the MySQL server. Make sure the check-box is selected and press “Finish”.

The “MySQL Server Instance Configuration Wizard” will run next. Choose the “Detailed Configuration” option and select all of the default choices. Doing so will configure the database to be running with settings best designed for a developer’s computer. When you get to the dialog offering the “Include Bin Directory in Windows PATH” option, we suggest you select it. If you don’t choose this option, you will need to manually set up your path so the “Command Prompt” program has easy access to MySQL client programs.

You will also be presented with a dialog to set a root password. If you are going to be working locally and aren’t worried about security, you can deselect “Modify Security Settings” and have a blank root password. We strongly suggest you set a password to be safe.

You can confirm that MySQL is running by trying to fire it up in the Command Prompt program:

	C:\&gt; mysql -p -u root
	Enter password: ****
	Welcome to the MySQL monitor.  Commands end with ; or \g.
	Your MySQL connection id is 1
	Server version: 5.0.51a-community-nt MySQL Community Edition (GPL)

	Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

	mysql&gt; exit

When you reboot your computer, MySQL will start automatically in the future.

Gems

While the One-Click Ruby installer added some common Windows oriented gems for you, you still need the Ruby on Rails gems and the gems used in the LearningRails course. Install them with the command:

	C:\&gt; gem install rails capistrano mongrel mongrel_cluster

All installed gems (including Ruby on Rails and its dependencies, Capistrano, Mongrel, and Mongrel_Cluster) will get installed at their latest versions.

The MySQL adapter gem needs to be installed next.

	C:\&gt; gem install mysql

Once the command completes, you should be all set with the baseline gems you will need for the LearningRails courses.

SSH Terminal Program

In deployment environments where your production or other remote servers are running a Unix-derived operating system, you will want to log in to those machines using the SSH protocol. A good Windows SSH terminal program is PuTTY. Download the complete Windows installer and double click to let it run.

You can select all of the default options. Once the installer finishes, you are ready to login to your remote machines.

Installing a Git client

Git is all the rage in the Rails world now and has pretty much replaced Subversion as the version control system of choice. That said, both are in common use. The Git on MSys project team has done a nice job of building the git tools and a simple installer for Windows.

Download the latest installer (latest as of the last update of this article was Git-1.5.6.1-preview20080701.exe) and double click the executable.

During setup, you will be presented with a number of screens. Select the defaults until you get to the following two dialogs:

“Adjust your PATH environment” dialog. Select the “Run Git from the Windows Command Prompt”.
“Choosing the SSH executable” dialog. Select “Use PLink” since we just installed Putty.

The installer should complete, and you can optionally review the ReleaseNotes.rtf file.

The installer command places the core git tools and the man page documentation (type git help _commandname_ for help) on your machine and updates the PATH so you can use git from the Command Prompt. ruby script\plugin install should find git and use it for installation of newer plugins.

Note that if you have an older Rails project, you’ll want to update to Rails 2.1 or newer to get the latest support for git. When you upgrade, update your project with the rake rails:update command.

Code Editing Tools

While you can get by with using a plain text editor like Notepad you will have much higher productivity if you use a programming editor that is highly tuned to Ruby on Rails development. The One-Click Ruby installer automatically installed the SciTE programmer’s editor. SciTE is ok for basic tasks with one or two files, but we recommend trying some of the other programs below.

We use the commercial TextMate programmer’s editor for much of our day to day work on the Macintosh. TextMate is highly extensible through a collection of community supplied “bundles”. There is a Windows “look-a-like/port” called the E Text Editor that looks promising and includes much of the functionality found on the Mac. Even better, it is supposed to be compatible with TextMate bundles, so as functionality improves for one platform, it should become available on the other. There is a trial version available if you want to test it out.

There are a variety of good open source or free programmer editors available too. On the open source side you can find ports of vim and emacs, both of which have add-ons to create a full featured Ruby and Rails development tool set. jEdit is a very extensible open source editor written in Java that has a decent Ruby programming plugin set.

Remote Linux Admin for Windows Users

2008-04-22T17:00:00Z

All the cool kids in the web world these days seem to be using Macs, which have hearts of Unix so are natural complements to Linux-based servers. Others are running Linux desktops. So a lot of the remote server administration information on the web assumes that you’re on either a Mac or a Linux box.

For historical reasons, however, I have a collection of Windows systems, and they’re what I’m comfortable with. I also have some things, like my collection of 60,000 photos managed in the Photoshop Elements Organizer, that aren’t easily moved to a Mac, and I have lots of Windows applications that I own and am familiar with. So while I don’t have any religious feelings about it (please, spare me the Mac evangelism), I’m using Windows systems to remotely administer my web servers.

This really isn’t a problem, as there are ample tools available to make Windows do most everything a Linux system does, or a least everything you need to do to administer one remotely. But it does take a little more effort, at times, to track down the right tools and figure out how to apply them. If you’re early in this process, this article may help. (If, on the other hand, you’re a grey-beard Linux hacker or a Mac die-hard, you can stop reading now.)

Although there are GUI interfaces for Linux, remote administration is done predominantly from the command line. And if you want to follow the well-greased paths for deploying Rails applications, you’re going to be living in a command-line world. This is, of course, rather alien in the Windows environment.

There’s really two command-line environments you need to use: the Windows command shell, for taking actions on your local machine, and a Linux shell, for interacting directly with your server. The Windows shell is essentially a grown-up version of the old DOS prompt. Linux shells come in a variety of versions, with BASH being the most common.

Enhancing the Windows Command Window

You need to use the Windows shell to control your local development environment, and with some extensions (to be described in a later post), you can use it for some tasks that involve your remote server as well.

To open a Windows command shell, you can select Run from Start menu and then enter cmd and click OK. But there’s a better way: Microsoft offers a free add-on that lets you open a command window by right-clicking on any folder and choosing a new option that the add-on installs, “Open Command Window Here.” Aside from being quicker than the Start > Run > cmd approach, it opens the command window with the current directory set to the folder upon which you right clicked. Download the command window PowerToy. It is entirely painless and will make your life just a little bit simpler.

Now you should customize your command window settings, as the defaults are pathetic. The window has no menu, so it may not be immediately clear how one customizes it. The secret is to open any command window, right-click on the title bar, and choose Properties. Once in the properties dialog, here’s some things you might want to change:

In the Options tab, check the boxes to enable Quick Edit Mode and Insert Mode. This enables you to cut and paste text (you can’t use ctrl-X and ctrl-V like you can in a GUI environment). To copy, select the text and then click the right mouse button. To paste, just click the right mouse button.
Also in the Options tab, change the Buffer Size to 999, and the Number of Buffers to 5. This gives you more memory for past commands. At any command prompt, press the up arrow repeatedly to move back through previous commands. This can save a lot of typing.
In the Layout tab, increase the Screen Buffer Height to 2500, so you’ll have more text you can scroll back through after it scrolls off the top of the window. Increase the Screen Height to provide a window as tall as you’d like; I prefer 75 for my 1200-pixel-high monitors.
In the Colors tab, change the text and background colors if you’d like. White text on a black background is traditional and has a retro appeal, but I prefer black text on a white background.

When you’re done making changes, click OK, and then choose Save Properties for Future Windows in the dialog that appears. Now you’ll have a much nicer command window to work with from now on.

Get Set up for SSH

Although you can use the Windows command prompt to act upon your remote server, the primary method used to access Linux systems remotely is SSH (Secure Shell). There’s not an SSH client built in to Windows, but good free clients are available. The most popular is PuTTY. Download the PuTTY installer package. Choose the download labeled “A Windows installer for everything except PuTTYtel”, which will get you the complete set of PuTTY utilities, some of which you’ll want later.

Run PuTTY, and you’ll see a deceptively simple window. There’s actually lots of options here, which you can explore by clicking the categories on the left. But you can get started by using all the defaults and simply entering the name of your host (or its IP address) in the Host Name field and clicking Open. (To save yourself a little typing in the future, you can enter a name under Saved Sessions and click Save, and then the next time you can just double-click this name in the Saved Sessions list.)

Assuming PuTTY is able to connect to your host, you’ll then see another of those lovely white text on a black background windows (you can change these settings in the initial PuTTY dialog), with a Login: prompt. At this prompt, enter the user name your host assigned you, and then you’ll get a password prompt. Enter the correct password, and you’ll be online talking to your server, with essentially all the control that a user sitting at the machine has. All data sent back and forth is securely encrypted, so no one will be able to sniff your network traffic and figure out how to get into your server (unlike FTP, in which not only your files but also your user name and password are sent in clear text).

If you aren’t able to connect to your server (even to the point of getting a Login prompt), then check the following:

Make sure your host has enabled SSH access. If you have a shared hosting account, it might not be offered, or you might have to ask for it.
Make sure you have the host name right. This should be simply the domain of your web site. If it is a new account and you haven’t set the DNS yet, you can use the IP address.
If all else fails, check with your host to see if they’ve moved SSH to a port other than the standard 22. Some companies are doing this to reduce brute-force attacks. You can enter any port number in the PuTTY dialog.

If, on the other hand, you get the login prompt but it doesn’t accept your user name or password, double-check that you have these exactly correct. For some hosts, you may need to use “name@domain.com” and not just “name” for your login name. Check the signup material you received when you opened the hosting account.

Once you have these two command-line environments in place, you have the essential tools to both control your local development environment and to administer your server. Now you just need to know what to type into these windows :-).

For more information:

Excellent overview of SSH software for Windows
Windows Command Shell Overview
Complete (though badly presented) Windows Command Reference
A good third-party Windows command line reference
Cygwin is a Linux-like environment for Windows…
Windows Services for Unix contained an emulation environment and useful tools. (Deprecated but might be useful.)

BarCamp Miami 2008

2008-04-22T17:00:00Z

BarCamp Miami was held February 28th, 2008, concurrent with the Future of Web Apps Miami conference (and shared the nice Carnival Performing Arts Center venue). Up until this point, I hadn’t been to a BarCamp, though I have participated in other unconferences before.

BarCamps evolve on the spot with regard to the content, and Miami was an eclectic mix of talks volunteered from many of the 250 or so participants. As a BarCamp newbie, I, of course, had to give a talk. The process was simple enough: volunteer a topic, grab a room on the grid, and then lead that session. Attending talks was pretty much the same: check the grid, go to the talk, and participate in discussion.

Talks in Brief

How Not to FAIL at Web Services

First stop was Gregg Pollack’s “How Not to FAIL at Web Services”. Gregg (cohost with partner Jason Seifer from the great Rails Envy podcast) dove in to how to conceptualize and build web service APIs the RESTful way. Unfortunately, when it comes to RESTful design, the world has fractured. Some have grokked Roy Fielding’s thesis from his doctoral dissertation and the subsequent implementation best practices in Ruby on Rails and other technologies. Others have interpreted RESTful APIs to simply mean using XML, or perhaps JSON, as a payload, and wacky URLs that spell out a full API call without regard to how HTTP really works. In Gregg’s assessment, the later will be a sure way to FAIL.

Does Rails Need More Love?

I had snagged an early time slot, so I wandered over to my designated room to prep. My talk was entitled Does Rails Need More Love? and focused on the problems facing designers and developers just learning Rails 2. As readers of BuildingWebApps.com and our blog have heard us say before, Rails 2 has fundamentally broken almost all documentation, books, tutorials, and other reference materials out there for new Ruby on Rails learners. I proceeded to explain this sad state of affairs, talk about what we are trying to do to help (BuildingWebApps.com as a commercial hub for resources, new articles under Creative Commons, free podcasts), and opened the floor to discussion of what people really need to help them learn.

I received a lot of good feedback about our site, as well as thoughtful commentary on the different materials people would like to see more of to learn Ruby on Rails (and really, any other web technology). Some of the top contenders were tutorials that stay current, book efforts similar to Python’s Django Book, and more newbie-friendly forums.

Should Kids Surf the Web?

After my session, I walked in to Jose Castillo’s talk about “Should Kids Surf the Web?”. This was interesting to me from two points of view: 1) as a parent of a couple of younger, computer-savvy kids, I’m always curious as to the latest ideas around children and technology; and 2) some of my previous start-up companies focused on children’s education and entertainment software, some of which was net related.

Jose is a great speaker and he showcased a recent project called GoTrybe, which is a kid’s goal-setting and physical-fitness-oriented social application that the state of Tennessee is helping to drive. The side discussion was interesting too, looking for ways to promote the positive aspects of Internet usage by kids and help fight fear-mongering and lack of knowledge (and common sense) among many who want to keep kids away from technology in general. No final solutions, alas!

Coworking: Because Working Alone SUCKS!

BuildingWebApps.com is a virtual company with respect to its physical offices. Since I spend a lot of time at my home office, it was with some interest I attended Alex Hillman’s talk “Coworking: Because Working Alone SUCKS!” talk.

Coworking is where you have a shared office space, with one or more other people working there, although not necessarily for the same company/job/project. It is a mash-up of office space, cafe culture, and camaraderie. Alex gave a number of examples of “how it works” with respect to finding space, finding compatible coworkers, building trust, general bootstrapping, logistics, etc.

It was refreshing to see the different approaches. I think the trick to kicking off a successful coworking space is having that critical mass of creative folks who “get it.” Living up in the Sierra Nevada foothills, I’m hoping I can find an opportunity to try coworking someday.

Launch Your Company in 48 hours

OK, that wasn’t the name of the talk, but the guys over at Tasty Planner presented their company and product. Tasty Planner was conceived of and initially built as an entry in 2007’s Rails Rumble Contest.

Rails Rumble is the Iron Man Triathlon of Ruby on Rails programming. Your team has 48 hours to build from scratch a compelling application.

Tasty Planner is a menu creation, planning, shopping, and sharing application that seems pretty cool. The four team members discussed their approach and key take-aways. Most important, they:

agreed to make decisions quickly,
had mostly clear areas of responsibility, and
consumed a lot of caffeine.

Things went so well that one team member took time to go to a concert too! This was a fun talk and we all got to check out the heavy weight prize.

BarCamp Takeaways

BarCamp is all about networking. While the sessions were excellent, even better was the chance to mingle between sessions and in the hallways, making contacts and exchanging ideas. If you have a chance to attend a BarCamp (be sure to check the official BarCamp wiki, they are literally being organized around the world), do try to give a talk. It is the fastest way to start meeting people.

Resources

Flickr Pictures from BarCamp Miami

Official BarCamp Miami Page

Articles Revolving Around BarCamp Miami

Setting up Rails on Windows Vista

2008-04-22T17:00:00Z

This guide walks you through setup instructions for preparing a Windows Vista development machine to be used for general Ruby on Rails coding. This baseline setup is what we use for our LearningRails online course.

You will end up with a development machine with the following baseline components:

Ruby and all basic Ruby utilities
Ruby Gems package manager
Subversion client
MySQL database client utilities and server
Gems for Ruby on Rails, Capistrano, Mongrel, Mongrel Cluster, and MySQL
SSH Terminal Program
Git client (UPDATED)
Programmer’s editor or IDE

Note: In the command sequences we illustrate here, command line prompts are shown as C:\>.

Prerequisites

This guide assumes you have a Windows computer running the current Windows Vista operating system with up-to-date service patches applied (SP1 or higher). It also assumes you have not set up alternate Ruby on Rails tools prior to running through this guide. If you have, then small adjustments may be required as you walk through the following instructions.

You will need to have access to an Internet connection to complete various download steps.

You will need to have administrator access to your computer to complete this guide. Some of the Windows installers may ask you for your password. With most of the installer programs described below, Windows Vista will present the famous User Account Control (UAC) dialog asking whether an unidentified program should be permitted to have access to your computer.

You should select the “Allow” option which will let the specific installer program continue. In the specific case of MySQL, the MySQL installation process is not compatible with UAC. We will walk you through temporarily turning UAC off so you can install MySQL.

The Recipe

Follow this recipe in sequence. If you have previously installed a particular component, you can usually skip the associated step.

Ruby and Ruby Utilities (irb, ri, rdoc)

Download the latest installer (1.8.6 r26 as of this writing) and double click on it to get started.

Select all of the default settings and let the installer complete its work. Once done, open a Command Prompt (aka DOS Command Line) window by selecting the Start menu, then enter cmd into the Start Search text box and pressing return.

You can check that Ruby is installed by typing the command:

	C:\&gt; ruby -v
	ruby 1.8.6 (2007-09-24 patchlevel 111) [i386-mswin32]

You should seem similar responses. If you get an unrecognized command error, try closing your Command Prompt window and opening another one.

Ruby Gems Package Manager

You next need to install the latest version of gem.

Check the version that gets installed:

	C:\&gt; gem -v
	0.9.4

You need 1.0.1 or newer. If you have an older version, you can update with the command line: gem update --system.

Installing a Subversion client

Download the latest “Windows installer with the basic win32 binaries” option on the site. Double click the setup program and select the default options.

Once the installer is done, open a new Command Prompt window and check the installation:

	C:\&gt; svn --version
	svn, version 1.4.6 (r28521)
	   compiled Dec 20 2007, 16:33:06
	...

Installing MySQL via the Offical MySQL Installer

You will be installing MySQL via the official Windows Essentials installer from MySQL.com. This installer handles all of the setup steps for you.

NOTE: As of this writing, MySQL 5.0.51a and 5.1.23rc have bugs that prevent simple installation onto Vista. A workaround recipe is available but it is complicated. We recommend using a slightly older version, MySQL 5.0.45, as it doesn’t have the current installation bugs. We’ll update these instructions once fixes to the current MySQL line are available.

Unfortunately, the MySQL installer and Windows Vista User Account Control (UAC) conflict with one-another. You will have to temporarily turn UAC off.

First, go to the Start Menu, select Control Panel, and then click on User Accounts and Family Safety:

Click on the User Accounts link to open your account’s setting dialog:

Click on the Turn User Account Control on or off link. Assuming that User Account Control is still on, Windows Vista will ask for permission to continue with turning User Account Control off. Nice and circular, yes? Now you can actually turn UAC off. Unselect the checkbox and press OK.

You will be prompted to restart your computer. Go ahead and do so now.

One other change you will need to make is to open your Windows Vista Firewall to permit MySQL connections to the MySQL server port (3306). To do so, open Control Panel again, and select the Allow a program through Windows Firewall option of the Security group.

Press the Add port... button, and enter MySQL in the “Name:” field and 3306 in the “Port number:” field. Leave the protocol as “TCP”.

Press OK on the Windows Firewall Settings dialog box and close the Control Panel.

Finally, you can get on with installing MySQL. Double-click the community edition (open source) Windows Essentials MySQL setup program to get started:

You can confirm that MySQL is running by trying to fire it up in the Command Prompt program:

	C:\&gt; mysql -p -u root
	Enter password: ****
	Welcome to the MySQL monitor.  Commands end with ; or \g.
	Your MySQL connection id is 1
	Server version: 5.0.45-community-nt MySQL Community Edition (GPL)

	Type 'help;' or '\h' for help. Type '\c' to clear the buffer.

	mysql&gt; exit

When you reboot your computer, MySQL will start automatically in the future.

Once you have confirmed MySQL is working, you can also reverse the steps above for re-enabling User Account Control.

Gems

While the One-Click Ruby installer added some common Windows oriented gems for you, you still need the Ruby on Rails gems and the gems used in the LearningRails course. Install them with the command:

	C:\&gt; gem install rails capistrano mongrel mongrel_cluster

All installed gems (including Ruby on Rails and its dependencies, Capistrano, Mongrel, and Mongrel_Cluster) will get installed at their latest versions.

The MySQL adapter gem needs to be installed next.

	C:\&gt; gem install mysql

Once the command completes, you should be all set with the baseline gems you will need for the LearningRails courses.

SSH Terminal Program

You can select all of the default options. Once the installer finishes, you are good to login to your remote machines.

Installing a Git client

Download the latest installer (latest as of the last update of this article was Git-1.5.6.1-preview20080701.exe) and double click the executable.

During setup, you will be presented with a number of screens. Select the defaults until you get to the following two dialogs:

“Adjust your PATH environment” dialog. Select the “Run Git from the Windows Command Prompt”.
“Choosing the SSH executable” dialog. Select “Use PLink” since we just installed Putty.

The installer should complete, and you can optionally review the ReleaseNotes.rtf file.

Code Editing Tools

While you can get by with using a plain text editor like Notepad you will have much high productivity if you use a programming editor that is highly tuned to Ruby on Rails development. The One-Click Ruby installer automatically installed the SciTE programmer’s editor. SciTE is ok for basic tasks with one or two files, but we recommend trying some of the other programs below.

Seed Conference: The Creative Business Life

2008-04-22T17:00:00Z

The one-day Seed Conference was an event unlike any of the many conferences I’ve attended over the past few decades. It was, for the most part, a series of personal essays by three unusually creative folks: Jason Fried of 37signals, Jim Coudal of Coudal Partners, and Carlos Segura of Segura Inc and a variety of other ventures. All are based in Chicago, where the event was held.

Carlos Segura, Jason Fried, and Jim Coudal

The program consisted of each of these three people speaking for an hour or two, followed by a panel discussion. It’s hard to put a label on this event, which drew its attendees almost solely by the reputations of the speakers. The event was sold-out and filled the auditorium at the Illinois Institute of Technology to its capacity of 128 attendees.

The conference was about design, web applications, and business, but its real focus was on creating a life and a business that you enjoy by following your creative inspirations. For anyone working in a large company, it was a persuasive, though indirect, call to strike out on your own (one that we heeded some time ago). For designers doing freelance work or running agencies, it was a rallying cry for creating your own products, rather than spending all your time applying your skills on behalf of others. And for everyone, it was an impassioned pitch for following your instincts, creating the best products you can, and having a great time doing it.

Carlos Segura: Art, Type, and Inspiration

Carlos worked as an art director for a string of large ad agencies before striking out on his own in 1991. He now runs multiple ventures, including the Segura Inc. agency, t26 type foundry, 5inch (silk-screened blank DVDs), and Cartype (more than you can imagine about car emblems and logos).

Carlos showed examples of amazing, multifaceted campaigns he created for Corbis and RockShox. Check out the client list on the Segura Inc. site for links to a variety of their work.

Carlos created the t26 type foundry in 1994 out of frustration with the fonts available and the hassles with using it. By applying his own branding and marketing skills, on top of enlightened policies (t26 is the only type supplier that allows designers to legally provide fonts to service bureaus) and great new typefaces, he’s built t26 into one of the largest independent type foundries.

Jason Fried: The 37signals Way

Jason Fried , the founder of 37signals, needs no introduction here, but perhaps the history of 37signals is not as well known. Jason began as a freelance designer and didn’t really form a company until he had freelanced for three years and got the job to design GettyOne, for which he needed another designer. 37signals, founded in 1999, still has only 10 employees, most of whom work primarily from home. For such a small company, it has had a big impact.

37signals became a product company with the launch of Basecamp, from which Ruby on Rails was extracted. Basecamp was initially built as an internal tool, and then turned into a product. Their initial goal was $5K per month in revenue, which they exceeded within six weeks of launch. A year later, 37signals dropped all client work.

Jason remains focused on user experience, while David Heinemeier Hansson, the co-owner of 37signals and original author of Rails, leads the development side of the business.

Jason’s talk was, for the most part, his well-honed “Getting Real” pitch. If you haven’t already read the Getting Real book and you’ve made it this far into this article, it should be next on your list.

Just Wing It

Jason is a vocal advocate for doing away with most planning and just diving in and building products. He argues that plans never end up being what happens anyway, and that you’re better off focusing your time on activities that lead directly to something you can put in front of customers. He takes an approach that is akin to Agile methods in the software development world, but applied to building businesses and doing design — and taken, perhaps, to an extreme. He calls for us to “embrace the unknown” and “just wing it” since “you don’t know what you’re doing anyway until you’re doing it.”

There’s a fascinating discussion to be had over the counterpoint that planning can provide a lot of value, but that didn’t happen at this event, and it will have to wait for a future article to appear here.

Another key point was that all too often there are too many cooks (too many participants in a project) and too few chefs: leaders who freely share their knowledge, as in cookbooks, in cooking shows, and so forth, and thereby build powerful personal brands while spreading their knowledge. Jason pointed out that Getting Real is the 37signals cookbook and asks, “What’s your cookbook?” (This site is growing into ours.)

Jason advocates for small teams and an easy-going approach. 37signals gives everyone Fridays off during the summer months, and Jason says just as much work gets done. He recommends hiring “managers of one” — in other words, people who are self-managing.

As for work style, Jason spoke out against the pervasive open workplace with its focus on nearly constant communication. “A lot of people think interruption is collaboration,” he commented.

Financials remain one topic that Jason won’t discuss, but he did say that Basecamp is the company’s most profitable product, and Campfire its least-profitable.

Some other tidbits:

They do all their prototyping in HTML and CSS, and don’t use Photoshop for mock-ups.
They don’t actively market the company, other than by blogging and speaking.
Highrise came from an internal need to track journalists they were talking with.

Jim Coudal: Business Serendipity

Like Carlos Segura, Jim Coudal runs a creative agency (Coudal Partners) and a host of spinoff products and businesses, including The Deck (ad network), The Show (concert recordings), and Jewelboxing (nice jewel boxes for CDs and DVDs). These sites are worth spending some time on just for inspiration, even if you aren’t interested in the products.

The site Coudal has so much content on it that a note at the bottom proclaims, “We actually do stuff other than update this site,” with a link to the “About Us” page.

Jim described how he moved away from client work, as an example of serendipity and following opportunities that present themselves. After years of doing design, web development, and filmmaking on behalf of clients, Coudal began developing short films and other projects just to show off the firm’s talents. When a British TV production company expressed interest in turning one of these films into a series, Jim thought that was going to be their path away from client work. When sending out a sample DVD, Jim went looking for better packaging for the DVD.

The TV show never happened, but Jewelboxing was born. Check it out if you need cool CD or DVD packaging.

Triggered by an opportunity to produce CDs of live concert recordings for sale to concert-goers, Jim founded The Show, in partnership with a Jewelboxing customer.

Jim points out that enthusiasm for new ideas is typically highest early on, so by pursuing a series of projects you can stay higher on the enthusiasm curve.

Like Jason, Jim argues against the need for things such as business plans. He described his goal as being to “find a way to screw around at work all day and get paid for it,” and it sounds as though he has accomplished just that!

Ready to Go?

Was it worth spending a day at? Absolutely. If I hadn’t already read and absorbed Getting Real, it would have been even more so. Whether it was worth a San Francisco to Chicago trip, complete with a four-hour flight delay and waiting outside for a cab in snowy, 15-degree weather, is a tougher call, but I’m glad I went. A two-day conference would have made much better use of all the travel time, though.

Future Seed conferences haven’t been scheduled, but given the sell-out crowd and how much the presenters seemed to enjoy themselves, it seems likely. Visit seedconference.com if you want to join the notification list for any announcements.

Future of Web Apps Miami 2008

2008-04-22T17:00:00Z

Carsonified’s Future of Web Apps, Miami, was held February 29th, 2008 at the Miami Carnival Performing Arts Center (actually, there were tutorials the day before, and a beach party the following day, but I missed those events).

Future of Web Apps, or FOWA for short, has been held before in London and San Francisco, and this was the first time it was held on the East Coast. FOWA brings together a who’s who of Web 2.0 technorati to tackle general themes of interest revolving around where the Web is going. Ryan Carson, chief of Carsonified, lays out those themes and his guests tackle them in a series of talks. Getting inside thoughts from many of those who have made Web 2.0 successful is interesting, but even better is the discussion that goes on outside of the talks in the hall-ways. I found these to be inspiring and reaffirming of many of the practices, ideas, and goals we have with BuildingWebApps.com and beyond.

In Miami, Carson’s big themes were Iteration, Speed, and Openness. In many ways, the talks boiled these themes down to the sound byte of “get something out there quickly, small and simple, wash, rinse, repeat (and throw in an API to ‘set the data free’)”.

I’ll try to capture some highlights. From a developer point of view, the sessions were generally, well, general, so those looking for deep technical insight probably didn’t find it in the single session track. From a “meet some of Web 2.0’s current active drivers” viewpoint, it was a good place to mingle.

Kathy Sierra: Creating Passionate Users

Kathy Sierra, the keynote speaker, I recalled from her days in the game development world. She addressed the general question “Why are we here?” (meaning, “we” the audience). She proceeded to tackle a variety areas that should concern the audience in “the future,” all centering around the idea that what “we” should be doing is creating passionate users (of our products indirectly, most specifically of what users can do with our products, and what they can do with one-another). Ultimately, her point was that we should facilitate users getting together offline as well as on, and use our understanding of “meet”-space (my pun intended) to key in on important behavioral motivators.

Sierra is a strong advocate of enabling users to “kick ass”, and touched on how to create “hi-rez” user experiences that get people quickly above the “suck threshold” and nearing the “passion threshold”. She reminded the audience that it isn’t about the tools we create, but how the tools are used. Driving toward a “telepathy-driven design” mentality, in which the user experience becomes one of “it’s as if the app could read my mind” is one goal.

Overall, Sierra’s talk was inspirational in keeping focused on the user, and keeping the user engaged, happy, and successful.

Matt Mullenweg: The Architecture of WordPress

Matt Mullenweg of Automattic (makers of WordPress, Akismet, and more) highlighted his thoughts on scaling from multiple angles (platforms, business, community, and teams). This was a wide ranging talk, of which there were a few technical tidbits.

WordPress has continued to see high growth over the last six months, but amazingly operates on a relatively small numbers of servers. Mullenweg broke down one WordPress configuration as:

Two load-balancing machines, running the Pound load balancer, Whackamole virtual IP manager, and Spread messaging toolkit
Two hefty database servers running MySQL
Three web servers using a well-configured Apache setup

WordPress makes heavy use of its hyperdb technology, puts everything into Subversion that does onto a server (all configuration and OS files), keeps things stateless, and uses a lot of memcached.

Mullenweg touched on scaling community and talks more about it on his blog.

With regards to scaling the business, he indicated that their attempts to have subscription levels didn’t work so well, particularly since most of their growth was on the side of readers, not bloggers. They ended up going with a specialized advertising model that only shows ads to specific users when visiting permanent pages, or if the user only occasionally views the site. Interestingly, in a show of favoritism to FireFox users, they never show ads to users of FF.

Mullenweg finished with some tips of how he is scaling the team and the five things he looks for when hiring: 1) passion for the space; 2) personality fit; 3) ability to learn (curiosity); 4) familiarity with technologies; and 5) taste.

Tantek Celik, Brian Oberkirch, and Joseph Smarr: The Future of Social Networks

Celik, Oberkirch, and Smarr gave a set of interconnected talks around some of the core building blocks for the next wave of social applications. In the large, these were RSS, Creative Commons licensed content, OpenID, and oAuth. Together, it is possible to tie together many interaction modes, across a variety of services such as email, Twitter, Flickr, last.fm, or other specific Social Networks.

Of particular interest to those creating sites that create/use user profile information, Celik gave a nice primer on sharing profile information through the hCard microformats work he has spearheaded. If you aren’t familiar with the microformats efforts, this is definitely something worth checking out.

Profile information can be tied together via hCard (which describes “people” information), >XHTML Friends Network (which covers “relationship” information), and linking profiles’ information together across the net using XFN’s rel me="me" attribute on your links. This is called profile equivalency and Google’s crawlers, among others, use these to build the the data for the OpenSocial Social Graph API.

Key Lessons

A variety of speakers shared key lessons they learned as they built their products, and these lessons drive how they see “the future.” Here are some highlights:

Blaine Cook, from Twitter, emphasized the need to simplify (YAGNI) and listen to users versus your developers, and encouraged everyone to check out their Ruby distributed queue server Starling.

Leah Culver from Pownce shared some of the missteps they made introducing their APIs. Their first API was not well conceived, didn’t provide access to enough data, and just didn’t succeed with developers. For 2.0, they are spending time with developers, greatly opening up the data available to applications, permitting key data uploads (file transfers, note posting, etc.), supporting oAuth, and providing a developer showcase. Culver indicated that all of these efforts are also in support of the interoperability and key building blocks discussed earlier.

Emily Boyd from Remember the Milk gave a really great talk on the evolution if her To Do List service and the amazing amount of work two people can do who are passionate about a space. She is a fun example of a computer person adopting “cool” technologies or “workarounds,” “because they are cool,” and in this case, doing so at the benefit of her customers. One example was in pushing as much into client-side Javascript processing as possible, adopting Google’s Gears offline framework. Another novel feature was unofficial integration of task management with GMail (where no real API exists) through the use of the likes of greasemonkey.

Cal Henderson of Flickr gave one of his trademark talks, equal parts informative and good fun. At FOWA, Henderson focused on automation, monitoring, and incrementalism. At Flickr, they keep releases small and rapid, thereby keeping the amount that can go wrong as small as possible. His book, Building Scalable Web Sites covers many of these techniques and suggestions.

Gary Vaynerchuck of wine library tv rounded out the day with his inspirational talk. He talked of the creation of his vlog, but most importantly, about the need to be passionate about your community (and wine!).

Worth it?

Overall, FOWA was a great opportunity to meet and greet many of the folks driving current Web 2.0 darlings, as well as mingle and share ideas with other entrepreneurs trying to create the next wave. I’d recommend it if you are looking for events to add to your list of “networking” events, but skip it if you are looking for purely technical information (for that, barcamp is a better choice than FOWA).

Resources

Many of the talks are available online as MP3 and slides

Following and contributing to real-time chatter on Twitter at conferences, other events, and topics is much easier with twitter #tag, add hashtags bot to enable it.

Using Yahoo's User Interface Library Treeview in Rails

2008-04-22T17:00:00Z

Our BuildingWebApps.com site organizes much of its information by assigning one or more categories from a domain specific taxonomy to each article, link, or other piece of content. A site visitor can browse the information in several ways, but one quick approach is via a category browser widget that appears on most content pages. The hierarchical tree view is implemented by embedding Yahoo’s Open Source User Interface Library Treeview (aka YUI treeview, or just treeview here) into our RHTML. As of this writing, YUI is available under a BSD License and is part of a much larger, rich set of Javascript widgets and utility classes.

The treeview widget is implemented in Javascript, has many visual and interaction behaviors that can be tuned, it can be skinned, and it can work with static or dynamic data sources.

In our case, since our category data changes infrequently, we decided to implement a static data collection that we can cache, and which is loaded with the page in its entirety.

Here is how I did it.

Step One: Grab The Source From Yahoo

After downloading the latest libary, I dropped the default Javascript and CSS files into our Rails app’s public/javascripts and public/stylesheets directories, respectively. The YUI widget Javascript comes in several implementations: a debug version (treeview-debug.js) which is fully documented and instrumented, a production version (treeview.js), and an obfuscated, slimmed down version (treeview-min.js).

A couple of supporting libraries are also required for utility code and event handling (yahoo.js and event.js, both available with -min.js variants.)

Similarly, there are a number of stylesheets that are needed depending on the visual and interaction choices you make for your widget use. On the BuildingWebApps.com site, I wanted the control to act as a menu of sorts, such that only one category can be selected at once, and when I select a category in one part of the tree, I want any other prior choice to deselect. The treeview-menu.css contained the necessary defaults for this look and feel.

Like the Javascript, you can grab minimal versions of some of these CSS files (labeled with -min postfixes) when available.

One thing to note is that I customized some of our CSS to tweak the appearance for the site and snuck those snippets in our site CSS file instead.

Finally, I needed to prepare the visual assets for the disclosure triangle and bullet graphics. The library comes with a default set of sprite GIFs that you can open in any image editor and customize as needed. After some quick editing, I installed our GIFs into our public/images directory and tweaked the CSS to point to the correct place.

Step 2: Creating My Views

Next, I proceeded to get my view environment ready for widget usage. First, I plugged my stylesheet and javascript tags into my common layout’s header:

&lt;%= stylesheet_link_tag 'treeview-menu' %&gt;
&lt;%= javascript_include_tag 'yahoo-min.js'%&gt;    
&lt;%= javascript_include_tag 'event-min.js'%&gt;
&lt;%= javascript_include_tag 'treeview-min.js'%&gt;

I then created a partial template file _nav_widget to hold the treeview setup:

&lt;h2&gt;Browse &lt;img src="/images/icons-browse.gif" width="25" height="25" align="absmiddle" /&gt;&lt;/h2&gt;
&lt;div id="contentTreeDiv"&gt;&lt;/div&gt;
&lt;script type="text/javascript"&gt;
(function() {
&lt;%= category_tree_data_builder('category_data') %&gt;
&lt;%= yui_tree_builder('contentTreeDiv', 'category_data', item) %&gt;
})();
&lt;/script&gt;

When the page this code is embedded on loads, the anonymous Javascript function fires, and proceeds to run the Javascript that gets embedded in place here by my helper functions. This technique effectively name-spaces any of the code inside the scope of the anonymous function, protecting me from any inadvertent collisions. Once the Javascript produced by _yui_tree_builder_ executes, it replaces the div with id “contentTreeDiv” with the final treeview widget.

With my partial ready to go, I am able to start using it in my various pages by the normal render techniques:

&lt;% content_for :right_middle do %&gt;
	&lt;%= render :partial =&gt; '/categories/nav_widget', :locals =&gt; {:item =&gt; @category } %&gt;
&lt;% end %&gt;

The mysterious local variable “item” permits me to hint to the treeview where I am in the display hierarchy so I can start the treeview open and expanded to that category.

As you can see, all of the magic is hidden in my helpers, _category_tree_data_builder_, which is responsible for constructing an array of data that is consumed by _yui_tree_builder_, which creates the Javascript that builds the widget.

Step 3: Inside The Helpers

My technique is inspired by Sonjaya Tandon’s HOW-TO: Integrate a YUI tree with Rails article. I’ve made some changes to start to support multiple treeviews and permit that “hinting” of where the user is when she navigates from one page with the widget to another (so the tree starts in an expanded mode at the appropriate category node).

_category_tree_data_builder__ constructs the array of data from our taxonomy of categories. You would change this code to walk your model as appropriate. For BuildingWebApps.com, the Category model is built with the acts_as_tree model extension, so walking the tree is simple. This implementation is slightly unwound to make it easier to follow:

def walk_category_recursive(level, parent)
  ret = ""
   parent.children.each do |node|
     ret += "#{level}, \'"
     ret += yield level, node
     ret += "\',\n"
     ret += walk_category_recursive(level + 1, node) { |lvl, n| yield lvl, n } unless node.children.empty?
  end
  ret
end

def category_tree_data_builder(tree_data)
  data = "var #{tree_data} = [" +
    walk_category_recursive(0, Category.root) {|lvl, node| link_to(h(truncate(node.title, (30 - lvl))), {:controller =&gt; 'topic', :action =&gt; 'show', :id =&gt; node}) }
  # chop off the last trailing comma
  data.chomp!.chop!
  return data + "];\n"
end

Finally, we construct our Javascript code that builds the actual treeview widget:

def yui_tree_builder(tree_div_id, tree_data, expanded_label)
  expanded_label = "NONE" if expanded_label.nil?
  return "var tree; \n" +
      "function #{tree_div_id}Init() {\n"+
      	"tree = new YAHOO.widget.TreeView(\"#{tree_div_id}\");\n"+
      	"addChildrenNodes(0, 0, tree.getRoot());\n"+
      	"tree.draw();\n"+
      "};\n"+
      "function addChildrenNodes(currLevel, nodeIndex, parent) { \n" +
       "var lastNode;\n"+
       "var level = currLevel;\n"+
       "while (nodeIndex &lt; #{tree_data}.length) {\n"+
           "var level = #{tree_data}[nodeIndex];\n"+
           "if (level == currLevel) {\n"+
               "nodeIndex++;\n"+
               "if (#{tree_data}[nodeIndex].indexOf(\"/#{expanded_label}-\") &lt; 0) {\n" + 
                  "lastNode = new YAHOO.widget.HTMLNode({html: \"&lt;div class='browserNaviNotSelected'&gt;\" + #{tree_data}[nodeIndex] + \"&lt;/div&gt;\"}, parent, false, true);\n"+
                  "lastNode.multiExpand = false;\n"+                    
                  "lastNode.nowrap = true;\n"+
                "} else {\n" +
                  "lastNode = new YAHOO.widget.HTMLNode({html: \"&lt;div id='browserNaviCenter'&gt;&lt;div id='browserNaviItem'&gt;\" +  #{tree_data}[nodeIndex] + \"&lt;/div&gt;&lt;/div&gt;\"}, parent, true, true);\n"+
                  "lastNode.multiExpand = false;\n"+
                  "lastNode.nowrap = true;\n"+
                  "var p = parent;\n"+
                  "while (p != null) {\n"+
                    "p.expanded = true;\n"+
                    "p = p.parent;\n"+
                  "}\n"+
                "}\n"+
               "nodeIndex++;\n"+
           "} else if (level &lt; currLevel) {\n"+
               "return nodeIndex;\n"+
           "} else {\n"+
               "nodeIndex = addChildrenNodes(level, nodeIndex, lastNode);\n"+
           "}\n"+
       "}\n"+
       "return nodeIndex;\n"+
      "};\n"+
      "YAHOO.util.Event.onDOMReady(#{tree_div_id}Init);\n"
end

That’s pretty much it. Most of the tweaking that I’ve done since putting this code together has been on the style side of things to improve the appearance. Peeking inside of the YUI code reveals a number of node types, and if none of them fit your needs, it is easy to derive your own functionality in no time.

I will likely change the solution presented here if we ever dramatically grown our category taxonomy. Downloading the data en-masse isn’t ideal from a scalability and bandwidth usage point of view. When the time comes, it would be relatively simple to partition the data set into levels or layers of the tree, and dynamically load what is needed when certain nodes are exposed. In the mean-time, the existing solution is simple.

Selling Friends: Scaling a High-Traffic Rails Application

2008-04-22T17:00:00Z

At the recent Silicon Valley Ruby Conference, Friends for Sale developer Alex Le outlined the approach they’ve taken to scaling up to deliver an impressive 300 million page views per month for their Rails-based Facebook application.

Friends for Sale is currently the #6 most popular application on Facebook. The application describes itself as follows:

“Buy and sell your friends as pets! You can make your pets poke, send gifts, or just show off for you. Make money as a shrewd pets investor or as a hot commodity!”

So I guess I there’s something here I don’t quite get — but in any case it has become perhaps the highest-traffic Rails app, delivering at least 50% more page views per month than yellowpages.com.

The app was created by the ironically named Serious Business Inc. The initial version was built in 10 days by Alex Le and Siqi Chen, using the RFacebook gem, and was launched on 11/1/07. Alex had previously worked on the rebuilding of yellowpages.com as a Rails application.

Referring to the oft-cited scaling aphorism, Alex asserted “Don’t scale until you need to… unless you’re on Facebook!” They had scalability problems on their first day because of the speed at which the audience ramped up. By the end of the first month they were delivering 1 million page views per day; by the end of the third month, they hit 10 million per day. They currently have 7 million users and 650,000 unique visitors per day.

Scaling to this traffic level required both adding lots of servers and tuning the database. They started out at Slicehost, and switched to SoftLayer when they needed more servers. Their decision to use SoftLayer was driven, in part, by the speed with which they could get them set up — 2 hours. Alex encouraged everyone to start with a hosting provider that can scale with you, to reduce the pain when traffic grows.

After two months, they hired a database administrator to handle the database tuning. Alex recommended using the Rails Query Analyzer plugin, and to index only the fields that you need to. He noted that while Active Record makes it easy to get the application going, it can get in the way when you need to optimize your database performance. They use Dr. Nic’s Magic Multi Connections plugin to handle the database connections, with some monkey-patching to fix issues they found; they plan to release their plugin code soon.

Their current server configuration includes:

One front-end server running nginx with fair for load balancing.
Eleven application servers, each with 8G RAM and four 2.4 GHz processors, running 16 Mongrel instances on each one (that’s 176 Mongrels!), with 4G on each server for memcached.
One master database server and three slaves, each with eight 2.3 GHz processors and 32G RAM, using 10K RPM SCSI drives in a Raid 1+0 configuration, running MySQL 5.

Their next step is to seek more performance from their existing hardware. Toward that end, they’re planning to move from fair to qrp (queueing reverse proxy) for load balancing, and they’re exploring alternative implementations of Mongrel that have faster threading models.

They also cache extensively. Serialized models are stored in memcached, using write-through caching. They moved logic to view helpers to simplify the use of fragment caching.

Serious Business has been recruiting for Rails developers, and in these ads they claim they are building the world’s largest Rails cluster. Maybe selling friends isn’t such a bad idea.

Exception Handling and Old URLs

2008-04-22T17:00:00Z

Whenever I deploy a Rails site, I install the exception notification plugin so I get an email if a user provokes a bug I hadn’t found. It’s a piece of cake to install:

1. Install the plugin

ruby script/plugin install exception_notification

2. Include the plugin in your ApplicationController (in the application.rb file)

include ExceptionNotifiable

3. Add one line to your environment.rb file to specify where to send the email

ExceptionNotifier.exception_recipients = %w(person1@domain.com person2@domain.com)

4. Make sure you have ActionMailer configured (to use either sendmail or STMP), which you’ll already have done if your app sends email for any purpose.

What’s this? Errors already?

A few minutes after I first installed the Exception Notification plugin, I checked my inbox and found a dozen error emails from the site! After a brief moment of panic, I realized that all were coming from search engine spiders, and that the URLs were all invalid. I had replaced an old, crufty, static HTML site, and the spiders were rechecking pages they had indexed in the past.

So the next question was what to do with the old URLs. I could remap each URL to the most appropriate page on the new site, but the old site got little traffic and there wasn’t a clear mapping between the two sets of pages, so it hardly seemed worth it. I decided to map index.html to the new home page, since many people might have bookmarked that page, and it was clear what it should map to. As for everything else, I wanted a way to tell the spiders to stop trying to index them, and to tell anyone who accessed them that this was no longer a valid URL and they should explore the new site.

The heart of the fix is to add a few lines to routes.rb. Fortunately, the old site design had put all the HTML pages except for the index page into a directory called html. There were also some PDF files, conveniently in a directory named web_pdfs.

Here’s the routes, which I added at the end just before the default route:


map.connect '/index.html', :controller =&gt; 'page', :action =&gt; 'home'
map.connect '/html/*any', :controller =&gt; 'page', :action =&gt; 'oldpage'
map.connect '/web_pdfs/*any', :controller =&gt; 'page', :action =&gt; 'oldpage'

I have a controller called page_controller that manages the public parts of the site. The first route simply maps index.html to the home page action.

The second route maps any URL in the html directory to a new page, which I called simply “oldpage”. The oldpage.rhtml file simply has some text telling the visitor that this page no longer exists, and gives them some suggestions for exploring the new site.

The “*any” in the route definition absorbs whatever comes after “/html/”. With this technique, I don’t have to worry about whether there might be subdirectories within html, or what the file name extensions might be.

The final piece was to tell the spiders not to bother with these pages any more. I didn’t want to use a redirect, because the page to which I wanted to redirect the user wasn’t the new permanent page, but rather one that explained that the site had been changed. I decided to set the HTTP header to the “gone” status code (410). This just takes one line in the page controller oldpage action:


def oldpage
  render :template =&gt; 'page/oldpage', :status =&gt; :gone
end

Eventually the spiders will stop spidering these old pages, but since index.html will still lead to the new home page without any error code, they will find all the new pages from there.

Validating Email Addresses with Ruby

2008-04-22T17:00:00Z

In any application in which a user enters an email address, there is the very real possibility that the user will make a typo and your application will end up with an invalid address. You can have them enter it twice, but this seems clunky. And you can, of course, send an email with an activation link, which provides the only true validation, but there’s no need to bother sending the email if you know the address is no good. Furthermore, once you’re past the page where the user enters their email address, you’ve missed your chance to tell them there’s something wrong and they should correct it.

So you really should do what you can to validate the address when the user enters it. I recently made a simple addition to my applications that helps a lot: verify that the domain name is valid.

It’s surprisingly easy to do — especially with a little help from Peter Cooper’s excellent Beginning Ruby, which has a very useful chapter on network programming. The following code is adapted from his examples:

require 'resolv'
def validate_email_domain(email)
      domain = email.match(/\@(.+)/)[1]
      Resolv::DNS.open do |dns|
          @mx = dns.getresources(domain, Resolv::DNS::Resource::IN::MX)
      end
      @mx.size &gt; 0 ? true : false
end

This example makes use of the Ruby standard library “resolv”, so you need to require it first.

The first step is to separate the domain name from the rest of the email address. The regular expression captures the part of the string that follows the @ symbol.

Then the code creates a new DNS resolver object and queries the resolver for an MX (mail exchanger) resource at the specified domain. This returns an array, which will be empty if there is no MX record for the domain.

(Note: In a previous version of this article, I used Resolv.getaddress to see if there is a DNS entry for the domain, instead of checking for an MX record. This approach works most of the time, but it rejects any domain for which there is no A record. If a domain is used only for email and not for a web server, there might not be an A record. Also, some domains have an A record only for www.domain.com, which will also fail the simple getaddress test.)

You can use something like the following in the validate method within the appropriate model:

unless email.blank?
    unless email =~ /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/
        errors.add(:email, "Your email address does not appear to be valid")
    else
        errors.add(:email, "Your email domain name appears to be incorrect") unless validate_email_domain(email)
    end
end

I first check to make sure the email address is not blank, because that’s detected by a simple validates_presence_of :email statement that produces a different error message.

Then I make sure that the email address is at least syntactically reasonable, with a rather ugly regular expression, before bothering to check the DNS.

It should be noted that the regex I use here isn’t designed to cover all of the RFC2822 cases, nor with other RFC drafts dealing with non-ASCII addressing.

An even better approach would be to use an observer to validate the address with an Ajax call before the user submits the form.

It is possible to take this a step further by sending the SMTP server referenced in the MX record a “RCPT TO:” command. In theory, this would check that the user name is valid as well as the domain name. This takes additional time, however, and I’ve read that the response from mail servers is often not reliable. If anyone has tried this, I’d appreciate any feedback on how well it worked.

Using SSH Keys to Speed Login

2008-04-22T17:00:00Z

With a basic SSH setup, you have to enter your password every time you log in to the server, which is not unreasonable from a security perspective. But if you want to automate tasks and use deployment tools such as Capistrano, you’ll end up typing that password over and over again, even for a single deployment process. Fortunately, there is a mechanism to avoid this while still preserving good security. But, as with most such things in Windows, it takes a little effort to set it up. (Things are a little simple on Macs, which we’ll cover in a future article.)

SSH authentication uses public key cryptography, in which you have a private key available only to you on your local system, and a matching public key that can be published on your server. Authentication software can confirm that the public and private keys match, but hackers cannot derive your private key from your public key. Once you set up a public-private key pair, these keys can be used to authenticate your SSH sessions, and you won’t ever have to type your password again.

There’s a couple different programs you can use to accomplish this; I’m going to explain how to do it with PuTTY and its associated programs, PuTTYgen and Pageant. If you installed the full PuTTY package, you’ll have all three programs already installed. If not, download the installer and run it now. (Be sure to get the full package, under the heading “A Windows installer for everything except PuTTYtel,” and not just putty.exe.)

Creating Your Keys with PuTTYgen

To create your public-private key pair, run PuTTYgen. There’s several types of keys, but SSH-2 RSA is the most common and is selected by default. (If this doesn’t work, you’ll need to check with your host to see what type of key their SSH server is expecting.) The number of bits defaults to 1024, which is fine. So all you have to do in the PuTTYgen window is click the Generate button, and then wiggle the mouse around a bit. The mouse movements generate random data that ensures that your key is unique.

When PuTTYgen is done creating the key, it will show a long string of characters that make up the public key. Select this text and paste it into a file, named something like id.pub (using notepad or any simple text editor). I made a folder at the root level of my C drive called SSH to store these keys and other related info, but you can put it anywhere you can find it later. (Note: you can also click the Save Public Key button and enter a file name, but this file won’t work as an alternative to the id.pub file we generated with cut-and-paste. It includes line break characters that confuse the server-side SSH code.)

Now you need to save your private key. If you just click the Save Private Key button, PuTTYgen will ask if you really want to save it without a passphrase, because we didn’t enter one. Here you have a choice to make between convenience and security.

The passphrase is essentially a password for accessing the key. Once you have your public key uploaded to your server (which we’ll do shortly), anyone who has access to your private key will have access to your server. If you use password protection on your PC, and you’re the only one with access to it, you might be comfortable going without a passphrase. But it is safest to use a passphrase, and we’ll soon see how you can make it so you only need to enter it once each time you boot your system. So to set a passphrase and save the private key:

Enter it twice, once in the Key Passphrase field and once in the Confirm Passphrase field. Keep in mind that this passphrase is essentially the key to accessing your server, so make it a robust password.
Click the Save Private Key button, and enter a file name (no extension) for your private key. The .ppk extension is automatically appended.

You now have your key pair and are done with PuTTYgen. Next you need to upload your public key to your server and set up your PC to access your private key.

Uploading Your Public Key

The details of uploading your public key may vary depending on the server configuration. The instructions below are for Rails Machine and are derived from the Mac and Linux oriented instructions they provide.

Open an SSH session to your server (using PuTTy, or another client if you prefer, as described in my previous post.) You probably have more than one user account; in my case, following the recommended practices from the Rails Machine folks, I have a root account that I never log into directly, and regular user accounts of Michael and Deploy. The Deploy account is the one I use for almost all communication with the server. So log into that account, or its equivalent for your setup. You’ll have to manually enter the password one last time.

Now, in the shell window that is connected to your server, create a directory for the private key file:

mkdir ~/.ssh

This creates a directory named .ssh within your home directory, which is where the SSH server will look for the public key.

Now set the permissions for this directory so you, but only you, have all privileges:

chmod 700 ~/.ssh

Now you have a directory on your server to hold your public key, and you need to move the key up there. There’s various tools you can use to do this. One tool you should become comfortable with is scp, or secure copy. It is not built in to Windows, but there is a version of it that comes with PuTTY, called pscp. If you add the path to the PuTTY program directory to your system path, you’ll be able to use pscp in any command window. (You may also want to install a set of Unix-style utilities; you can install the entire Cygwin environment, or if you want something lighter weight just for SSH-related tasks, get just the OpenSSH utilities. In either case, make sure to add to your Windows system path the folder in which these programs are stored, so you can use them from any command window without having to type their full path.)

To copy the public key, follow these steps:

Open a Windows shell in the folder in which you’ve stored your public key. (If you installed the Command Here utility as I recommended in the previous article, you can just right-click the folder and choose Open Command Window Here.)

In the command window, type

pscp id.pub username@hostname.com:~/.ssh/authorized_keys

(Of course, you’ll need to replace “username” with your actual user name, and “hostname.com” with the name of your server. If you’ve named your public key something other than id.pub, replace that name as well. Finally, if you’re using scp from OpenSSH instead of PuTTY’s pscp, drop the p in the command name.) This will copy your public key to a file called authorized_keys in the .ssh directory in your home directory.

Finally, to make the key file a little more secure, go back to your SSH window (remember, we started there but then switched to the Windows console), and type:

chmod 600 ~/.ssh/authorized_keys

This ensures that only the owner of this file (that’s the user name you began your SSH session with) can read or write it.

Making Your Private Key Available in Windows

OK, we’re almost there. Now we need to enable Windows programs making SSH connections to access your private key file. You could set PuTTY to use the key file, but that doesn’t buy you much, since it will ask for the passphrase every time you open a connection, and it won’t be available to other programs (such as Capistrano). So, you need to use another program called Pageant, which is installed along with PuTTY, to load the key into memory and make it available to other programs.

You can run Pageant directly via Start > All Programs > PuTTY > Pageant, and then you can tell Pageant to load your private key. But assuming you want the private key to always be available, you want it to load automatically upon startup. To do so, create a text file called load_private_key.bat (or whatever), with the following contents:

start “Pageant” “c:/Program Files/PuTTY/Pageant.exe” c:/ssh/id.ppk

Note that you’ll need to change the path to Pageant.exe if you didn’t install PuTTY in its default location. The id.ppk file is the private key file that you generated from PuTTYgen. (Using the “start” command, rather than simply providing the path to Pageant directly, prevents a DOS window from being left on the screen. Thanks to Tim Jervis for this tip.)

Finally, add this batch file to your startup tasks (Click Startup > All Programs > right click on Startup and choose Open, then right-click the load_private_key.bat file, drag it into the startup folder, and choose Create Shortcut from the menu that appears when you release the mouse).

Now, when you reboot your system, the batch file will run, Pageant will load your private key, and you’ll be prompted for the passphrase that you specified when you created the key. Enter this passphrase just this once, and your private key is now available to all SSH functions. When you shut your computer down, everything is secure again.

Setting up Subversion

If you’re using Subversion, you need to take one more step to enable it to use the private key generated by PuTTYgen: adding a line to Subversion’s configuration file.

Subversion’s configuration file is located in the Application Data directory under your user account. The full path is:

C:\Documents and Settings\{your windows user name}\Application Data\Subversion\config

Note that Application Data is a hidden folder, so to locate this file you must have Windows set to show hidden files and folders.

Open the config file in any plain text editor (such as Notepad) and add the following line:

ssh = $SVN_SSH plink.exe

plink.exe is the command-line link setup program that is included with PuTTY.

You’ll also need to make sure that the PuTTY directory is listed in your system’s Path.

Unfortunately, plink insists on popping up a DOS window, which is annoying. If anyone knows how to stop it from doing this, please let me know!

You’re Done!

That was simple, wasn’t it? :-) This may seem like a lot of trouble to go to just to avoid having to type your password, but once you’ve set this up once, you’re done. And if you’re using an automated deployment tool such as Capistrano, you’d have to type your password multiple times for a single deployment (since one deployment involved multiple SSH commands and other actions); with this setup, it can be fully automated.

Understanding Ruby on Rails

2008-04-22T17:00:00Z

If you’re new to Ruby on Rails, you may be struggling to understand just what Rails is, what it can do for you, and what you need to learn to use it effectively. In this article, we’ll take a quick romp through the various aspects of Rails. We’ve sprinkled links liberally, so you can use it as an annotated table of contents for the rest of the site.

What is Ruby on Rails?

Ruby on Rails encompasses a number of technologies, and some philosophy as well. This can make it challenging to get your arms around just what Ruby on Rails is.

Ruby is a programming language. By itself, there’s nothing about Ruby that is specific to web applications.

Ruby is a modern, object-oriented, dynamic language. In Ruby, everything is an object — even a number is an object that has methods. Ruby is dynamic; data types are assigned dynamically, and you can extend the language itself as it is executing, defining classes, adding methods, and so forth.

Ruby has a very clean, minimalist syntax. This, combined with its dynamic nature, makes it especially suitable for creating extensions to the language that enable your programs to read almost like English.

Rails is a framework for writing web applications in Ruby. The term “Rails” is commonly used to refer to “Ruby on Rails,” which is the official name of the framework.

Why Use Rails?

If the application you are building falls into the very large sweet spot for which Rails works well, there’s no faster way to write it — once you’re up-to-speed on the framework. There’s a sizable learning curve to comprehend the Rails framework, but once you have the basics of it down, you’ll be able to produce robust, fully customized applications more quickly than with any other technology.

Because the Rails approach eliminates a lot of the drudgery of writing applications in languages such as Java, and because it makes changes easy and allows you to write expressive, readable code that is easy to maintain, it is simply more fun to build Rails applications. When coding is more fun, you’ll write better code.

Because Rails requires less code than most other approaches, you can produce a given application with fewer people. Smaller teams are more efficient than larger ones, multiplying the productivity gains of using Rails.

There’s also a great Rails community, so there’s lots of open-source plugins and even complete applications, plus countless blogs and other information sources. It’s an enthusiastic, helpful, programmer-centric community that puts a high priority both on building great applications and on having fun while you’re doing it.

When Not to Use Rails

Rails is not the answer to every problem. Here’s a few situations in which it is probably not the best approach:

If you’re new to Rails but are already up-to-speed in another technology, and the app you’re building isn’t too large, you’ll get the work done more quickly by sticking with what you know. This is the major factor that stops most developers from switching to Rails. If you’re building a large application, or think longer term, however, working your way up the Rails learning curve is very worthwhile.

If you can create the application using something like Joomla, in which you can do a lot without writing any code at all, that’s probably the quickest approach. You loose a lot of flexibility, however.
If the application needs to perform tremendous amounts of computation, the relatively slow speed of Ruby may be a disadvantage. This is quite rare, however, and you can always move the inner loops into a language such as C.
If you expect to have extremely high traffic, your server costs may be higher with a Rails application, and you’ll have to do more innovating beyond what the framework gives you automatically. Then again, the time you save building the application may still make it a worthwhile trade-off.
If you have to share a legacy database with existing code, so you can’t restructure it, it may be hard to make Rails work with it.
If you’re building a static site, Rails is probably overkill. Even so, the templating engine in Rails is very useful for such sites, the built-in caching features can eliminate the need to run the Rails code on most accesses, and you can easily build in your own content-management features. But it is more expensive to host Rails sites than static sites, and there’s a lot more you need to understand to build them.

As you can probably tell by now, we think Rails is a great solution for the vast majority of web applications.

The Rails Philosophy

Before we get into the specifics of what Rails is composed of, it is helpful to understand the philosophy that underlies its approach.

There’s two terms you’ll hear a lot with regard to Rails: “convention over configuration” and "DRY (don’t repeat yourself).

Convention over configuration is a very important principle behind Rails. It goes hand-in-hand with another attribute of Rails, that it is “opinionated software”. The Rails design embodies lots of opinions about how you should structure your code, name your classes and files, and organize your database tables. There are methods to override most of these conventions, but if you go with the flow and follow the conventions, then you can avoid almost all configuration code. That’s convention over configuration — and the payoff is huge.

Keeping your code DRY means avoiding repetition. In its simplest form, it means that if you need the same code in two places, put it in a method so you can write it once and call if from both places. It sometimes increases the amount of work it takes to write your code initially, but it save headaches in the long run. There’s various facilities in Rails to encourage this, but it is something you need to pay attention to when writing your code.

In the past year or so, the Rails community has also leaned heavily toward RESTful architecture. There’s no requirement to use a REST design, but Rails is increasingly encouraging you to do so, and providing tools to make it easier.

Aspects of Rails

Rails is designed to make it easy and fun to create interactive, reliable, database-backed web applications. Rails is a set of programming libraries, but it is more than that — it is an approach to developing web applications. These are the major aspects of Rails:

Rails implements the model-view-controller (MVC) pattern for application design. Your application code is divided into models, which deal with the database and manage the data; views, which present present data to the user and allow the user to interact with the application; and controllers, which mediate between the two.
Rails provides base classes from which your model and controller classes inherit. This endows your classes with a great deal of capability without writing a single line of code beyond the class declaration.
Rails includes Active Record, a module that provides an Object Relational Model (ORM) that automatically instantiates Ruby objects from your database tables. Your code never has to touch the database directly; it deals with Ruby objects, and ActiveRecord takes care of persisting those objects in the database.
Rails provides many classes and methods that facilitate common tasks in web applications, such as processing data from forms and validating data before writing it to the database.
Rails views are created by a templating system that automatically composites each web page from a layout, which typically provides the overall structure for the page, a template that defines the unique content of the page, and a special type of template, called a partial, for elements that are used in multiple places.
The Rails templating system allows you to mix HTML and Ruby code, and it provides a rich set of helpers to simplify the generation of HTML and JavaScript code. There’s also a special type of template for producing XML.
There’s also support for caching pages and parts of pages to increase performance.
RJS (Ruby JavaScript) templates allow you to write Ruby code that the Rails framework translates to JavaScript for execution in the browser. This is a powerful facility for easily creating sophisticated Ajax interactions.
Rails migrations enable you to define your database schema with Ruby code, and to easily migrate from one version of the schema to another.
Testing is built into Rails, streamlining the process of writing and running automated tests for your application at various levels.

So, as you can see, there’s a lot to Rails. And there’s more — the Rails ecosystem includes a number of tools and extension methods:

Generators are special Rails methods that automate the creation of models, controllers, and so forth.
Scaffolds are a kind of generator that automates the creation of a basic set of integrated functionality. Most often this is used to support the Create/Read/Update/Delete (CRUD) views and controller actions for a given model, but scaffolds are available for other features such as RESTful interfaces.
Gems are packages of Ruby code that are easily shared.
Rails plugins are like gems but are installed directly into a particular Rails application.
Two JavaScript frameworks are directly supported by Rails: Prototype, which extends the JavaScript language, abstracts away browser differences, and makes many common tasks simpler; and Scriptaculous, which is a visual effects library.
RDoc and RI are Ruby tools for creating and viewing program documentation.
The Rails Console provides a command-line environment for interacting directly with your application.
Rake is an automation tool for performing common tasks in developing Rails applications, such as migrating from one database schema version to another.
Capistrano is an automation tool for deploying applications. It automates the process of publishing new versions to a production or staging server, and it also allows you to perform many server tasks without having to explicitly log in to the server and issue shell commands.
Mongrel is an application server that is widely used to run Rails applications. Typically an HTTP server, such as Apache or Nginx, serves up static content and cached pages, while requests that require Rails processing are sent to Mongrel.

Now What?

That wraps up our whirlwind tour of what Rails is and why it’s worth learning. Follow the links in the article to learn more about each of the topics. And for an easy way to begin learning, sign up for our free online course in Ruby on Rails.

Silicon Valley Ruby Conference

2008-04-21T17:00:00Z

Last week’s Silicon Valley Ruby Conference was perhaps the year’s largest local gathering of Ruby enthusiasts, with 130 attendees. Although not in the same league as the big-time RailsConf and RubyConf events, it was nonetheless a worthwhile couple of days.

In this article, we present a few tidbits from various talks at the conference. We’ve also posted separate articles from two talks:

The Desert Framework

Parker Thompson from Pivotal Labs talked about the Desert component framework. This open-source framework is a gem that Pivotal Labs uses to easily modularize their application components and quickly assemble them to create new applications.

The Desert framework allows a component to provide models, migrations, routes, controllers, views, and even plugins. It includes a modification to the Rails class loader, allowing code to define a class in multiple places, yielding the sum of all of them. Components are templating language agnostic. The framework deals with dependencies between plugins and load order — something Parker noted should be in Rails.

Pivotal has built about a dozen apps with the Desert framework and has done one full rewrite of the framework. While the framework itself is open source, Pivotal has not, unfortunately, open-sourced any of the components, which limits the immediate appeal. Pivotal may release some of the components in the future.

IronRuby

John Lam talked about the IronRuby project. He is one of two people at Microsoft working on IronRuby. They’ve been working on it for 14 months and are getting “relatively close to running real ruby programs”; John characterized it as “about halfway done.” IronRuby runs on top of the Dynamic Language Runtime (DLR), which in turn runs on the Common Language Runtime (CLR), just as IronPython does.

The runtime environment is part of Silverlight, which is a 4M download, on top of 1M download for video playing, plus 1.5M for DLR and Ruby. When this technology is ready, you could run a Rails view on the client instead of on the server. You could run Ruby “on both sides of the wire” and access .NET routines from Ruby. Because IronRuby lives in the Silverlight security model, it allows Ruby code to run from within the browser without needing to have its own security model.

IronRuby is being released under the Microsoft Public License, Microsoft’s open-source license.

Rubinius and Merb

Tom Morini from Engine Yard talked about the state of Ruby and the Rubinius project. Tom noted that the growth in Ruby jobs is quite dramatic:

ruby, java Job Trends

ruby jobs – java jobs

However, this is on a relative scale. On an absolute scale, it’s clear that there are still vastly more Java jobs:

ruby, java Job Trends

ruby jobs – java jobs

Nevertheless, it is compelling that the number of Java jobs is stagnant, while Ruby jobs are increasing steadily.

Rubinius is a next-generation virtual machine for Ruby that is written entirely in Ruby. The project is now backed by Engine Yard, which hired project creator Evan Phoenix and four other top Ruby programmers to work on it. Tom said they hope to have a demo running Rails by RailsConf in May, and to have a 1.0 release this summer.

There are 136 committers to date to Rubinius, making it the largest Ruby interpreter project by that measure; there are only 53 on the Matz Ruby Interpreter (MRI), 22 on Jruby, and 10 on IronRuby.

The RubySpecs project, which is an RSpec test suite for the Ruby language being built for Rubinius, is becoming the definition of the Ruby language, which has no formal definition. There are currently 22,664 expectations in the tests.

Matz is participating in monthly meetings with other Ruby implementors, which should help ensure that Ruby compatibility remains high even as the number of execution environments proliferates.

Merb, which is also being backed by Engine Yard, is a Rails-like framework that was originally designed to solve file upload problems with Rails applications. It is steadily increasing in capability. Sony is writing backends for PSP and PlayStation 3 games in Merb, and music site MOG is being rewritten in Merb. The 1.0 release of Merb is planned for this summer.

Rails at IBM

IBM’s Anant Jhingran and Julian Kamil talked about using Rails in enterprise environments. It may come a surprise to some that IBM has created a number of web applications for clients using Rails. One example is the site for the National Museum of African American History and Culture, which has launched as a virtual museum while the physical museum is being constructed. The site was created by a team from from IBM’s Innovation Center in Washington, DC.

Anant Jhingran (left) and Michael ‘Max’ Maximilien

The speakers noted that while Rails is not ready to replace core enterprise functions, it can be used very effectively to manage web services and create mashups that draw on other enterprise systems. Julian calls this “penetration from the skin,” rather than attacking the core. He showed that he has Rails running on an IBM S/390 mainframe, and Anant talked about using IBM’s DB2 database with Rails.

One barrier is that some customer contracts prohibit the use of open-source software because they want everything to be fully supported. This is a customer education issue, rather than a technology challenge. In terms of Rails itself, the highly prescriptive nature of Rails (such as the lack of support for natural database keys) is a challenge when working with core enterprise functions.

Michael ‘Max’ Maximilien from IBM’s San Jose research lab showed his DSL for mashups, which allows mashups to be easily defined in a Ruby-based DSL and then automatically creates a Rails application that implements them.

Using SSL in Rails Applications

2008-04-05T17:00:00Z

If your web application manages any private information, you should be using SSL (https://) for those parts of the application. Any data sent over a plain http connection can be “sniffed” by any ISP along the route that the packets take if you aren’t using SSL.

Fortunately, implementing SSL isn’t too hard, once you know what you need to do. This article will talk you through the process. These are the steps we’ll go through:

Create your private key
Create your certificate signing request
Get your certificate
Configure your web server
Set up your Rails application

Creating your private key

The first thing you need is a private key, with which your certificate will be encrypted, and which will be used to encrypt your SSL pages before they are sent. You make the private key yourself. Assuming your server has openSSL installed, enter the following command in an SSH shell:

openssl genrsa -out domainname.key 1024

This creates your private key in the file domainname.key (you should substitute your domain name for domainname, of course, although the name doesn’t really matter). This key is unprotected, so you should ensure that this file is readable only by the root user:

chmod 600 domainname.key

Alternatively, you can create your key in an encrypted form that will require you to specify a passphrase when creating the key, and to enter that passphrase to access the key:

openssl genrsa -des3 -out domainname.key 1024

This makes your key more secure, but it has a big downside: once you’ve installed the key, you’ll need to enter the passphrase any time the web server is rebooted. If you’re not around and there’s an emergency reboot of your server, your site will be down until someone can log in and enter the key.

If you do encrypt your key, don’t forget your passphrase! Without it, your key, and the certificate that uses it, will be worthless, and there’s no way to recover it.

Creating your certificate signing request

Now that you have your private key, you can create the certificate signing request (CSR), which you’ll need to get your certificate.

In the SSH shell on your server, create your CSR as follows:

openssl req -new -key domainname.key -out domainname.csr

You’ll be prompted to provide the name of the company, the country, city, and state, and some other information. The most critical piece of information here is the common name, which must exactly match the domain of the server on which the certificate will be used, including any subdomain. Note that www counts as a subdomain, so one certificate works either with www.domainname.com or with domainname.com. You can also buy a “wildcard” certificate, which works with any subdomain, but they’re much more expensive (at this writing, $199 vs. $19.99 at GoDaddy). (To make your site work with or without the www prefix, you should be redirecting accesses to one or the other, so you’ll only need a certificate for one of them.)

Don’t enter any of the “extra” information that you’ll be prompted for. In particular, don’t enter a challenge phrase, or the certificate signing authority won’t be able to read your request.

The file domainname.csr will now contain a string of text, which you’ll shortly be providing to your certificate authority. The file contents should look something like this:

Getting your certificate

Now you need to choose where to get your certificate, and what level of verification to pay for. To understand the choices, keep in mind that an SSL certificate provides two separate functions:

It certifies, to varying degrees, the identity of the person or business that controls the web site.
It provides the public and private keys for encrypting communications with the site.

You can get certificates at prices ranging from less than $20 to more than $1500, and they all provide the same encryption. The only difference is the degree to which they verify that you are who you say you are, and the seal that they give you to display on your web site. For more on certificates and certificate authorities, see Implementing SSL. Or, if you don’t care about all the fancy stuff (which, for the most part, provides little value) just go to GoDaddy and get your $19.99 Turbo SSL certificate.

The workflow will vary depending on your certificate authority; I’ll describe how it works at GoDaddy.

When you purchase your certificate, you get a credit that is good for one certificate. You then log into the SSL Certificate part of the site and use the credit to request a certificate. The web form provides a form field into which you paste the text from the CSR you generated in the previous step.

When you submit the CSR, the certificate authority will email the administrative contact for the domain to ask if they want to approve the request. This is how they verify that the certificate belongs to the domain. If you purchase a more expensive certificate, at this point they’ll perform additional verification steps to ensure that the certificate belongs to who it says it belongs it.

Once the CSR is approved, you’ll get an email with a link to download a zip file that contains the two certificate files you need to install on your server. One is your certificate, and will be named something like “domainname.com.crt.” The other is the intermediate bundle certificate that establishes the chain that connects your certificate to the signing authority. In GoDaddy’s case, this is gd_intermediate_bundle.crt.

Now is a good time to make a backup of these files. The intermediate bundle is a standard file that you can usually get again, and you can request that your certificate authority re-issue your certificate file. But if you lose the key file, your certificate is worthless, and you’ll have to purchase another one.

Configuring your web server

Now you need to configure your web server for SSL. Just how this is done depends on what server your using, its version, and how it was installed and configured. I’ll describe how it works for a typical Apache 2.x configuration; you may need to adjust this for your situation.

You should already have virtual host definition, either in your httpd.conf file or in an application-specific configuration file that is included into the main httpd.conf by reference. There are two kinds virtual host definitions: name-based, and IP address based. You can’t use name-based virtual hosts with SSL, so you’ll need to have a dedicated IP address for the site that is using SSL. If you only have one IP address for your server, you’ll only be able to have one application. If you want to host multiple applications, your host should be able to provide you with multiple IP addresses.

You’ll need two virtual host blocks, one for the non-SSL parts of the site, and another for the SSL parts. The basic configuration should look something like this:

&lt;VirtualHost 123.456.789.123:80&gt;

  Include conf/apps/domainname.conf.common

&lt;/VirtualHost&gt;

&lt;VirtualHost 123.456.789.123:443&gt;

  Include conf/apps/domainname.conf.common

  # SSL Engine Switch
  SSLEngine on

  # SSL Cipher Suite:
  SSLCipherSuite ALL:!ADH:!EXPORT56:RC4+RSA:+HIGH:+MEDIUM:+LOW:+SSLv2:+EXP:+eNULL

  # Server Certificate
  SSLCertificateFile /etc/httpd/conf/ssl.crt/domainname.com.crt

  # Server Private Key
  SSLCertificateKeyFile /etc/httpd/conf/ssl.key/domainname.key

  # Server Intermediate Bundle
  SSLCertificateChainFile /etc/httpd/conf/ssl.crt/gd_intermediate_bundle.crt

  # Set header to indentify https requests for Mongrel
  RequestHeader set X-Forwarded-Proto "https"

  BrowserMatch ".*MSIE.*" \
    nokeepalive ssl-unclean-shutdown \
    downgrade-1.0 force-response-1.0
  
  CustomLog logs/domainname.com-ssl_log \
    "%t %h %{SSL_PROTOCOL}x %{SSL_CIPHER}x \"%r\" %b"

&lt;/VirtualHost&gt;

Let’s walk through this. The first virtual host block is essentially the same as what you’d have without SSL, except that you have to specify an IP address (123.456.789.123 in this example). I’ve put all the configuration that would normally go here, to set up the proxy to Mongrel and any mod_rewrite rules, into an include file, domainname.conf.common, which is not shown here. Doing so allows the same commands to be reused in the SSL block.

The second virtual host block defines the same IP address, but this time for port 443, which is the standard SSL port. First we include all the common configuration code to handle mongrel and so forth. Then, finally, comes the SSL configuration directives. We need to turn on the SSL engine, specify the encryption to be used, and point to the three files we generated earlier: the key, the certificate, and the intermediate bundle. (The CSR isn’t needed once the certificate has been generated.) In this example, I’ve shown them going in subdirectories of conf, but you can put them anywhere, as long as these pointers match the location.

Next, we set the request header to tell mongrel when there is an https connection. Don’t leave this out, or you’ll have no end of confusing problems in your Rails code!

Finally, there’s a bit of config to keep Internet Explorer happy, and a custom log definition to log SSL accesses to a separate log file (this last bit is entirely optional).

To test all this, enter

apachectl configtest

in an SSH shell. This will check your config files for syntax errors without actually rebooting the server, so in case there’s a problem you don’t leave the server disabled while you sort out any errors.

At last, you can now reboot Apache (sudo service httpd restart), and if everything is correct, you’ll have an operating SSL server.

Tell your Rails app where to use SSL

With the above setup done, you should be able to browse to any page in your application using either http:// or https://. You’ll probably want to leave parts of the site unsecured, since SSL pages put extra load on the server, so you need a way to indicate which pages require SSL, and which don’t.

The ssl_requirement plugin, written by DHH himself, makes this simple. Install the plugin:

script/plugin install ssl_requirement

And then include it at the top of your application.rb file, which effectively includes it in every controller:

include SslRequirement

Now all you need to do is specify, at the top of each controller, which controller actions require SSL:

ssl_required  :login, :account, :payment, :cart

Be sure to include in this list any create or update actions that process form data from SSL pages. The magic of this is that you don’t need to change any links; any access to an action that requires SSL will automatically redirect to https://. If anyone tries to access a page that is supposed to be secure with an http:// link, they’ll be redirected.

You can also provide an ssl_allowed declaration if there are actions that you want to be able to access either way. Such actions won’t redirect to https:// but if that protocol is explicitly specified in a link, it will work.

Check your Ajax actions

For the most part, that’s all there is to it on the Rails side. There’s just one more thing that may require your attention: actions that service Ajax requests.

On any page accessed with SSL, all Ajax requests must use SSL, or they will fail. To make this happen, all you need to do is include the names of the actions that service the requests in your ssl_required statement.

In some cases, you may have Ajax actions that have no code in the controller, but are just rendering RJS templates or other views. For these actions, you’ll need to add an empty action definition block in the controller, and add the action name to the ssl_required statement.

One obscure case is the text_field_with_auto_complete helper. If you’re using this in your view, you’re probably also using the auto_complete_for :model :field shortcut in your controller. This automatically produces an action to respond to the autocomplete requests. But since the action isn’t explicitly defined, how do you tell it to require SSL? You just need to know what the automatically created action is named, which is auto_complete_for_model_field. Just substitute the names of your model and field, and add this action name to your ssl_required statement.

Check for mixed content

One last thing to watch out for is mixed content. If you’re testing in Firefox, you won’t notice it, but in IE, users will get a security warning if an SSL page accesses any non-secure content. You don’t have to worry about links to images and so forth, as long as they’ve been written as paths without the full domain name; those will automatically use the protocol of the main page. But if you have any full links, you’ll need to make sure they are written as “https://” on any SSL page.

One case where this problem can sneak in is with JavaScript snippets for services such as Google analytics. If you have a Google analytics link on your page, change it from “http://www.google-analytics.com/urchin.js” to “https://ssl.google-analytics.com/urchin.js”. (Google has now change its analytics code so this isn’t necessary if you’re using their current code.) This will work fine on all pages, whether they use SSL or not, and it will keep the analytics link from triggering the mixed content warning.

Now you have SSL, but …

Now your site can send pages in encrypted form, so they can’t be snooped on by prying eyes along the path between your server and your user’s computer. And the user can examine the certificate to see to whom it was granted, and know that the browser would warn them if the domain name didn’t match.

Of course, there’s much more to keeping your users’ data secure. You need to ensure that all model requests are properly scoped, and for internal security, you need to make sure that confidential information isn’t leaking out in your logs, exception reports, and backups.

Can Rails Scale? Absolutely!

2008-04-05T17:00:00Z

There’s a persistent chatter about scalability in discussions of Rails, especially among people who aren’t actually using it. When we talk with people considering Rails for new sites, concerns about scalability often come up.

In reality, while Rails is not the world’s speediest framework, the supposed scalability issues are very unlikely to be a legitimate reason not to use Rails.

Where Are the Huge Rails Sites?

Some Rails critics attempt to reinforce scalability concerns by noting the lack of large, well-known web sites running Rails. After all, you won’t find Rails behind the scenes at Yahoo, Google, eBay, MySpace, or Facebook.

The major factor here, however, is not scalability, but age. It takes time for sites to become huge and well known, and Rails is one of the newest web frameworks. So of course it isn’t at the heart of the relatively old, well-known web sites.

It is worth noting, however, that there’s strong interest in Ruby on Rails even at many of these large sites. eBay, Yahoo, and Amazon all have Rails projects under way. Facebook is working with Joyent to support Rails apps on their platform. IBM Global Services is building Rails sites for clients. And Thoughtworks is using Rails for a large fraction of its enterprise development projects.

So what are the largest Rails sites? The highest-traffic Rails site we’re aware of is yellowpages.com. This site isn’t in the same league as Yahoo and Google, but it sees much higher traffic than anything you’re likely to build (see figure). The second-highest-traffic site we’ve been able to identify is Revolution Health, headed by AOL founder Steve Case.

Note that this graph shows visits, so you can multiply the figures by perhaps 4 to 5 to get pageviews. That puts yellowpages.com around 100 million pageviews per month (Update: as you’ll see in the comments below, developers at YellowPages.com report that they’re serving around 170 million pages per month), and Revolution Health at around 30 million. Of course, these are unconfirmed, third-party estimates, so they aren’t precise, but they’re probably in the ballpark.

The oldest Rails site of all, Basecamp, is unfortunately hard to measure because its users are spread across many domains and subdomains. Basecamp claims over 1 million users, but it’s impossible to know what that really means.

Twitter is perhaps one of the highest-traffic Rails applications, in terms of transactions per second, but because most of those accesses are not web page views they don’t show up in public measurement metrics. Twitter had some well-publicized problems scaling their Rails infrastructure, but in fact these problems were overcome with a couple months work. Somehow this fact generated less publicity. Twitter remains on Rails.

Some other well-known Rails sites include CNET’s Chowhound, 43things, Spock, and Penny Arcade. At least in how they show up on measurement services such as Alexa and Compete.com, however, their traffic isn’t close to that of yellowpages.com or Revolution Health.

So, for now, yellowpages.com seems like the best proof point. If you have any data to add about these or any other sites, please let us know.

Sources of Scaling Issues

Concerns about Rails scaling probably come, in part, from Ruby’s reputation as a relatively slow language. No one will argue that Ruby is a speed demon. But it’s also true that it is a very rare web application that comes anywhere close to being compute-bound. Database access and network delays are almost always the overwhelming factors. And in the coming year, we’ll see major improvements in Ruby speed, as Ruby 1.9 moves into widespread use and alternative execution environments, including JRuby and Rubinius, reach production systems.

There’s a lot of different things that can slow down a web application. Rails makes it easy to get your application running without worrying about any of the performance issues, and that’s a good thing. If you ignore everything about performance tuning, you’ll still have a working application, and from there you can tune. There’s little point in tuning for performance before you have something that is successful for a small group of people. And if you focus on building an optimally scalable site and end up late to market as a result, you’ll have achieved nothing.

Rails provides a rich set of caching mechanisms that can dramatically increase the speed of most web applications. You can typically achieve dramatic performance gains by applying page, action, and fragment caching. And for big sites, memcached is a popular solution. In many cases, these solutions largely take Rails out of the picture for the highest-traffic pages.

Another common source of performance problems is slow database queries. The ease with which you can access your data without writing any SQL or thinking too much about how associations really work can lead to very inefficient queries. So the next step after implementing caching is to look for queries that are being executed in loops and could be replaced with a single query. A simple change can sometimes yield an order-of-magnitude speedup.

The next step is to look for individual queries that are slow. Often, data can be cached, using memcached or other solutions, eliminating queries entirely. And denormalizing the data can yield huge gains.

There’s a variety of tools available to help you do so. You may need to add databases indexes, or add some :include clauses, or otherwise refactor your queries or your data. These are problems that apply to all frameworks and programming languages. Rails just makes it easier to ignore all these issues if your application isn’t performance limited — which is probably the case for 99.9% of all web applications.

Scaling the Hardware

If you’ve done all this and you’re down to a fundamental database performance bottleneck, you’re neither better nor worse off with Rails than with any other web framework. All the usual solutions, such as adding mirrored read-only database servers, can be applied just as well to Rails apps as to those built with to Java, or PHP, or whatever.

When it comes to handling massive HTTP traffic, you can scale a Rails application horizontally just like any other by replicating your front-end web servers behind a load balancer. There’s nothing about Rails that makes this more difficult than with any other technology.

If you need to scale your Rails processing, you can add more Mongrels to your heart’s content. (Mongrel is the most widely used Rails application server.) It is possible that the overhead of Rails means you’ll need to devote more hardware to executing your application code, but as we discuss in the following section, the time savings of using Rails can pay for a lot of extra hardware.

This kind of horizontal scaling is getting easier and less expensive all the time, as hardware costs drop and “cloud computing” solutions such as Amazon’s EC2 become more widely used. RightScale can automate much of this scaling for Rails applications, even allowing you to quickly add more servers when demand peaks.

The Bottom Line

Scaling a web application to very high traffic levels is hard work, no matter what framework you use. Today, there is more experience in doing so with Java and PHP applications than with Rails applications. But every day there’s more experience with high-traffic Rails sites, and the majority of the techniques used apply equally well to all frameworks and programming languages.

Even if the overhead of Rails does increase your hardware requirements, it doesn’t necessarily increase your total costs. Suppose the ease of Rails development means that you can do the same work with 4 developers that would require 5 with another technology. (Many teams will tell you that this is a gross understatement of the savings, but it’s plenty to illustrate our point.)

Eliminating that single developer from your team will save you somewhere between $100,000 and $250,000 per year, depending on how senior they are, how well you pay, and what your overhead is. But let’s stick with the low end of the range. For $100,000 per year, you can get perhaps two-dozen high-end servers at a first-class hosting facility. That will get you quite a few more Mongrels.

If you’re at Yahoo or Google looking at replacing your core infrastructure, then you’d better look very carefully at scaling issues, and it might be worth using the most compute-efficient language to minimize that amount of hardware you need. But for nearly everyone else, all the concerns about Rails scalability are just noise. Don’t let the FUD keep you from choosing the technology that will maximize the efficiency of your development team.

For Further Reading

See our Performance Tuning section for links to a variety of related resources.

It’s boring to scale with Ruby on Rails, a July 2005 article by David Heinemeier Hansson
The adventures of scaling, Stage 1 by Patrick Lenz. He replaced a 50,000-line PHP site with a 5,000-line Rails site.

If you want to read up on the Twitter story, here’s some references:

Interview with Twitter developer Alex Payne, which is what started the whole controversy
Scaling Twitter presentation from RailsConf 2007
Video of Scaling Twitter presentation given at the Silicon Valley Ruby Conference in 2007
Kevin Clark’s article on the controversy around Twitter’s scaling challenges

Add to the Community Knowledge

If you have first-hand knowledge of traffic numbers at a large Rails site, or stories of scaling challenges and solutions, please add your comment here, or send us an email.

Jared Spool's Web App Summit

2008-03-30T17:00:00Z

Last week’s Web App Summit, produced by Jared Spool’s User Interface Engineering, had more than the usual quotient of quality talks. The presentations were almost entirely focused on user experience, with technology and business receiving only tangential attention. Even the day titled “Going from concept to code” never really got to code, but there were enough user experience insights to make it a worthwhile couple of days.

As one might expect of talks focused on user experience, most were quite visual and don’t lend themselves to written summaries. What follows is a random sampling of tidbits that made it into my notes in an intelligible form.

Jared Spool, UIE

If you’ve ever seen one of Jared Spool’s numerous conference presentations, you know that he is one of the industry’s more entertaining and insightful speakers. His introduction followed a theme of “web apps: where business rules meet user experience.” The point, essentially, is that business rules sometimes need to be bent in the name of user experience. Jared advocates putting the user experience first, and using that to help define the business rules.

It’s often the little things that get customers excited. Jared calls these “delighters.” As the Kano Model describes, customer needs can be divided into three categories:

Basic needs are the things that everyone expects. If you don’t meet them, it’s a huge negative factor, but doing more than is expected has no benefit.
Performance needs are attributes that vary over a wide range, and for which the customer values each improvement.
Excitement needs are the “wow” features, which can produce lots of user satisfaction for a relatively low investment — if you pick the right thing to implement.

This theme came up repeatedly with other speakers: it’s the little things that go beyond what’s expected that give big boosts in user satisfaction.

Steve Mulder, Molecular

Steve Mulder gave an excellent talk about user experience with rich internet applications. He started with the question “To richify, or not to richify?” His answer is that the designer should ask:

What are common activities that could be easier?
Where do users want more flexibility or power?
Where are brand-immersive experiences valuable and effective?

As an example of an application in which an Ajax interaction significantly improves the user experience, Steve cited a single-screen checkout process. Products remain displayed on the left, while the form area on right is replaced, using Ajax, as the user goes through the checkout process.

Steve recommended that designers “prune with ferocity,” overemphasize the core, underemphasize the cool stuff, and be obsessive about a consistent visual system for interactivity cues.

Another interesting point was the clarification of two similar, but different, issues:

Findability — finding something you know is there
Discoverability — finding something you don’t know to look for

Jeremy Keith, Clearleft

Jeremy Keith gave an entertaining and largely visual talk which I’m hard pressed to summarize. But here’s a few tidbits:

A conceptual metaphor is using one idea to describe another
The web uses conceptual metaphors all the time — move, navigate, browse, surf
In this metaphor, the user is a traveler, URLs are places
Interaction is different conceptual metaphor — staying in one place and interacting with various things
Ajax enables interaction metaphor on the web — user stays in one place
Ajax does not mean JavaScript — asynchronous is what makes ajax special
Best Ajax definintion: communicating with the server without refreshing the whole page
Use progressive enhancement. First build the site without JavaScript. Then add JavaScript enhancements, but ensure that it continues to work without JavaScript.
Keep the business logic on the server

Bill Scott, Netflix

Bill Scott, who directs the user experience team at Netflix and previously led the group at Yahoo that, among other things, created the Yahoo UI Pattern Library, gave an excellent talk on antipatterns: patterns to watch out for in your user experiences. His presentation is available online, and while it doesn’t quite stand alone without the narrative, it’s still worth a look.

Here’s a few of the antipatterns:

Meandering way

Need to move the mouse back and forth to complete a series of actions
Solution: reveal hidden tools on hover; avoid popup and page jitter; play on spatial memory
Anytime anything moves, it attracts the eye, so don’t move things you don’t mant to draw attention to
To analyze, draw arrows for each move required to complete a task

Pogo stick navigation

Need to move back and forth between pages to accomplish a task
Solution: encapsulation of click stream into an overlay
Use in-context tools
Be careful with overlays to make the back button do the expected thing

Tiny targets

Making key interaction targets too small
Apple site: video play button is 8 × 8 pixels, grey on grey, sometimes not near video (if large surround)
Use “call to action”-style buttons

Hover and cover

Pop-ups on hover can cover other important info
Hover is good for invitations but not for actions

Animation gone wild

You know what this means!
nasa.gov (animated menus and collapsing sections)
Carousel effect (amazon, others)
Tabs that animate change of content like a carousel
Just because you can, and it looks cool, doesn’t mean that you should

Missed moments

Not providing feedback throughout an interaction
Think “interactive directions” — moment-by-moment directions are the key

Bill is working on an interaction design book, which will include a section on antipatterns. It won’t be out for some time, but it promises to be worth watching for.

Sean Kane, GetListed

Sean is currently a principal in the startup GetListed, an “employment marketplace” that he wasn’t ready to talk about. His talk instead focused mostly on observations from Netflix, where he previously led the user experience group, and what start-ups can learn from big-company processes and techniques. (Sean actually spoke on the second day, but I’m including him out of order to keep the Netflix thread going.)

One of Sean’s themes was the value of data. With Netflix’s 7-million-plus user base, it has a great deal of data, and is able to use this data to evaluate alternative designs and features.

One example of a data-driven decision: Netflix recently went from an 800-pixel-wide design to one that is 950 pixels wide, when data showed that only a very small part of the user base was using browser windows less than 1000 pixels across.

Another interesting example was the way Netflix evaluated whether to add a “multiple queues” feature, so a single user could have multiple movie lists. They put a button labeled something like “Add New Queue” on the queue page, and if you clicked on it, the resulting page simply said “Sorry, this feature is still in development.” In the end, few people clicked on the button, and the feature was never developed.

Yet another good case study was the way Netflix evaluated various user interfaces for showing customers a series of trailers that had been chosen for them by the recommendation engine. They implemented several different UIs, ranging from a very simple one that give the user no options but to advance from one trailer to the next, to a more complex UI that showed the user a series of box shots next to the video player, which the could click on to move from trailer to trailer.

In qualitative testing, users liked the more capable UI. In quantitative testing, on the other hand, users of the more capable UI clicked on lots of movie boxes, but in the end they watched fewer trailers and performed fewer “Add to Queue” actions, which is what Netflix wants them to do. So the simpler UI turned out to be better in terms of meeting the business goal, even though it was not the one the designers liked best, the one that was most capable, nor the one that was favored in qualitative assessments.

Sean emphasized the importance of agility. Netflix, even though it now a large company and runs a very high-traffic site, uses a two-week release cycle. This gives it more than 20 times a year to test new features and make incremental changes. Most changes aren’t overtly noticed by users.

(This is in striking contrast to one large photo sharing site with which I had some dealings with in the past, which updates their site quarterly.)

Andrew DeVigal, New York Times

Andrew DeVigal is the multimedia editor at the New York Times. You can see the wonderful presentations his team produces in the multimedia section of the Times site.

Andrew’s team is creating some of the best examples of using Flash to present information in a compelling way. I found it interesting that his team is not divided into journalists, designers, and Flash coders: his team members play all three roles.

Jason Fried, 37 Signals

Jason Fried led off the second day and, thankfully, did not give yet another “getting real” talk but instead talked about the details that make a design great. Unsurprisingly, most of the examples came from 37 Signals products.

It was interesting to see how much thought has gone into some of the hidden details. One of the hallmarks of such details is that when they’re done right, you hardly notice them. But if they hadn’t been done right, they’d be annoyances.

Ironically, as one of the often-cited “Web 2.0” applications, Basecamp and its brethren exhibit almost none of the classic “Web 2.0” visual design traits, such as rounded corners and gradients. 37 Signals has focused on usability, not on visual appeal.

One essential practice, which would seem to be obvious but is somehow overlooked by far too many web applications, is really understanding the user’s workflow and minimizing the number of clicks required to accomplish a task. As an example, Jason showed how few actions are required to create a new to-do list in Basecamp and add items to it.

Some other examples of details that make a difference:

Take care with copywriting: avoid technical terms, be explicit, write from the user’s perspective. An example: in Highrise, access rights for a contact aren’t labeled “permissions”; the list is headed “Who can access this contact” and has choices like “Only I can”.
Event timing can be critical. Example: in Basecamp, an edit link appears to the left of a task when you hover over the task. But when you move your cursor to the edit link, it doesn’t disappear immediately if you overshoot; it sticks around for a quarter of a second.
If you have multiple 37 Signals applications, you can now get a set of drop-down menus at the top of the page that let you move easily among them. Since you have to pass over these menus to get to the browser controls, the designers didn’t want them flashing up. So
they don’t pull down until you hover for them for 1/4 second.
Keep the user oriented when changes happen. For example, when completing a task, it appears crossed out briefly, then fades away, then disappears and space is reused.
Scrolling up the browser when inserting an ajax dialog, so the entire dialog and the submit button is visible.

All this attention to detail is what sets a great design apart for the pack. “The craftsman spends time on details because he doesn’t know any other way” — great designs come from designers who are obsessed with the quality of what they’re producing.

In response to an audience question, Jason admitted that 37 Signals does not do any formal user testing; they just pay attention to feedback from real users. It no doubt helps that they’re designing for users much like themselves.

Hagan Rivers, Two Rivers Consulting

Hagan Rivers gave an excellent talk showing examples of how she takes existing designs and makes them more usable and more attractive. She’s been designing web applications since there was such a thing, and she and her husband run a design shop that specializes in “application design makeovers.”

Hagan put together a great set of visuals for this talk, and I can’t begin to do justice to them in words. Here’s her summary list of makeover tips:

Remove as much as you can
Be obsessive
Improve just one thing
Create strong groupings
Let data rise out
Beware the navigation that eats pixels
Leverage your templates
Watch out for technicolor headaches
A single purpose for each screen
Prioritize what’s there
Never rest!

If I had a web app that needed a design makeover, Two Rivers would definitely be on my short list of companies to ask for help.

Derek Featherstone, Further Ahead

Derek addressed the issues of design for accessibility. This is a huge challenge for web application designers, and folks like Derek make a big contribution by evangelizing for better accessibility.

Derek encouraged designers to look at the needs of impaired users holistically, and not to take a compliance-based checklist approach. To create an accessible application requires thinking through a lot of issues that just aren’t on most designers’ minds.

In my own work, I have to admit that I find it overwhelming to consider all the accessibility issues, when we’re still working 110% on getting the core experience down. But as we become more intimate with what accessibility requires, it affects our coding style, and as we get further along in our development, we’ll pay some particular attention to accessibility.

Knowing when you’ve done well isn’t easy, either. Reading web pages with a screen reader is an art unto itself, and not one that a sighted designer or developer is likely to develop. So you really need to have contact with impaired users who can give you feedback on where your design creates problems for them.

If you need help with design for accessibility, check out the consulting services that Further Ahead offers.

In Closing

Jared Spool brings a nice levity to his talks, and even performed magic tricks during some of the breaks. In this spirit, I’ll close with one of his jokes.

Why are New Yorker’s always depressed?

The light at the end of the tunnel is New Jersey

File Upload Form Testing Fixtures

2008-02-04T16:00:00Z

Recently, I needed to write my first set of functional tests for a form that is used to upload image assets into our Content Management System. I wanted to find something as easy as fixtures for testing this part of our program.

Whether you are using Rick Olson’s excellent attachment_fu (see Mike Clark’s nice tutorial), Sebastian Kanthak and Jonas Nicklas’ upload_column, or your own code that works with file uploads, you should test this workflow just like any other code path. At first, I thought this was going to be a painful task and require messing around with some custom File I/O or other marshaling trickery. Most of the documentation for 3rd party file upload implementations tended to have little or no information on testing.

Then, while reading through the code a bit more, I stumbled upon fixture_file_upload. This convenience function is tucked away in ActionController’s TestProcess module and is shorthand for instantiating the underlying ActionController::TestUploadedFile class. TestUploadedFile itself is a mock object that simulates the target file that my user would upload in a form or other interface via a MIME multipart/form-data POST.

To use this handy method, I simply put test files in a convenient directory within my fixtures directory, say “files”. Then in a test for upload_column, I write:

def test_should_create_asset
    old_count = Asset.count
    post :create, :asset =&gt; { :title =&gt; "test", :file =&gt; fixture_file_upload('/files/testpicture1.jpg', 'image/jpeg') }
    assert_equal old_count+1, Asset.count
    assert_redirected_to asset_path(assigns(:asset))
 end

Here, the :file attribute for my asset model is expecting an uploaded file from my form, so I feed it one from my fixtures/files directory.

If I use attachment_fu, I may write a create test:

  def test_should_create_asset
    old_count = Asset.count
    post :create, :asset =&gt; { :name =&gt; 'railslogo', :uploaded_data =&gt; fixture_file_upload('/files/rails.png', 'image/png') },
                   :html =&gt; {:multipart =&gt; true }
    assert_equal old_count+1, Asset.count

  end

or an update test:

  def test_should_update_asset
    put :update, {:id =&gt; assets(:one).id, :asset =&gt; { :uploaded_data =&gt; fixture_file_upload('/files/rails.png', 'image/png') }}
    assert_redirected_to asset_path(assigns(:asset))
  end

The TestUploadedFile class is not limited to image data. It can channel any type I may wish into the request. Its default content type assumes text/plain.

Now I can proceed to write a suite of tests for my file upload use cases and let Action Controller and the fixture_file_upload helper do the heavy lifting.

Other Resources

2007: The Ruby on Rails Year in Review

2008-01-08T16:00:00Z

Ruby on Rails had a very good year in 2007, continuing to gain traction as one of the leading web development frameworks and making progress on many fronts. Although it is not yet nearly as widely used as PHP, Java, or .Net, it has become perhaps the most common platform for web startups, at least within the “Web 2.0” space.

In addition to all the startups that launched in 2007 using Rails-based applications, many established companies converted existing applications or began new ones using Rails. Some examples:

Yellowpages.com replaced a J2EE system with a new Ruby on Rails application. This may be the highest-volume Rails site currently operating.
Twitter added a new kind of instant messaging, with an application that seriously stressed the scalability of Rails.
The originators of Rails, 37Signals, added the Highrise contact-management application to their portfolio.
Revolution Health is a large health information site led by Steve Case.
MicroPlace, a microfinance investing site, is owned by eBay — until now, a hard-core Java shop.
Yahoo, until now mostly a PHP shop, began alpha testing a new geolocation platform, called FireEagle, which is written in Rails.

New Versions of Everything

The big news on the technical side was the release of version 1.2 early in the year and version 2.0 at the end of year. There were also major new releases of key related programs, including Capistrano 2.0, Prototype 1.6, and Scriptaculous 1.8.

Rails is still very young, but it is no longer a newborn. Basecamp, the application from which Rails was originally extracted, is now almost four years old. To be sure, there have been some teething pains, and a few people who have vocally abandoned Rails. But Rails is clearly a healthy adolescent, with a great future as an adult ahead of it.

Rails 2.0 shows signs of a maturing framework; despite the “major” version number, the changes are more incremental than those from 1.1 to 1.2, and there’s more attention to backward compatibility.

Rails Community Growth

The Rails community, whatever you may mean by that, grew dramatically in 2007.

No doubt there are many more people building with Rails today than there were a year ago, though we haven’t been able to come up with a specific way to measure that.

The past year has seen an amazing proliferation of Ruby on Rails books. At the start of the year, I had 5 Ruby and Ruby on Rails books on my shelf. I may have missed one or two, but not more than that. One year later, I now have 27 books on Ruby and Rails.

There’s a dozen or so introductory books now, with dozens of application examples, as well as one outstanding new reference book: The Rails Way. And there’s specialty books on topics including mapping, social networking, Active Record, and Prototype and Scriptaculous.

RailsConf in May 2007 attracted a sell-out crowd of more than 1,600 attendees, triple the previous year’s attendance, and organizer O’Reilly said it was their fastest-selling conference ever. The was also a successful RailsConf in Europe in the fall, several regional RailsEdge conferences, a larger-than-ever, sold-out RubyConf, and many smaller events.

Strife at the Fringes

Like any large and growing community, the Rails community has its detractors. In a recent article, which got a lot of attention because it was, in a peculiar way, a fun read, Zed Shaw attacked the Rails community and proclaimed his plan to move away from Ruby and Rails. As the author of Mongrel, the application server used by the vast majority of Rails apps in production today, Zed’s programming chops are unquestioned. But we find it unfortunate that he’s created an “us” vs. “them” situation, and that he turns technical disagreements into personal attacks on other people.

Another notable article was written by CD Baby creator Derek Sivers, after he gave up on a two-year effort to rewrite his PHP site in Rails, and went back to PHP. The key point of this piece, as we see it, is that if you are expert in a technology and you have a detailed idea of what you want to build, it can be frustrating to switch to another technology, especially one that makes you learn new ways to make things easy, and that constrains how you can implement things.

Part of what makes Rails great is its “opinionated” design, and of course that means there are opinionated people at the heart of the Rails community. A small group of people holds a great deal of power over Rails, and if you happen to disagree with that group, it can be painful. Our experience has been that the vast majority of people in the Rails community are smart, friendly, and contribute a lot.

There’s a few people, including David H. Hansson, Dave Thomas, Mike Clark, Chad Fowler, Michael Koziarsky, and Jim Weirich, without whom we just wouldn’t have the Rails software and community as we have it today. Many others no doubt belong on this list as well. They’ve made incredible contributions during the past few years. Remember that, in most cases, no one is paying anyone to build and maintain the Rails framework. (This not to say that these people haven’t built businesses around Rails, of course, as we have.)

The Rise of REST

Perhaps the most far-reaching change in Rails during the past year has been the whole-hearted adoption of RESTful design practices. Rails 2.0 eliminates the old scaffold entirely and replaces it with what had been called resource_scaffold, which is indicative of the core team’s belief that all applications should be designed as a set of resources with RESTful interfaces. REST even got a book of its own in 2007: the surprisingly readable RESTful Web Services.

The rise to prominence of the RESTful approach has many advantages, but it does present additional hurdles for newcomers learning Rails. Conventional routes are easier to understand, but with the scaffold no longer using them, new users will be thrust immediately into REST. At least it is now clear that there’s really no alternative to coming to grips with REST if you want to follow the Rails golden path.

h2. Development Tools Proliferate

A year ago, you wouldn’t find many Rails developers using an IDE. TextMate and the console were, and remain, the most widely used development setup. But IDEs are gaining ground.

At the end of 2006, the open-source RadRails project, based on Eclipse, began gaining some traction. In early 2007, RadRails was acquired by Aptana, which has now built a much enhanced version of the Rails support from RadRails into its Aptana Studio development environment.

Sun lent its support to Rails with the introduction of Ruby and Rails support for NetBeans. NetBeans 6.0 went through a series of beta releases, culminating in the official release late in 2007. NetBeans works either with Sun’s JRuby or with the native Ruby interpreter.

And there’s more — Borland’s CodeGear now supports Rails, ActiveState offers Rails support in its Komodo IDE, and SapphireSteel offers Ruby in Steel, a set of Ruby extensions for Microsoft’s Visual Studio.

Looking Forward

We’ll save most of our prognostications about the future for other articles. But one key trend to watch in 2008 is the emergence of Rails running on various virtual machines, including Ruby 1.9, JRuby, Rubinious, and IronRuby. By the end of the year, it will probably be a lot harder to attack Ruby on the basis of its being slow.

What Did We Miss?

We’ve touched on just a few highlights in this article. What do you think were the most significant Rails events of 2007? Add your comments and we’ll update the article after a bit with the most notable additions.

Better Rails Scaffolding

2007-12-31T16:00:00Z

One of the things that created a lot of early attention for Rails was the scaffolding, which makes it possible to create an instant admin interface for your database tables. While the built-in scaffolding was interesting two years ago, it clearly has received no attention from the core team, which doesn’t use it. It is really pretty horrible; for example:

The standard CSS is really, really ugly
It deals with only one table at a time and ignores associations
It is hard to customize; generally, you end up just stripping it out and replacing it
It doesn’t use any AJAX

There have been various attempts to build a better solution; the two best-known are Streamlined and Ajax Scaffold. The latter evolved into ActiveScaffold, which yesterday reached a big milestone: version 1.0 was released. I haven’t yet had a chance to deeply evaluate the two against each other, but one thing is clear: there’s no longer any reason to use the standard scaffolding.

Unlike many Rails plugins, ActiveScaffold actually has extensive documentation. I’m looking forward to being able to actually use scaffolding for admin functions now instead of having to build them from scratch. It’s great to be using a framework with such an active developer community that dives in and solves problems such as this one. And, of course, it’s all open source.

BuildingWebApps Articles

Web 2.0 Expo: TV and Radio with an API

Web 2.0 Expo: Web Developer Tools

Web 2.0 Expo: Social Media

Social Media Marketing – why it fails and how to fix it

The Whuffie Factor

Slides

Video

Other Social Media Talks

Designing Social Interfaces

Designing Social Websites

Building Sites Around Social Objects

Social Media Buyer’s Guide

Beyond Buzz: Measuring a Conversation

Web 2.0 Expo San Francisco Spring 2009

March 31 – April 3, San Francisco

Enhancing Conditional Routing in Rails

The Goal — Conditional Routes in routes.rb

The Implementation

Startup Camp and Foo Camp

Startup Camp

Foo Camp

Retrospection

More Foo Stuff

Setting up Rails on Tiger (Mac OS X 10.4)

Prerequisites

The Recipe

Native Development Tools (X11 and Xcode 2.5)

MacPorts

Ruby and Ruby Utilities (irb, ri, rdoc)

Ruby Gems Package Manager

Installing a Subversion client

Installing Git via MacPorts

Installing MySQL via MacPorts

Gems

Code Editing Tools

Setting up Rails on Leopard (Mac OS X 10.5)

Prerequisites

The Recipe

Ruby and Ruby Utilities (irb, ri, rdoc)

Ruby Gems Package Manager

Native Development Tools (Xcode 3.0)

MacPorts

Installing Git via MacPorts

Installing MySQL via MacPorts

Gems

Code Editing Tools

Podcasts and Screencasts on Ruby on Rails

Podcasts

Tutorial: Learning Rails

People: Ruby on Rails Podcast

News: Rails Envy

Screencasts

Learning Rails

Envycasts

Railscasts

Peepcode

Pragmatic Screencasts

RubyPlus

Coderpath

Zenunit Sensei

The Rebuilding and Scaling of YellowPages.com

Why the rewrite?

Why Rails?

Keeping the project moving

System architecture

Performance optimization

New Crop of Rails 2.0 Books

For Beginners

Getting Started with Rails, for Experienced Developers

Going Deeper

Easy Text Formatting with Textile

What is Textile?

Implementing Textile

Making Textile Even Easier

Markup without Coding

Web 2.0 Expo Highlights and Factoids

Tim Bray: Ruby is the Leading Language for Web Applications

Setting up Rails on Windows XP

Prerequisites

Matt Mullenweg: The Architecture of WordPress

Matt Mullenweg of Automattic (makers of WordPress, Akismet, and more) highlighted his thoughts on scaling from multiple angles (platforms, business, community, and teams). This was a wide ranging talk, of which there were a few technical tidbits.