Microsoft’s Arc Mouse is gorgeous. The idea is quite cool as well - a folding portable mouse. Usability of course is the real question.

In contrast to these centralized systems, OpenID allows a system to authenticate it’s users against any other system. I will leave an explanation of the key exchange to other sites here and here who do it much better than me. The one complexity left with the OpenID specification is that you need to remember or record an arbitrary url, which you must enter on the site you want to authenticate with. For users, this is as bad as them having to remember a password, except that the URL need not be kept secret.

The solution to this complexity comes from Clickpass. They have created a one-button graphical widget which lets users authenticate against Facebook, Google and Yahoo or any OpenID provider. The developer just has to implement a simple interface and is good to go. More importantly, the user’s experience improves dramatically since they now only have to login once with their authentication provider instead of over and over again at each site they go while repetively typing in a complex URL. So what’s not to like? Clickpass makes life easier for the developer and the user has a better experience.

These are two visualizations I did of a few days activity on Yahoo Live, Yahoo’s lifecasting/videochat service. On the first one the horizontal axis represents time, and the vertical axis is number of viewers. It is very information dense, so blow it up to full screen and watch a few times; you may see some interesting patterns. A shout out to Phil Pearson for his help with some of the finishing touches.

Visualization of Yahoo Live! (no. 1) from Nikhil B on Vimeo.

This one is a collage showing all the simultaneous channels at once. If you watch carefully you can notice that there are fewer broadcasts at night and more in the morning. You might also catch a glimpse of morning light and evening darkness.

Visualization of Yahoo Live! (no. 2) from Nikhil B on Vimeo

Mouse Pointers by Nikhil Bobb is licensed under a Creative Commons Attribution 3.0 United States License.

update March 28th, 2008
I also just found out that “CA customers can call 858 522 8838 (not tollfree)” at fatwallet. This number was really quick, and went direct to the customer service rep without any menus.

update April 2nd, 2008
If you want dry loop service (DSL without a phone line) you can call the AT&T dry loop department directly at 1-800-942-6037.

What is whereis?

Each instance of whereis lets you share location within a trusted group of people. Whereis does not update location in Fire Eagle, you should do this using other apps (eg. Fire Eagle automatic device updaters, or other sites). This screenshot basically sums it up -

What can I use it for?

• Run it on your intranet to easily share location between your co-workers
• Run it on the internet so friends and family can share location

Who is whereis intended for?

Whereis is intended for developers who have familiarity with Ruby and access to a server.

Why are you releasing it?

It is a simple app (~200 lines of code) built on top of the camping framework. If you understand Ruby and the MVC pattern, it will give you a good idea of how FE works and can be used. I think the code is pretty self explanatory, drop me a line if you have any suggestions.

What else should I do with it?

• run an instance for your group
• use it to experiment with fireeagle
• skin it with CSS to make it look good
• build a service around it
• add a subscriptions table with acls to have a twitter like mode
• anything else

How do I use it?

• download the files
• make sure you and everyone you want to use whereis have fireeagle accounts
• install camping (via gem)
• install dependencies
• get a fireeagle consumer token and secret from the FE website and set up the correct callback URL
• insert the token and secret in getFEClient - whereis.rb
• change the login password in createTheBasics - whereis.rb
• “camping whereis.rb” on the command line

Caveats

• Whereis uses sqlite as it’s database so it’s probably not suitable for large scale deployments.
• I’m using a very early version of the fireeagle gem, before you write anything make sure to look at the newest version.
• This code might be a bit slow in production if the fireeagle servers are heavily loaded. If you want to take initiative and fix the problem this is how you would do it (via Seth Fitzsimmons) - instead of updating the locations on query, update them periodically using a cron job or some other method.

#!ruby
#whereis - a simple fireeagle demo
#IMPORTANT: make sure to use the version of fireeagle.rb included in the tarball
#Nikhil Bobb (nikhilb at yahoo-inc.com)
#26th Feb 08

require 'camping/session'
require 'FireEagle'
require 'JSON'

Camping.goes :Whereis

module Whereis
  include Camping::Session
  table_style = "border-width:1px; border-style:outset"

  def getFEClient(access_token = "", access_token_secret = "")
    client = FireEagle::Client.new \
	  :consumer_key        => "",
	  :consumer_secret     => "",
	  :access_token        => access_token,
          :access_token_secret => access_token_secret
  end

  #gets a user's location from fireEagle and returns a nice
  #string
  def getFELocation(access_token, access_token_secret)
    client = getFEClient(access_token, access_token_secret)
    location_obj = client.user
    #query the JSON object to get the location
    #where best guess = true
    hierarchy = location_obj["user"]["location_hierarchy"]
    current_loc = hierarchy.select {|l| l["best_guess"]}.first
    [current_loc["name"], current_loc["located_at"]]
  end
end

module Whereis::Models

  class User < Base;
    has_one :request_token
    serialize :access_token
  end

  class RequestToken < Base;
    belongs_to :user
    serialize :bin
  end 

  class Login < Base; end

  class CreateTheBasics < V 1.0
    def self.up
      create_table :whereis_logins do |t|
        t.column :username, :string
        t.column :password, :string
      end
      create_table :whereis_users do |t|
        t.column :name, :string
        t.column :access_token, :text
      end
      create_table :whereis_request_tokens do |t|
        t.column :str, :string
        t.column :bin, :text
        t.column :user_id, :integer
      end
      Login.create :username => 'admin', :password => "eagle123"
    end
    def self.down
      drop_table :whereis_users
      drop_table :whereis_request_tokens
      drop_table :whereis_logins
    end
  end
end

module Whereis::Controllers
  class Style < R '/styles.css'
    def get
      @headers["Content-Type"] = "text/css; charset=utf-8"
      @body = %{
        table {
          border-width:1px;
          border-style: dotted;
        }
        td {
          border-width: 1px 1px 1px 1px;
          border-style: solid;
        }
      }
    end
  end
  class Auth < R '/auth'
    def post
      @logged_in_user = Login.find :first, :conditions => ['username = ? AND password = ?', input.username, input.password]
      if @logged_in_user
        @login = 'login success !'
        @state.user_id = @logged_in_user.id
        redirect R(Index)
      else
        @login = 'wrong user name or password'
        render :id
      end

    end
    def get
      render :id
    end
  end

  class Index < R '/'
    def get
      if @state.user_id.blank?
        redirect R(Auth)
        return
      end

      @users = []
      User.find(:all).each do |u|
        t = u.access_token
        if t
          location = getFELocation(t.token, t.secret)
          @users << [u.name, location[0], location[1]]
        end
      end
      render :whereis
    end

    def post
      if @state.user_id.blank?
        redirect R(Auth)
        return
      end

      client = getFEClient
      request_token = client.get_access_token_part1
      rt = RequestToken.create :bin => request_token, :str => request_token.token
      u = User.create :name => input.user, :request_token => rt
      redirect "#{FireEagle::AUTHORIZATION_URL}?oauth_token=#{request_token.token}"
    end
  end

  class Callback < R '/callback'
    def get

      if @state.user_id.blank?
        redirect R(Auth)
        return
      end

      client = getFEClient
      rt = RequestToken.find_by_str(input.oauth_token)
      at = client.get_access_token_part2(rt.bin)
      user = rt.user
      user.access_token = at
      user.save
      rt.destroy
      redirect "/"
    end
  end
end

module Whereis::Views
  def layout
    html do
      head do
        title { "Where is everyone?" }
        link :rel => 'stylesheet', :type => 'text/css',
             :href => '/styles.css', :media => 'screen'
      end
    end
    body { self << yield }
  end

  def id
    p @login
    form :action => R(Auth), :method => 'post' do
      label 'Username', :for => 'username'; br
      input :name => 'username', :type => 'text'; br

      label 'Password', :for => 'password'; br
      input :name => 'password', :type => 'text'; br

      input :type => 'submit', :name => 'login', :value => 'Login'
    end

  end

  def whereis
    form :method => "post" do
      input :type => "text", :name => "user"
      input :type => "submit", :value => "add me"
    end
    table do
      tr do
        td "name"
        td "location"
        td "time"
      end
      tr do
        @users.each do |u|
          u.each{|c| td c}
        end
      end
    end
  end
end

def Whereis.create
  Camping::Models::Session.create_schema
  Whereis::Models.create_schema :assume => (Whereis::Models::User.table_exists? ? 1.0 : 0.0)
end

Remember to return the superclass or Camping will throw a “Read error: #<NoMethodError: undefined method `status’ for nil:NilClass>” because it can’t call back into the returned controller. A modification of the above linked wiki page example illustrates -

Camping.goes :YourApp

module YourSession
  def service(*a)
    @session = YourApp::Session.new
    s = super(*a)
    @session.close
    #return s from above after completing
    s
  end
end

module YourApp
  include YourSession
end

I didn’t see a chart in the the article so I made one with their statistics. Enjoy.