Last night, I was lucky enough to see Bill Scott (of Yahoo Design Pattern Library, YUI, OpenRico, Netflix fame) present at my local Ruby user group. He shared his thoughts about the successful design patterns that have defined today’s web. As someone who enjoys brilliantly designed “things” including web apps and sites, I found his talk very interesting.

Most (actually, all) of his talk was devoted to the consumer web. My head is almost always focused on how to take the good stuff coming from the consumer web back into the enterprise web. Bill’s ideas made me realize how little we (as enterprise web app developers) pay attention to the minute details that go into producing web apps that customers love. Bill is currently the Director of UI Engineering at Netflix. If you’re a Netflix customerfan, you’ll know that Netflix.com is a superb site. Netflix’ business depends entirely on the success of its site. Very small incremental changes could drastically affect their business. All of the changes they make to the site go through rigorous testing with real users and are carefully measured.

With the enterprise products I’ve been a part of building, we’ve spent some time on usability tests. However, they’re usually done before the product is even passed over to development. They’re usually done during the visual design phase. Once the UX teams have finalized their product designs, they’re approved and passed over to the developers to start building. However, most of the time, the product doesn’t end up matching what was designed by UX.

This process wasn’t always this way. I remember back in the PeopleSoft client-server days, most products didn’t go through any usability tests. I suppose the reasoning is that back then, most of the “ERP” apps were focused on back-end users who were trained to use the software so usability wasn’t that big of an issue. Today’s focus is in building apps that anyone can use without training. Aside from testing usability, I don’t know if we focus enough on learnability. In order for software to be easy enough for anyone to use, it needs to provide enough queues for users to be able to learn how to use it. Bill provides a lot of examples in his presentation above of how to do this.

The problem with the the visual design process in the enterprise today (as I see it) is that it doesn’t follow good software development practices like agile. Once a visual design is finalized, it’s passed on and never really iterated for improvements. Some enterprise software development cycles could take over a year or two from concept to design to build to release. Over that time, new UI patterns could have emerged as well as totally new ways to solve the same problem that the software originally sought out to solve. This is the reason why agile methodologies exists.

What Bill described as his overall process for building good looking web sites that work can be reduced down to an agile process for visual design. It doesn’t make sense to design once then move on. The process needs to be iterative. Feedback from real users with real data need to be used as a way of testing ideas and measuring success rates iteratively. I’m no expert with UX, but this process makes a lot of sense to me.

Anyone out there in Oracle UX land care to comment? Are you guys already doing this? If so, how’s it working?

BTW, Bill’s got a book coming out on this topic… added to my wishlist.

  # search_controller.rb: default execution searches multiple models.  If a scope param is provided
  # it will search only that model.  multi_solr_search can return two two different formats, the object
  # name and id, or the actual object.  If you're query returns a lot of results, you don't want to load
  # up every single object.  The code below loads the object name and id then just loads the object
  # for the current paginated group.  This is using will_paginate.
  def all
    if params[:scope] and ["UserProfile", "Idea", "Question", "Group"].include?(params[:scope].classify)
      scope = params[:scope].classify
      models = [scope]
    else
      scope = "UserProfile"
      models = [Idea, Question, Group]
    end

    # execute solr multi model search based on the scope selected above
    solr_results = scope.constantize.multi_solr_search(params[:q],
                                                 :models => models,
                                                 :results_format => :ids,
                                                 :limit => 1000).docs.compact
    @total = solr_results.size
    solr_results = solr_results.map {|m| r = m.fetch("id").split(":")}
    per_page = 10
    page = params[:page] || 1

    # determine array indices that are to be included in the current paginated group
    first_idx = (page.to_i > 1) ? ((page.to_i - 1) * per_page) : 0
    last_idx =  (first_idx + per_page.to_i - 1)
    last_idx = last_idx <= (@total - 1) ? last_idx : @total - 1

    # only load the objects in the current paginated group
    offset = 0
    first_idx.step(last_idx,1) do |idx|
      begin
        solr_results[idx + offset] = solr_results[idx + offset][0].constantize.find(solr_results[idx][1])
      rescue # make sure we don't blow up if an object doesn't exist
        @total -= 1
        offset += 1
      rescue
      end
    end
    @results = solr_results.paginate(:page => page, :per_page => per_page)
  end

I’d love to see if someone could clean this up more. Any takers?

  if RAILS_ENV == 'test'
    config.load_paths << "#{RAILS_ROOT}/vendor/mocha-0.5.4/lib"
    config.load_paths << "#{RAILS_ROOT}/vendor/dust-0.1.4/lib"
    config.load_paths << "#{RAILS_ROOT}/vendor/unit_record-0.3.0/lib"
    config.plugins =
      Dir[ "#{RAILS_ROOT}/vendor/plugins/*" ].map { |p| File.basename p } -
      %w{ acts_as_solr }
  end

  unless RAILS_ENV == 'development'
    config.plugins =
      Dir[ "#{RAILS_ROOT}/vendor/plugins/*" ].map { |p| File.basename p } -
      %w{ query_trace migration_buddy }
  end

Aside from the static references to different gems that are to be loaded, there’s a flaw in how the plugins are loaded… can you see it? Hint, the second conditional (unless RAILS_ENV == ‘development’), recreates the config.plugins array which would overwrite the “test” environment’s setting before it.

This made me seek out a better way of excluding plugins. I found two different solutions, but neither of them worked on Rails 2.1.x. So, here’s what I came up with:

  # Load all plugins with init.rb... :all does the same thing, but doesn't allow
  # us to exclude plugins from different environments.
  config.plugins = Dir[ "#{RAILS_ROOT}/vendor/plugins/*" ].map { |p|
    File.basename(p) if File.exist?(File.join(p,"init.rb"))}.compact

  if RAILS_ENV == "test"
    config.load_paths += Dir[ "#{RAILS_ROOT}/vendor/testing_gems/**"].map do |dir|
      File.directory?( lib = "#{dir}/lib" ) ? lib : dir
    end
    config.plugins -= [ :acts_as_solr, :"rails-footnotes" ]
  end

Notice how I also separate out the gems we use for testing — no need to load those in other environments.

But things weren’t all sunny for Joe as the national press began digging into the details of his life. It turns out he owes taxes to the state of Ohio amounting to $1,182.98. He’s not licensed as a plumber and has been working without one.

Not to mention, his name’s not even Joe! (Full name: Samuel Joseph Wurzelbacher.) His name is apparently misspelled on the Lucas County Board of Elections database, which raised questions over whether he may be disqualified to vote in November anyway.

Further, even if he buys the plumbing company as he wants to do, he still wouldn’t earn anywhere near enough money to face a tax hike under the Obama plan. In fact, he’d qualify for a variety of tax cuts.

Hilarious… so much for McCain “going to work for Joe” campaign.

After applying that, you can simply do this:

jrubyc app/ lib/
rm `find app/ lib/ -name '*.rb'`

DHH

Why I love working with family people - (37signals)

From the experience I’ve had working with family people, I’ve found an amazing ability to get stuff done when the objectives are reasonably clear, the work appears to have meaning, and if it can be done within the scope of what should constitute a work week. When there are real constraints on your time, like you have to pickup the kids or make them dinner or put them to bed, it appears to bring a serenity of focus to the specific hours dedicated to work.

This is what companies need, startups or not. They need constraints and especially constraints on how often you can play the hero card to Get This Very Important Project Done. Most projects are just not that important and most things just shouldn’t be done anyway, despite how good of an idea you feel it is in the heat of the moment.

We who choose to surround ourselves with lives even more temporary than our own, live within a fragile circle, easily and often breached.  Unable to accept its awful gaps, we still would live no other way.  We cherish memory as the only certain immortality, never fully understanding the necessary plan….

 – “The Once Again Prince”, Irving Townsend

class Feeds::PeopleController < Feeds::BaseController
  before_filter :person_in_context, :only => [:show, :friends]

  # GET /feeds_peoples/1/friends
  # GET /feeds_peoples/1/friends.xml
  def friends
    @friends = @person.friends

    respond_to do |format|
      format.xml
    end
  end

  # GET /feeds_peoples/1
  # GET /feeds_peoples/1.xml
  def show
    respond_to do |format|
      format.xml
    end
  end
end

Anyway, I suppose I should start being productive with my blog again.