Java The Hutt

Rails realities part 29 - Salesforce and rails integration, the easy way

2009-12-03T16:11:00.001-08:00

In honor of Dreamforce and RubyConf both being in San Francisco at the same time a couple of weeks ago today's post is about making the two of them work together.
If you do ever need to integrate Salesforce.com with your rails app there's really one game in town, (well really two but one depends on the other, you'll see shortly) and while it works great once you get things working I think the documentation around the process could use a little help so today we're going to have a little tutorial and go through the process of integrating Salesforce into an existing rails application.

So first off the assumptions:

You have a rails 2.3.x app (I'm sure this works with older 2.x versions but for my app I'm running 2.3.4 to be exact)

You'd like to integrate with Salesforce but the entirety of your app is not driven by Salesforce.

What are your options? Well there are currently two projects that seem to be the default and have the most momentum for connecting to SF:

rForce - A simple 'low level" API access library to get at your SF data.

ActiveSalesforce - An ActiveRecord extension that allows you to interact with your SF data using model objects. It uses rForce to make the API calls.

rForce is really simple to use and makes the assumption that you are familiar with the SF API. There's a great tutorial here on how to get that up and running:

http://oldfartdeveloper.blogspot.com/2009/09/rforcesalesforce-setup-for-dummies.html

That's the article that got me "unstuck" trying to figure out my way through the world of Salesforce integration. If you'd like to get up and running with rForce have a look at that tutorial. If you're interested in ActiveSalesforce read on....

So if you didn't read old fart's tutorial above and create a SF developer account then you're gonna wanna do that before we get started. The short of it is:

Go to http://developer.force.com/ and sign up

You will receive an email with your username (Your email address is your username) and a temporary password.

Either click on the embedded link in the email to login or visit https://login.salesforce.com/ and login from there with your email and password. (Once logged in you'll want to change your password to something more memorable than the random string that was generated for you)

Once you've logged in you're taken to the home page of your personal CRM sandbox. At the top of the page you'll want to click on the "Setup" link.

Now we have to obtain your security token that's used to login to the API. To do that click on the "Setup" link at the top of the page.

Once on your setup page you should see a section on the left side navigation titled "Personal Setup". In that section there's a node named "My Personal Information". Expand that node. You should see something like this:

Click on the "Reset Security Token" button to have Salesforce send you an email with your security token.

Once that's completed we're ready to dig into some ruby and get our application talking with the API.

Let's get started!

First let's add a configuration entry in environment.rb in our rails app for the activesalesforce gem. I'm using the johnreilly version on github.

    config.gem "johnreilly-activerecord-activesalesforce-adapter", 
             :lib => 'activerecord-activesalesforce-adapter', :source => 'http://gems.github.com'

Once you have that entry in your environment.rb file you can install the gem by running the following rake command from the root of your application
```
sudo rake gems:install
```

OK so let's create our first SF related model, a base class that will be used for all SF model classes. So we generate:

ruby script/generate model Salesforce::SfBase

After that is generated we add some code to connect to SF and end up with something like the following:

class Salesforce::SfBase < ActiveRecord::Base  
  self.abstract_class = true
  # create a connection to Salesforce for the given user
  def self.login(user, pass, token)
    params = {:adapter  => "activesalesforce",
                              :url     => "https://login.salesforce.com/services/Soap/u/16.0",
                              :username => user,
                              :password => pass + token}
    self.establish_connection(params)    
  end
end

Next let's generate an SF class that represents a user.
```
ruby script/generate model Salesforce::User
```
Modify that newly created user class to look as follows:
```
class Salesforce::User < Salesforce::SfBase
end
```

Now we're ready to test our connection to SF and retrieve a user in their system via the API. Let's create a test in the Salesforce::UserTest as follows:
```
class Salesforce::UserTest < ActiveSupport::TestCase
  def test_should_return_sf_user
    user = 'yourSFemail@yourdomain.com'
    password = 'yourSFpassword'
    key = 'your SF security token'
    Salesforce::SfBase.login(user, password, key)
    u = Salesforce::User.first
    assert_not_nil u
  end
end
```
If all went well you should see a successful test run and have a user from the SF system. The code simply logs into SF via the login method defined in our base class. This sets the connection for any ActiveRecord classes that derive from SfBase for the rest of the request. Then we simply use our SF User class the same way we would any ordinary ActiveRecord class.
As a side not you'll probably want to store the SF credential information in a config file somewhere or if your SF support is on a per user basis somewhere in your users or accounts table.

Extra credit: You can also use related objects in the standard ActiveRecord way as well. For example we could change our User class as follows:
```
class Salesforce::User < Salesforce::SfBase
  has_many :contacts, :class_name => "Salesforce::Contact", :foreign_key => 'owner_id'
  has_many :cases, :class_name => 'Salesforce::Case', :foreign_key => 'owner_id'
end
```
Having these relations defined allows us to use relations in the normal rails way:
```
user = Salesforce::User.first
user.contacts
user.cases
```
Of course we'll need to generate a Salesforce::Contact and Salesforce::Case class but you get the idea. ActiveSalesforce will automatically match up any of the built in classes with your properly namespaced salesforce class. The key is that your classes do need to be namespaced at "Salesforce::" as far as I know. Perhaps you can override that behavior but I found it to be exactly what I'd want to do myself.

That should do it. Easy integration of Salesforce as another data source into your existing rails app. I should point out that this is not production tested code so it should be pointed out that things like ensuring the connection to Salesforce isn't causing any leaks should be investigated before deploying to production.

Enjoy!

Rails realities part 28 - Sinatra holdin' up the cache-money

2009-11-10T17:41:00.000-08:00

For those of you looking to integrate the cache-money write through caching within your rails app and you're using Sinatra to create some metals beware.

It all started with this command on the rails console:

>> a = User.find(1)

Which resulted in this error message:


NoMethodError: You have a nil object when you didn't expect it!
The error occurred while evaluating nil.key?
 from /Library/Ruby/Gems/1.8/gems/sinatra-0.9.4/lib/sinatra/base.rb:768:in 'route'
 from /Library/Ruby/Gems/1.8/gems/sinatra-0.9.4/lib/sinatra/base.rb:754:in 'get'
 from (__DELEGATE__):2:in 'send'
 from (__DELEGATE__):2:in 'get'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/transactional.rb:27:in 'send'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/transactional.rb:27:in 'method_missing'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/accessor.rb:22:in 'fetch'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/accessor.rb:31:in 'get'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/query/abstract.rb:65:in 'hit_or_miss'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/query/abstract.rb:18:in 'perform'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/query/abstract.rb:7:in 'perform'
 from /Library/Ruby/Gems/1.8/gems/nkallen-cache-money-0.2.5/lib/cash/finders.rb:24:in 'find_every'

Huh? Uhh, OK... WTF is the code doing in Sinatra? After some investigation I came across this very similar problem from someone using the ruby redis client https://sinatra.lighthouseapp.com/projects/9779/tickets/251-sinatra-collision-with-redis-client. Since that stack trace looked familiar I looked a little more closely. Turns out this bit of documentation is the key:

"The methods available to Sinatra::Base subclasses are exactly as those available via the top-level DSL. Most top-level apps can be converted to Sinatra::Base components with two modifications:

* Your file should require sinatra/base instead of sinatra;
otherwise, all of Sinatra's DSL methods are imported into the main namespace."

Read more here:
http://github.com/sinatra/sinatra/commit/536033334f33c6822acb64e18b6cdb4eee2f85fe#L0R515

Turns out the rails app I was working on which has some metals had included sinatra instead of sinatra/base. Simply changing that require fixed the problem with cache-money. Hopefully this saves someone else that same headache that cost me more time than it should've.

Tivo your code

2009-10-30T17:32:00.001-07:00

Lately I've been working on a project with some other developers and we were having discussions about development methodology choices and the role of testing in software development. I know that this topic has been covered to death but I personally always find it fun and rewarding to come up with new analogies for thinking about software, or anything for that matter, that helps educate and clarify the meaning or impact of a given concept, behavior, or pattern.

So while I'm not going to step back to the question of "What is meaning of life?", I am going to pose a high level question of "What is the process of writing software?" What is it you are actually doing when you're typing away in that text editor?

You're telling a story. A story of a software's journey. You're giving that story a plot line and characters and ideally it's going to go somewhere interesting. Not all software does, and there's a lot of reruns out there. Now you might be creating a really simple children's story like "The Little Iterator That Could" or something more involved like "The Passion of the Load Balancer: Timeouts Edition"

Whatever you're writing, every time you do so you're creating or building on an existing story. Your first "audience" for that story is your computer. Now computers are really patient but at the same time pretty intolerant listeners. They will sit there and listen to your story, no matter how good or bad, whenever you want. Like your mom they have an unending supply of patience and can endure the most boring of stories because, well, they have to. On the other hand just like many moms they're very active listeners and will critique your story until they understand every last detail, and it can get annoying because sometimes you just wish they'd implicitly know what you're trying to tell in your story. You can find yourself saying things like: "No, no, no... it doesn't go to 'find_the_dud', come on you know I meant 'find_the_dude'" So yeah it can be a bit annoying, but they really help keep your story straight for when you're ready to move on to the big time.

Speaking of the big time... it looks like your story was just optioned for a spot in the latest upcoming code repository! Oh joy! You can't wait to share your entire story with the world. You can't wait for the first episode to air with your new audience members, people. Your mom, err computer, loved the story and was able to understand it, surely your code is destined to be the next "Seinfeld" of the software world.

So it's opening night, your new episode is about to air, but then something strange happens. You continue telling your story and your audience is confused. They're not following your plot. They don't understand who the characters are, the roles they play, and generally what's going on and where things are going. Hmm... this is a problem. How is anyone going to love and adore your story if they aren't able to follow what's going on? And yeah, they're all coming into your story after it's begun. It might be episode #3 in your series of stories, or perhaps this is your Treehouse of Terror XX, the 20th installment in an entire series of stories.

So how the heck are you going to get your audience up to speed on your plot and characters so that they can follow your amazing story from here on out? And how are you going to ensure that they can always keep up to date on your series if they can't be there to watch/listen as you're creating this poetic genius?

You do what we all do when there's something we want to watch/follow but don't have time to do so "live", you Tivo it. Ahh yes Tivo. No longer do we don't have to have the show's writers sitting next to us on our couch, or more commonly, a friend explaining to us what happened on last week's episode of "As the Kernel Dumps". We can go get caught up at our leisure by simply watching the old episode on our trusty Tivo, and we'll be up to date with the latest plot when a new episode airs. Heck, we could even stand in for the writers and create our own next episodes of the show if we wanted to or had to in the event of a strike.

Fast forward a bit and now based on your smashing success of your last project you've just landed a role as a writer for a hot new Abobe Flex sitcom involving some charts, data, and other things that are sure to be instant hilarity, I mean what's not funny about charts and data? Hmm, but you still have to crank out new episodes of your other ongoing series. Guess you'll have to find some other writers to bring onboard to help with that. Hmm, luckily you've been Tivoing all your episodes so that this new writer can go back and watch all the old episodes to get up to speed and be able to create meaningful new stories that add to the existing plotline in a meaningful way. Oh and Tivoing these stories allows them to serve as a "sanity check" or "regression check" for any new plot lines this new writer comes up with. It's easy to go back and see if what they're coming up with fits within the historical boundaries of the series and if not fix the story accordingly.

Unfortunately not everyone out there has seen the light with regards to Tivoing their code. Throngs of software stories are out there being spoken into the ether with nary a chance at them truly being understood. Unless you were there from the firing of the opening brace or shortly thereafter you're not likely to understand what the heck is going on without some help from someone else that's been listening to the story or by talking to the authors themselves. The problem is that talking to the authors or even others in attendance doesn't really scale so well and it's kind of annoying to have to do for all parties. You as the story creator become the bottleneck. Imagine if every author out there had to tell their novels in person. We wouldn't be much further along than Shakespeare right now.

Of course if you haven't figured it out by now I'm talking of course about writing tests for your code and some of the advantages of doing so and the drawbacks of not. Without them you're delivering half a script as to what story the software is trying to tell. Tivoing your code is always a great idea, even if you're the only one that's ever going to be "listening" to these software stories. I promise you that in 6 months from now you'll come back to your series and you'll be plenty grateful that you have those old episodes Tivo'd to help you advance that storyline.

The world is waiting to hear your great stories! Now if you'll excuse me I have to go see "what's playing" in my git repository!

Mo simple sortable tables in rails

2009-06-30T19:08:00.001-07:00

A long time ago I wrote a blog posting on a plugin I created that would allow you to create a sortable table for your rails models with minimal work. Well, 2.5 years later I'm taking the time to write yet another blog post on a revamped version of that plugin that does more with less and is about 10x easier to set up and use. If you refer back to my old posting you'll see that I set out to create a plugin that would allow you to create a non-ajax sortable and paginated table. It certainly worked but involved too much configuration and understanding by you the developer in order to use it. The goal here is the same and the motivation is largely to make it braindead easy to get a table up and running without having to know much of anything. I use this plugin in my apps in user facing pages as well as the starting point for all of my admin pages, completely replacing the ever fragile ActiveScaffold. (Sorry you guys, it totally rocks when it works but it just kept breaking too much for me and I didn't need all the bells and whistles) Over the past couple of years I've completely revamped how this plugin works so let's a have a look at "sortable reloaded" OK let's get started:

First You either create or use an existing a rails app (2.2.2 is the version I'm using still, not positive but this should work with 2.3.x or any rails 2.x apps without a problem).

Next we need to install the will_paginate gem. Assuming you're familiar with specifying gems for your app in your environment.rb file here's my entry for will_paginate:

  config.gem 'mislav-will_paginate',
            :lib => 'will_paginate',
            :source => 'http://gems.github.com',
            :version => '~> 2.3.6'

Now that we've got the pagination gem in place it's time to install the plugin itself. We can do that with:
```
ruby script/plugin install git://github.com/kovacs/sortable.git
```

Next up I'm going to assume that you have a model for whose objects you'd like to create a paginated, sortable table. You're going to need a model as well as a controller with an entry in your routes.rb file. For example:
in user.rb
```
class User < ActiveRecord::Base
end
```
in users_controller.rb
```
class UsersController < ApplicationController 
end
```
in routes.rb
```
map.resources :users
```

Assuming you have that set up configured the simplest possible way to use sortable to create a sortable, paginated, searchable table of your objects is like this:
```
class UsersController < ApplicationController
 sortable_table User
end
```
After you add that snippet to your controller go and hit: http://localhost:3000/users and watch the magic happen. Pretty cool for a one line declaration. The magic happening behind the scenes is that the declaration "sortable_table User" is generating an 'index' action in your UsersController and is using a default index.erb template file for the view of that action. Here's a look at that code: In sortable.rb (vendor/plugins/sortable/lib/sortable.rb)
```
def index
 get_sorted_objects(params) 
 render :template => 'sortable/index'
end
```
in the view for index (vendor/plugins/sortable/views/sortable/index.erb)
```
<%= sortable_table %>
```
Everything is customizable but this is just demonstrating the simplest table you can create with the plugin.

By default you'll notice that the plugin uses all the attributes on your model when it builds the table. I can hear it already: "Dude, I don't want it to show XYZ attribute on my model" to which I'd say "Pfft... way ahead of you dawg". Specify what columns you want displayed in the table by default like this:
```
class UsersController < ApplicationController
 sortable_table User, :display_columns => ['id', 'name', 'email', 'created_at', 'timezone', 'state'] 
end
```
Of course this example assumes that you have the attributes on your User model. Replace with your attributes as needed. What you'll end up seeing is this:

Of course there's a ton of flexibility in the plugin that allows you to place a sortable table on any page you'd like as opposed to having it only show up on an index page that lists all your objects. You can also show a table that sorts, searches, and paginates over more than one object type. So if you wanted to show all your users and one or more attributes from a related object or objects you can easily do that with a few attributes in your sortable_table declaration. You can also easily customize the L&F of the table and turn off searching if you don't want/need it. See more details in sortable.rb and sortable_helper.rb where it outlines all of the options. If there's something that it doesn't do feel free to fork the code and add it yourself and send me a pull request.

The basic mechanics on how to make use of the plugin in your app is that you want to call:
```
get_sorted_objects(params, sortable_options)
```
This call will populate a few variables for you to use:
```
@objects  # The collection of objects that you can display in a table
@headings  # The collection of table header objects that are used to build the header and links.
```
Then in your view you'll just call:
```
<%= sortable_table %>
```
Wherever you'd like that sortable table to appear. It's really that simple. You can easily override the template that's being used to build the table with a parameter to the helper call. For example:
```
<%= sortable_table :partial => 'loans/loan_table' %>
```
Have a look at vendor/plugins/sortable/views/sortable/_table.html.erb for an idea of how to build a table for your objects if you want to have more flexibility than the standard template gives you.

If you find this plugin useful and especially if you use it on a site that's a project that you're intending to make money with please donate something as it did require time and effort to clean up, document, and package this plugin for general consumption. Your donation will go towards improving this plugin and inspire me to release other plugins that I know would be generally useful to other rails developers. You might want to note that unlike most open sores projects this plugin comes with example code, documented code, tests, and has 100% test coverage as well. It's also being used in production on a real site that charges real money for its products so it's not just someone's hobby project that's going to be abandoned. Think about that while you're busting out your credit card and making a suggested donation of $20 (or whatever you'd like) here:

If you aren't going to donate or are using it for a non-profit project I'd really appreciate a link to my company site: http://www.cablecarsoftware.com. Thanks everyone and hope you enjoy it and find it useful! Oh and finally, get the code here.

Production deployments from the friendly skies

2009-05-19T12:45:00.001-07:00

This past weekend I flew to NY to attend my youngest sister's graduation from Hofstra. Once again I flew Virgin America like I always try to when I fly to NY. Power outlets at each seat mean that I can either work or play on my mac the entire time turning a 5 hour flight into nothing more than just another day at the office or a coffee shop :-) The only thing that's ever been missing of course is internet access. Well for $12.95 on Virgin you can now get high speed internet access. I forgot to test the speed but for browsing it was fine. I did notice lag when streaming a video but that's to be expected. Simply having it at all and having it usable is a huge win.

So there I was working on some fixes for LendingKarma and was ready to deploy. Then the realization that I was about to embark upon a production deployment from 30K feet hit me. What if there's a problem and the wifi goes out? I can't rollback thus leaving the site in whatever state caused by my deployment gone wrong. After posing the question to some fellow engineers via a twitter/facebook status update which of course resulted in "do it man!", because they're not the ones that have to deal with the fallout of a failure :-), I pushed ahead with my deployment. Wouldn't you know it, there was a problem and I immediately rolled back. Phew! Murphy's Law strikes again! I fixed the problem quickly and then redeployed successfully. Wow... I just did a production deployment from an airplane. Pretty damn cool :-)

And.... we're back

2009-05-04T15:31:00.001-07:00

Phew! That was a long commercial break. I always said I wanted to take a year off in my 30s. I guess a year off from blogging is about the closest thing I've come to that year off :-) Quite a bit's happened in the year since I last wrote. I helped a client launch, http://www.newrelic.com, went on a vacation to Europe (Budapest, Prague, and Berlin) and most recently launched a new venture of mine, http://www.lendingkarma.com.

For the folks that still have me in their feed reader after nearly a year without a peep, I say thanks for being so lazy about removing me :-) Considering that the majority of folks that do read this blog are interested in ruby and rails development I do have a few things that I can talk about that might be of interest.

So as you could probably guess LendingKarma is built on rails, but it's also built using a base app that is comprised of numerous plugins that make it really easy to get a base application up and running. Some of the plugins are:

Comatose - A lightweight CMS plugin for easy creation of static content. It also has an easy way to drop in dynamic content as well.

Active Merchant - The most commonly used plugin for adding e-commerce support to your rails applications. This version of ActiveMerchant includes a patch to support recurring payments through Paypal Web Payments Pro.

In place editing - An updated in_place_editor plugin that supports RESTful routes and includes support for inplace editing of select boxes. I'll post more about how this plugin works later.

Restful Authentication - At the time I started creating this application none of the new sexy plugin authentication mechanisms were ready or there yet so I stuck with Restful Auth for now. This probably deserves a second look now that there are some plugin based solutions out there.

Suspenders - Suspenders is the base app from the guys over at Thoughtbot. The guys who also created Factory Girl and Shoulda which I use as well in my projects now, though not in this base app's code base.

Uberkit - A plugin to help ease the pain of creating forms and fields. I enhanced this plugin to make use of another plugin I use to make it easy to create tooltips.

Bundle Fu - An asset packaging plugin whose only requirement is a closure around the assets you'd like to bundle into a single .css or .js file. Really nice!

I also have a few plugins I created that aren't on Github at the moment but are part of my base app:

OrderSystem - Order system is a plugin for e-commerce that's focused on selling digital products. It makes it brain dead easy to add any of the ActiveMerchant gateways as well as making it trivial to setup and test paypal standard or web payments pro as your gateway. It even has support for subscriptions using web payments pro. Subscription support for non-Paypal web payments pro is coming but for LendingKarma we are using Paypal so that was done first. I'm thinking of releasing this plugin in the same fashion as the RailsKit software. I looked at that software and wasn't happy with the product so I ended up creating my own which I think is an easier fit for integrating into an existing rails app. Anyway, more to come on that. Let me know if you'd like more information on that plugin.

Tooltip - A plugin that makes it easy to declaratively add tooltips to your site.

Sortable - A plugin that makes it easy to create a sortable, paginated table over your objects that is also very flexible.

ListEditor - List Editor allows you to declaratively create CRUD lists that use a modal dialog and ajax for the CRUD operations.

More on these plugins in future posts.

The end result of this work is a rails app that out of the box comes with user reg/auth, e-commerce support, and a CMS to manage the site's static pages. A great first step to many projects out there. I'm also just thinking about bundling the entire app itself for release as a base starter app.

Stay tuned as I plan on posting more than once this year :-)

JavaOne 2008 - Scala

2008-05-08T17:03:00.001-07:00

Between working, waiting, wishing for my Wii to arrive (yay!) I've finally managed to make it to my first talk at JavaOne. Because my good friend David Pollak has been bugging me to check out lift (written in Scala) I decided to go and check out the guy behind the guy behind the guy (Martin Odersky) The creator of Scala. (Enough links in there for ya?)

What's scala? Well it's a fully JVM compliant language that integrates functional and object-oriented language features. Boy that sounds to me like it's gonna get complicated or bloated real fast. From Martin's presentation today:

Is Scala a kitchen sink language?
Roughly comparable to java, smaller than C++/#

Two design principles:

focus on abstraction and composition so that users can implement their own specialized features

have the same constructs work for small as well as large programs

Scala adds:

pure object system - everything is an object unlike Java and Ruby

operator overloading

closures - Rubyists take note

mixins - Rubyists take note

existential types

abstract types

pattern matching

Removes:

statics - it adds its own static of sorts with a singleton object (called a companion object) where you can define methods


class Sample(x: Int, val p: Int) {
  def instMeth(y: Int) = x + y
}
object Sample { <-- companion object... contains statics
  def staticMeth(x: Int, y: Int) = x * y
}

primitives

break,continue

special treatment of interfaces

wildcards

raw types

enums

There's a good beginner intro here.

It seems like the biggest thing that most people object to (myself included the first time I saw it) is the syntax of the language. Martin referred to it at today's talk:

x: Int instead of int x

why?

works better with type inference
works better for large type expressions
val x: HashMap[String, (String, List[Char])] = ...

instead of

public final HashMap>> x = ...

OK so this is all fine and good but what about the thing all Java devs care about... tool support. Well it turns out that there's some stuff in the works and out there for Scala:

scalac

shell: scala

testing:

sunit, scalacheck, specs

eclipse plugin v2 in beta

in the works:

intellij plugin

netbeans plugin (caoyuan)

OK so that's my nickel tour (hey you get what you pay for) of Scala. For those of you around SF after Friday checkout Scala lift off on Saturday morning at 9AM. Unfortunately I can't make it myself due to a trip I had planned but if I weren't out of town I'd definitely go check it out.

So long TextMate?... Hello NetBeans? Really? Yeah, really.

2008-04-26T12:45:00.001-07:00

I'll admit it, I'm one of many folks that used to treat NetBeans as a whipping boy. Questioning why Sun would bother dumping money into the horse that so obviously lost the race to Eclipse and IntelliJ to win the hearts and minds of Java developers around the world.

Over the years NetBeans has flirted with me by introducing various features that sounded great on the surface and taken by itself usually was a pretty good feature. Like the new debugger and profiler that was introduced a couple years back. Or the first to implement JEE 5.0 tools, or Matisse - the Swing GUI toolkit. The list goes on and on.

But each and every time I'd download NetBeans and try it out no matter how good that one feature might've been it was surrounded by basic editing and development features that were laughable. There's no way anyone could use this tool on a daily basis and be productive.

Well over the past year and a half or so the NetBeans teams has been cranking away on support for ruby and rails development. Every once in awhile I'd take a look and see what kind of progress they'd made and always conclude that it wasn't there yet. Well, the other day I had need to hunt for a good javascript editor that would do code completion for me and so knowing NetBeans has support for javascript editing and code completion I decided to see how far the ruby and rails support in NetBeans has come as well.

I grabbed a nightly build of 6.1 and installed it. Right away I noticed that they made a special build for ruby where they've stripped it down to where it is focused on supporting ruby and rails apps. They added a theme that looks similar to textmate to make me feel more at home. Many keybindings are similar to Textmate (though not all but they are easily configurable). You can easily debug your rails apps with the graphical debugger. The generators work. Code completion works okay at times. API docs are easily visible inline during code completion. Navigating around the project is now easy where before that was the single biggest outage that kept me from even considering it. You can easily jump to type definitions. Simple refactoring is supported. Basically it's welcome to 2001 for anyone in the ruby world that came from Java. Regardless it's great to have some of these high leverage tools while working in the ruby world.

I haven't completely ditched TextMate. If I know I have to do some quick edits and know that I'm not going to have to do any heavy duty debugging or dev work and don't have the project open in NetBeans I'll still use it.

Anyway, great job team NetBeans! Thanks so much for the great dev tool.

Dave Chappelle was the man at Punchline tonight!

2008-03-20T04:46:00.001-07:00

Wow! I was lucky enough to score a pair of tickets to Wednesday night's surprise performance at the Punchline here in SF and man what an amazing show! The show was supposed to start at 11 but nothing happened until 11:30. That's when Dave came on. For the next 4.5 hours, yeah that's right, 4.5 hours, he delighted the crowd with topics ranging from Eddie Veder's singing voice (a recurring theme all night), to a stripper in the audience, to a guy that was in Afghanistan who stumbled upon a cave with a bunch of hash, cocaine, and steroids and managed to get himself kicked out of the military for smoking too much. Hell, he even managed a Police Academy reference, mentioning the Blue Oyster when someone suggested an eatery in the Castro when asking for a late night restaurant after the show.

Dude opens and closes his show and is on stage for 4.5 hours straight! No breaks, nothing. Two packs of cigarettes and about 6 coffees later it ended and my throat is sore from laughing.

What a fantastic night! Thanks Dave for a memorable time. Hope to have the privilege of seeing you again sometime. Hope you enjoyed that Grubsteak or Mel's. Come back to SF soon.

Opensocial observations (Part 1 - Data types available in MySpace v0.6 and Orkut v0.7)

2008-02-20T01:02:00.001-08:00

For anyone brave enough to dive into the world of opensocial you'll quickly find that there's a lot of stuff around to read but not much in the way of examples and demos showing the lay of the land.

I won't go into great detail here about how opensocial apps are architected but what I will say is that you have to define javascript in any opensocial app just to get the thing off the ground. On some containers you need to do an XML situp as well. I've only experimented on Orkut and MySpace thus far with varying degrees of success and confusion.

Basically if you're using v0.7 and on Orkut you create an XML file that contains your app definition. Here's an example:

<?xml version="1.0" encoding="UTF-8"?>
<Module>
  <ModulePrefs title="Data type inspector">
    <Require feature="opensocial-0.7"/>
  </ModulePrefs>
  <Content type="html">
    <![CDATA[
      <script src="http://www.pitchwire.com/javascripts/openSocialTestV0.7.js"></script>
      <script>
        gadgets.util.registerOnLoadHandler(init);
      </script>
      <div id='snoop'></div>
    ]]>
  </Content>
</Module>

You need to put this XML file somewhere that Orkut can get to it and load it. For example: http://www.pitchwire.com/opensocialTestV0.7.xml In fact you can simply add an app in Orkut and when it asks for the URL simply point to this XML file I have hosted if you don't wish to create these files and host them yourself.

You can see that in the XML file an external javascript file is referenced. That file contains the code I whipped up today that tells you what data types are available in a given container.

This code works for Orkut and any v0.7 opensocial containers:

function inspectEnv() {
  var env = opensocial.getEnvironment();
  html = new Array();
  camera1 = 'b3c7f1';
  camera2 = 'fff';
  last_camera = camera1;
  
  html.push('<br/>Domain: ' + env.getDomain() );
  html.push('<table style="border: 1px solid black;">');
  html.push('<tr style="background-color: c8eaa9;"><td>Type</td><td>Field</td><td>Supported?</td></tr>');
  
  var fieldType = opensocial.Environment.ObjectType.ACTIVITY;
  var fields = [opensocial.Activity.Field.TITLE, 
                opensocial.Activity.Field.TITLE_ID, 
                opensocial.Activity.Field.BODY, 
                opensocial.Activity.Field.BODY_ID, 
                opensocial.Activity.Field.EXTERNAL_ID, 
                opensocial.Activity.Field.ID, 
                opensocial.Activity.Field.MEDIA_ITEMS, 
                opensocial.Activity.Field.POSTED_TIME, 
                opensocial.Activity.Field.PRIORITY, 
                opensocial.Activity.Field.STREAM_FAVICON_URL,
                opensocial.Activity.Field.STREAM_TITLE,
                opensocial.Activity.Field.STREAM_SOURCE_URL,  
                opensocial.Activity.Field.STREAM_URL, 
                opensocial.Activity.Field.TEMPLATE_PARAMS, 
                opensocial.Activity.Field.URL, 
                opensocial.Activity.Field.USER_ID, 
                opensocial.Activity.Field.APP_ID];
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.ACTIVITY_MEDIA_ITEM;
  fields = [opensocial.Activity.MediaItem.Field.MIME_TYPE,
            opensocial.Activity.MediaItem.Field.TYPE,
            opensocial.Activity.MediaItem.Field.URL];
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.ADDRESS;
  fields = [opensocial.Address.Field.COUNTRY,
            opensocial.Address.Field.EXTENDED_ADDRESS,
            opensocial.Address.Field.LATITUDE,
            opensocial.Address.Field.LOCALITY,
            opensocial.Address.Field.LONGITUDE,
            opensocial.Address.Field.PO_BOX,
            opensocial.Address.Field.POSTAL_CODE,
            opensocial.Address.Field.REGION,
            opensocial.Address.Field.STREET_ADDRESS,
            opensocial.Address.Field.TYPE,
            opensocial.Address.Field.UNSTRUCTURED_ADDRESS];          
  inspectType(env, fieldType, fields);
  
  fieldType = opensocial.Environment.ObjectType.BODY_TYPE;
  fields = [opensocial.BodyType.Field.BUILD,
            opensocial.BodyType.Field.EYE_COLOR,
            opensocial.BodyType.Field.HAIR_COLOR,
            opensocial.BodyType.Field.HEIGHT,
            opensocial.BodyType.Field.WEIGHT];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.EMAIL;
  fields = [opensocial.Email.Field.ADDRESS,
            opensocial.Email.Field.TYPE];          
  inspectType(env, fieldType, fields);
  
  fieldType = opensocial.Environment.ObjectType.FILTER_TYPE;
  fields = [opensocial.DataRequest.FilterType.ALL,
            opensocial.DataRequest.FilterType.HAS_APP];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.MESSAGE;
  fields = [opensocial.Message.Field.BODY,
            opensocial.Message.Field.TITLE,
            opensocial.Message.Field.TYPE];          
  inspectType(env, fieldType, fields);
  
  fieldType = opensocial.Environment.ObjectType.MESSAGE_TYPE;
  fields = [opensocial.Message.Type.EMAIL,
            opensocial.Message.Type.NOTIFICATION,
            opensocial.Message.Type.PRIVATE_MESSAGE,
            opensocial.Message.Type.PUBLIC_MESSAGE];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.NAME;
  fields = [opensocial.Name.Field.ADDITIONAL_NAME,
            opensocial.Name.Field.FAMILY_NAME,
            opensocial.Name.Field.GIVEN_NAME,
            opensocial.Name.Field.HONORIFIC_PREFIX,
            opensocial.Name.Field.HONORIFIC_SUFFIX,
            opensocial.Name.Field.UNSTRUCTURED];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.ORGANIZATION;
  fields = [opensocial.Organization.Field.ADDRESS,
            opensocial.Organization.Field.DESCRIPTION,
            opensocial.Organization.Field.END_DATE,
            opensocial.Organization.Field.FIELD,
            opensocial.Organization.Field.NAME,
            opensocial.Organization.Field.SALARY,
            opensocial.Organization.Field.START_DATE,
            opensocial.Organization.Field.SUB_FIELD,
            opensocial.Organization.Field.TITLE,
            opensocial.Organization.Field.WEBPAGE];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.PERSON;
  fields = [opensocial.Person.Field.ABOUT_ME,
            opensocial.Person.Field.ACTIVITIES,
            opensocial.Person.Field.ADDRESSES,
            opensocial.Person.Field.AGE,
            opensocial.Person.Field.BODY_TYPE,
            opensocial.Person.Field.BOOKS,
            opensocial.Person.Field.CARS,
            opensocial.Person.Field.CHILDREN,
            opensocial.Person.Field.CURRENT_LOCATION,
            opensocial.Person.Field.DATE_OF_BIRTH,          
            opensocial.Person.Field.DRINKER,
            opensocial.Person.Field.EMAILS,
            opensocial.Person.Field.ETHNICITY,
            opensocial.Person.Field.FASHION,
            opensocial.Person.Field.FOOD,
            opensocial.Person.Field.GENDER,
            opensocial.Person.Field.HAPPIEST_WHEN,
            opensocial.Person.Field.HEROES,
            opensocial.Person.Field.ID,
            opensocial.Person.Field.INTERESTS,
            opensocial.Person.Field.JOB_INTERESTS,
            opensocial.Person.Field.JOBS,
            opensocial.Person.Field.LANGUAGES_SPOKEN,
            opensocial.Person.Field.LIVING_ARRANGEMENT,
            opensocial.Person.Field.LOOKING_FOR,
            opensocial.Person.Field.MOVIES,
            opensocial.Person.Field.MUSIC,
            opensocial.Person.Field.NAME,
            opensocial.Person.Field.NICKNAME,
            opensocial.Person.Field.PETS,
            opensocial.Person.Field.PHONE_NUMBERS,
            opensocial.Person.Field.POLITICAL_VIEWS,
            opensocial.Person.Field.PROFILE_SONG,
            opensocial.Person.Field.PROFILE_URL,
            opensocial.Person.Field.PROFILE_VIDEO,
            opensocial.Person.Field.QUOTES,
            opensocial.Person.Field.RELATIONSHIP_STATUS,
            opensocial.Person.Field.RELIGION,
            opensocial.Person.Field.ROMANCE,
            opensocial.Person.Field.SCARED_OF,
            opensocial.Person.Field.SCHOOLS,
            opensocial.Person.Field.SEXUAL_ORIENTATION,
            opensocial.Person.Field.SMOKER,
            opensocial.Person.Field.SPORTS,
            opensocial.Person.Field.STATUS,
            opensocial.Person.Field.TAGS,
            opensocial.Person.Field.THUMBNAIL_URL,
            opensocial.Person.Field.TIME_ZONE,
            opensocial.Person.Field.TURN_OFFS,
            opensocial.Person.Field.TURN_ONS,
            opensocial.Person.Field.TV_SHOWS,
            opensocial.Person.Field.URLS];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.PHONE;
  fields = [opensocial.Phone.Field.NUMBER,
            opensocial.Phone.Field.TYPE];          
  inspectType(env, fieldType, fields);
  
  fieldType = opensocial.Environment.ObjectType.SORT_ORDER;
  fields = [opensocial.DataRequest.SortOrder.NAME,
            opensocial.DataRequest.SortOrder.TOP_FRIENDS];          
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.URL;
  fields = [opensocial.Url.Field.ADDRESS,
            opensocial.Url.Field.LINK_TEXT,
            opensocial.Url.Field.TYPE];          
  inspectType(env, fieldType, fields);
  html.push('</table>');
  document.getElementById('snoop').innerHTML = html.join('');
}

function inspectType(env, fieldType, fields) {
  for(j = 0; j < fields.length; j++) {
    supports = env.supportsField(fieldType, fields[j]);
    display = supports ? 'style="font-weight: bold;"' : ''
    html.push('<tr style="background-color: ' + last_camera + '"><td>' + fieldType + '</td><td>' + fields[j] + '</td><td ' + display + '>' + supports + '</td></tr>');     
    last_camera = last_camera == camera1 ? camera2 : camera1
  }
}

function init() {
  inspectEnv();
}

Not so bad once you get your bearings and understand how things work. I will say that it hasn't been the smoothest development environment in the world but compared to MySpace it's a dream. Speaking of MySpace the current situation there is so awful at the moment it's almost as if they don't want people to write apps for their platform.

The current state of affairs there is that they expect you to paste your HTML and javascript code into a textarea on their developer site. They too suffer from some of the same confusion that Orkut does where it's not clear what the oder of operations are and where key links are missing when trying to navigate around the sandbox. Also on MySpace your app has a MySpace profile as if it's another user. It can have friends, etc. Yeah.. that seems about right for MySpace :-)

Because I'm apparently a glutton for punishment I decided to try and run my container introspection code on MySpace. Turns out V0.6 is much smaller in terms of data types than V0.7 with only 3 defined.

Here's the code that you can paste into your canvas textarea once you've created an app on MySpace:

<div id='snoop' style='height: 500px; overflow: scroll;'></div>
<script type="text/javascript" language="javascript">
function init() {
  inspectEnv();
}

function inspectEnv() {
  var env = opensocial.getEnvironment();
  html = new Array();
  camera1 = 'b3c7f1';
  camera2 = 'fff';
  last_camera = camera1;
  
  html.push('<br/>Domain: ' + env.getDomain() );
  html.push('<table style="border: 1px solid black;">');
  html.push('<tr style="background-color: c8eaa9;"><td>Type</td><td>Field</td><td>Supported?</td></tr>');

  var fieldType = opensocial.Environment.ObjectType.ACTIVITY;
  var fields = [opensocial.Activity.Field.TITLE, 
                opensocial.Activity.Field.TITLE_ID, 
                opensocial.Activity.Field.BODY, 
                opensocial.Activity.Field.BODY_ID, 
                opensocial.Activity.Field.EXTERNAL_ID, 
                opensocial.Activity.Field.ID, 
                opensocial.Activity.Field.MEDIA_ITEMS, 
                opensocial.Activity.Field.POSTED_TIME, 
                opensocial.Activity.Field.PRIORITY, 
                opensocial.Activity.Field.STREAM_FAVICON_URL,
                opensocial.Activity.Field.STREAM_TITLE,
                opensocial.Activity.Field.STREAM_SOURCE_URL,  
                opensocial.Activity.Field.STREAM_URL, 
                opensocial.Activity.Field.TEMPLATE_PARAMS, 
                opensocial.Activity.Field.URL, 
                opensocial.Activity.Field.USER_ID, 
                opensocial.Activity.Field.APP_ID];
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.ACTIVITY_MEDIA_ITEM;
  fields = [opensocial.Activity.MediaItem.Field.MIME_TYPE,
            opensocial.Activity.MediaItem.Field.TYPE,
            opensocial.Activity.MediaItem.Field.URL];
  inspectType(env, fieldType, fields);

  fieldType = opensocial.Environment.ObjectType.PERSON;
  fields = [opensocial.Person.Field.ABOUT_ME,
            opensocial.Person.Field.ACTIVITIES,
            opensocial.Person.Field.ADDRESSES,
            opensocial.Person.Field.AGE,
            opensocial.Person.Field.BODY_TYPE,
            opensocial.Person.Field.BOOKS,
            opensocial.Person.Field.CARS,
            opensocial.Person.Field.CHILDREN,
            opensocial.Person.Field.CURRENT_LOCATION,
            opensocial.Person.Field.DATE_OF_BIRTH,          
            opensocial.Person.Field.DRINKER,
            opensocial.Person.Field.EMAILS,
            opensocial.Person.Field.ETHNICITY,
            opensocial.Person.Field.FASHION,
            opensocial.Person.Field.FOOD,
            opensocial.Person.Field.GENDER,
            opensocial.Person.Field.HAPPIEST_WHEN,
            opensocial.Person.Field.HEROES,
            opensocial.Person.Field.ID,
            opensocial.Person.Field.INTERESTS,
            opensocial.Person.Field.JOB_INTERESTS,
            opensocial.Person.Field.JOBS,
            opensocial.Person.Field.LANGUAGES_SPOKEN,
            opensocial.Person.Field.LIVING_ARRANGEMENT,
            opensocial.Person.Field.LOOKING_FOR,
            opensocial.Person.Field.MOVIES,
            opensocial.Person.Field.MUSIC,
            opensocial.Person.Field.NAME,
            opensocial.Person.Field.NICKNAME,
            opensocial.Person.Field.PETS,
            opensocial.Person.Field.PHONE_NUMBERS,
            opensocial.Person.Field.POLITICAL_VIEWS,
            opensocial.Person.Field.PROFILE_SONG,
            opensocial.Person.Field.PROFILE_URL,
            opensocial.Person.Field.PROFILE_VIDEO,
            opensocial.Person.Field.QUOTES,
            opensocial.Person.Field.RELATIONSHIP_STATUS,
            opensocial.Person.Field.RELIGION,
            opensocial.Person.Field.ROMANCE,
            opensocial.Person.Field.SCARED_OF,
            opensocial.Person.Field.SCHOOLS,
            opensocial.Person.Field.SEXUAL_ORIENTATION,
            opensocial.Person.Field.SMOKER,
            opensocial.Person.Field.SPORTS,
            opensocial.Person.Field.STATUS,
            opensocial.Person.Field.TAGS,
            opensocial.Person.Field.THUMBNAIL_URL,
            opensocial.Person.Field.TIME_ZONE,
            opensocial.Person.Field.TURN_OFFS,
            opensocial.Person.Field.TURN_ONS,
            opensocial.Person.Field.TV_SHOWS,
            opensocial.Person.Field.URLS];          
  inspectType(env, fieldType, fields);
  html.push('>/table>');
  document.getElementById('snoop').innerHTML = html.join('');
}

function inspectType(env, fieldType, fields) {
  for(j = 0; j < fields.length; j++) {
    supports = env.supportsField(fieldType, fields[j]);
    display = supports ? 'style="font-weight: bold;"' : ''
    html.push('>tr style="background-color: ' + last_camera + '">>td>' + fieldType + '>/td>>td>' + fields[j] + '>/td>>td ' + display + '>' + supports + '>/td>>/tr>');     
    last_camera = last_camera == camera1 ? camera2 : camera1
  }
}
init();
</script>

Mind you this only shows you the supported datatypes for what's in the opensocial V0.6 spec. MySpace has a few extension of their own that are available for you to use. I won't cover that here, you can go check out their API docs for that. The word is that they'll be upgrading to V0.7 soon. I sure hope so but I also wish that Orkut would implement the full spec too. You'll see how much is still missing when you install the inspector app.

That's it for now. I'm sure I'll have lots more I could post about on this topic as well as Facebook development.

Enjoy!

Rails realities part 27 (Facebook and Bebo sittin in an app)

2008-01-31T23:22:00.001-08:00

Long time no post. Way too long. I'm not a big fan of too much noise so I try to post when I have something that I think is important to share.

Anyway, today I've got something to share that all you web2.0-facebook-bebo-social-networking-rails-app-building monkeys have been clamoring for but so far have only had a half baked solution to.... Running your Facebook apps on Bebo using RFacebook.

"Wait a minute, you CAN do that right now dude, catch up!" Ahh yes my little ruby fanboy there IS a solution out there right now, the RFacebook on Bebo plugin, BUT that only allows you to run the same app on EITHER Facebook or Bebo. That means you need to setup another VHost and another cluster of mongrels which you may not want to do (I don't).

"Dude, you're still behind man, that wizard Chad Fowler done started his own Facebook integration project called Facebooker." Yeah I know about that thing too and while it is said RFacebook is not long for this world, right now I've got a "legacy" (hehe) rails facebook app and at the moment upgrading to Facebooker isn't as attractive of an option for a live app vs. modifying the existing plugin/gem that's being used.

I've done the dirty work of hacking through RFacebook 0.9.8 and performing the necessary surgery to make RFacebook work on any network that's compatible with the Facebook API. In my case I've added support for Bebo. (The only other "facebook compatible" network I know of)

How about some code?
In the RFacebook GEM in facebook_session.rb...

module RFacebook
  # TODO: better handling of session expiration
  # TODO: support Bebo's API
  HOST_CONSTANTS = { 'facebook' => { :api_version               => "1.0",
                                     :api_host                  => "api.facebook.com",
                                     :api_path_rest             => "/restserver.php",
                                     :www_host                  => "www.facebook.com",
                                     :www_path_login            => "/login.php",
                                     :www_path_add              => "/add.php",
                                     :www_path_install          => "/install.php"},                                     
                     'bebo'     => { :api_version               => "1.0",
                                     :api_host                  => "apps.bebo.com",
                                     :api_path_rest             => "/restserver.php",
                                     :www_host                  => "bebo.com",
                                     :www_path_login            => "/SignIn.jsp",
                                     :www_path_add              => "/add.php",
                                     :www_path_install          => "/c/apps/add"}}

If there were another network to come along all you'd need to do is add a couple of constants in the RFacebook GEM for a new network and modify the config file for your new network. Now I don't know of any other "Facebook compatible" social networks out there besides Bebo at the moment but here's where you'd add their information if there were.

Now there are two burdens on you the user:

The plugin determines what network requests are coming from by checking for a subdomain (i.e. http://bebo.mkovacs.com, http://facebook.mkovacs.com). Therefore you have to tell Facebook and Bebo your callback address is one that begins with the subdomain you're on.
There is a slight change in the facebook.yml config file. Example:

development:
  facebook:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/
    tunnel:
      username: user
      host: pitchwire.com
      port: 1099
      local_port: 3000
  bebo:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/
test:
  facebook:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/
  bebo:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/
production:
  facebook:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/
  bebo:
    key: (key)
    secret: (secret)
    canvas_path: /pitchwire/
    callback_path: /facebook/

So as you can see it's pretty much the same except that for each environment there's a facebook: and a bebo: setting.

"OK great, gimme, gimme, gimme!!" Hmmm... well I've contacted the RFacebook project owner to provide him with the changes so he can integrate them and probably do a point release, but in this instant-gratification-web2.0-gotta-have-it-now-gimme-so-I-can-get-dugg world I'll put the files up on my rinky dink shared hosting site until there's an update to the codebase and a release.

Now for the disclaimer. This comes with the 'WTFPL' license and DIY support :-)

Update: I've checked the modified rfacebook code into the rfacebook project in a branch. For more information and to pickup the code go here: http://rfacebook.rubyforge.org/svn/branches/rfacebo/

Simply:

Replace your installed RFacebook-0.9.8 GEM (or 0.9.7) with the contents of the GEM zip.
Replace your installed rfacebook plugin (If you have 0.9.7 you can delete rfacebook_on_rails in your plugin directory) in your app with the zipped up plugin.
Modify your facebook.yml file to match the format above and include your settings for Facebook and Bebo in whatever environment you choose.

(For you folks using the RFacebook on Bebo plugin you can go ahead and remove that)

After that you should be able to hit your application from either Bebo or Facebook without having to setup different mongrel instances. Let me know if I've missed something and I'll update this post or the zips. Or join the discussions on the google group. (I'd say to use the groups on the RFacebook site but the app is currently broken).

Enjoy!

MicroPlace

2007-10-25T10:03:00.001-07:00

I've been quite busy over the last several months and have neglected my blog for too long. So while I don't have a rails reality to post today I will make mention of a couple of things that I've been up to over the past few months.

In early June I started contracting with a small startup within eBay called MicroPlace. Josh just blogged about the launch yesterday. So rather than repeat what he said go read his writeup :-) Shortly after I started with MicroPlace Josh came on board and working with the great team from MicroPlace we began to gel as a team and things came together well.

When I started the team was pretty deep into using agile development processes as a guiding principal to their work. Test first was highly touted and code coverage was closely watched (>97% when I left). It made coming in as a consultant much easier because I was able to make sweeping changes to the code when needed and be confident that I could know what was impacted as a result. It was my first time really being in an environment where everyone had bought into the value of testing *mostly* first and it definitely makes things less stressful and more enjoyable.

Though it was a quick 3 month engagement I really am grateful for the great connections that I made with the MicroPlace team and am very proud of the job we were able to do in such a short time of getting something launched, with quality, that is for the greater good of mankind. Best of luck to MicroPlace!

After finishing up with MicroPlace in early/mid September I went on a long overdue vacation for a few weeks, to Italy. While I haven't posted them all you can check out my photos from the trip on Flickr. I just got back last Thursday night and while I'm still getting over the jetlag (waking up at 5-6AM has been great for getting the day started with a run down to the Marina green :-) I'll back on pacific time fairly soon.

Oh and a final note about my beloved Indians who found a new way to falter as I arrived back to the US (I think I'll stay overseas next year if they make the playoffs again), Go Rockies!! ;-) Thanks for a great season tribe and for the chance to watch you in the playoffs!

iPhone activation blues for TDMA customers

2007-06-30T09:30:00.001-07:00

That's right kids. Falling under mass hypnosis yet again, I waltzed down to the Apple store in downtown SF at about 8PM last night to see if the hypothesis would be true that I could walk right in and pick one up instead of camping out overnight. Sure enough there was no line around the corner. The line I waited in had maybe 10 people and I waited maybe 5 minutes.

Tons of phones, no problems, people all around, San Francisco's finest outside standing guard just in case.

Then it's time to go home and activate this thing before going out for the evening. Ahh yes. This is where you get a nice reminder that AT&T is the provider for this phone.

So to give a bit of history, I've been holding out for quite some time for a phone that seemed worthy of giving up my old Motorola V.60c on the old AT&T wireless TDMA network but hadn't found a worthy successor so I just kept kickin it old school. TDMA's signal reach is much further and when I'd go camping I was the only one with a phone that worked because it also was cell compatible.

So basically I've been living in the cell phone "stone age". Everytime I'd decide to go on a "date" in a Cingular, TMobile store, etc, the folks that worked there would always remark "Wow I haven't seen that phone in YEARS. How about a nice crappy new phone that has a weaker signal strength that won't work in your apartment?"

"No thanks" I'd say as I'd walk out with my old tattered TDMA phone and wonder how much longer I'd have it around. I mean after 3+ years it's just starting to get a little long in the tooth ;-) The battery lasts about a day now with any sort of usage.

A few months ago AT&T gave me an ultimatum over a text message. "Upgrade or die." They are turning off the old TDMA wireless network in Feb. 2008. Hmm... well I guess I have no choice now. Hopefully they've got more GSM coverage than the last time I looked and hopefully it works in my apt.

So back to last evening. I got home, hooked it up to the mac that I purchased during my last "mass hypnosis" episode in Jan. 2006. I updated iTunes, hooked up the phone, and started the registration process. It all was going pretty smoothly until I reached the end. AT&T then informs me that more time is needed to activate my phone and that I will receive an email once it's completed.

"Sigh. They're not able to handle this volume." But I suspected that my being on TDMA might have something to do with it. I spoke with two representatives last night that ensured me that wasn't a problem and that it was just due to volume and that they were backlogged. "By 7AM EDT your activation will have gone through sir." What a pain but OK I guess that's the way it's gotta be.

Fast forward to this morning. No activation, no email, nothing. I call up again. Each time I called I made it a point to tell them I'm on the TDMA network because for some reason the person on the other end of the line doesn't seem to have that information. This time the woman says "Oh! Yeah that's gonna be a problem. Can you please hold?" After 10-15 minutes of holding she comes back, apologizes and informs me that they can't help me over the phone. I now need to go down to the AT&T wireless store where they will convert my account to GSM by giving me a fake SIM. Then I have to go back home and activate my phone. Fun. Why this can't be done over the phone I don't know.

Anyway for all you old TDMA users, all 1% of your in the AT&T customer base, be prepared for this nonsense when you finally upgrade. Unless you convert to one of the other carriers which almost seems like the least painful way to go. If that blackberry curve with wifi was ready to roll on TMobile I might consider that instead solely based on AT&T's crappy service.

Time for this caveman to get unfrozen down at the local AT&T wireless store.

Rails realities part 26 (I'm in ur app breakin cascading saves)

2007-05-21T22:27:00.001-07:00

OK I only posted once so far from my experience at RailsConf. I may post some more about some of the sessions I attended but overall it was a great time and I learned a few new things (namely some cool functionality that I didn't know firebug had :-)

One thing I was sporadically working on was adding a new feature to PitchWire and as I went further down the rabbit hole it became apparent that to add this new feature that it's probably best that I finally bite the bullet and upgrade from rails 1.1.6 to rails 1.2.3.

I'm actually still in the process of upgrading but I thought I'd blog about a couple of things that have tripped me up thusfar.

The first one that tripped me up was after updating rails and trying to run my tests I received tons of weird command line errors that I don't have anymore unfortunately but basically my rubygems was too old (.8.something) and I needed to upgrade to the latest (.9.something). I actually can't take credit for figuring it out. My new friend Jimmy (he doesn't have a blog yet but he should) thought of it as we were sitting there pair programming as he'd already gone through the upgrade exercise.

So after updating rubygems with:
"gem update system"

I reran my tests and was down to a total of 7 failures from 120something prior. I went to the first failure and it was an application failure. For some reason my profile update action test wasn't passing.

As it turns out the problem turns out to be my reliance on behavior that was deemed to be a bug: http://dev.rubyonrails.org/changeset/4690

I was using cascading save operations to update multiple objects on a single action because on my profile page I have properties that belong to 3 different objects, user, contact_info, and company. Now one could argue that I could either have separate pages for each or only provide an AJAX style update to the properties of these objects where you can only update one at a time. I may do that in the future but for now I'm not going to refactor my application for the sake of upgrading rails.

What does all this mean? Basically when designing your rails apps don't rely on cascading save operations anywhere. Explicitly save each object whose properties you have updated in the process of a request. And since it's not really desirable to update and save multiple objects per request the best approach is to keep the data in your request confined to a single object if you can which means using fine grained AJAX style field updates using inline editors everywhere or only showing a form that edits fields for a single object.

Unfortunately this doesn't always map very well to the business logic of your app so you may have to do something like:

User.transaction do 
  @user.save
  @user.contact_info.save
  @user.contact_info.company.save
end

Where as if you can rely on saves being cascaded down through a relationship hierarchy you can just write:

@user.save

I can't say I'm psyched to either patch rails back to the "broken" way or revamp my app to undo anywhere I'm relying on cascading saves but I'm a little scared at what else I might stumble across. Hopefully my tests are comprehensive enough to catch anything else, I'm glad they caught this one.

Be careful out there.

RailsConf 2007 - Day 1? Day 0?

2007-05-18T21:12:00.001-07:00

Many geeks have descended upon an unsuspecting Portland for a few days of geekery about some software thingy most have never heard of. Many of these poor luddites have never even heard of Twitter and appear uncertain of the herds of geeks wearing shirts that say "[Skip Intro]", "He broke the build", and "Powerset". I think I overheard some guy asking one of the crew if Powerset was that new gym over on 13th.

So today was Day 1 of RailsConf. I saw another blogger posting an entry titled "RailsConf Day 2". I don't know if he was working on tomorrow's posting or what but any way you slice it today is Day 1. Today was the first full day of the conference and yesterday was just all day tutorial sessions, so that means day 1. Or if you want to be a geek and make the argument that yesterday was the first day, well then you have to be a geek all the way and realize that yesterday was Day 0.

This morning started of with the big keynote. Folks were ready with their buzzword bingo cards, giddy like school kids waiting for the dirty words. Fresh off my "Geek retreat" last weekend in Vegas I went to the sports book down in the vendor area with odds on swear word usage. The over/under was 5. Counting on a kindler/gentler talk I bet $100 on the under.

Turns out DHH was a big teddy bear today and I'm $30 richer. There was no real big Earth shattering news that was revealed today, though he did lay out 9 things that are interesting that are going into Rails 2.0.

Breakpoints are back - ruby-debug is integrated into rails 2. The big win here is being able to put a simple statement into your action, stop the request in flight, inspect and change things and then continue the action.
HTTP perf and asset packaging -
```
javascript_include_tag :all, :cache => true
```
will package all js into one file for delivery. The same can also be done for stylesheets. You can also setup an environment configuration to create virtual asset servers to overcome the browser behavior of serially requesting images 2 at a time from the same host. Read more at Chad's blog.
query cache - AR has query caching that you get for free and works by matching exact SQL calls. You don't need to turn this on it just works. It will be interesting to see how big mongrel processes are going to get as a result of this.
action.mimetype.renderer - separate the mime type from the template type so that you can request a file type and it can be rendered easily by any template type without a special naming convention. Examples he gave: people/index.html.erb people/index.xml.builder index.rss.erb index.atom.builder
config/initializers - To slim down the environment configuration you can put ruby files into the "initializers" dir that get run automatically on init
sexy migrations - flip name -> type declaration to type -> name which can allow you to declare more than one column on a line and simpler timestamp declarations. Check out Chris' post here
HTTP auth - Basic auth plugin is moved to core.
The MIT assumption - default license file for plugin generation
Spring cleaning - removal of deprecated stuff

Of all the things he mentioned I think breakpoint being back is probably the best news for rails devs, especially those that are new and trying to learn the framework. The query cache is interesting as well. It's appears simple and will likely help perf for many apps which do the same queries again and again, especially for those of us that load the user data on each request from the id stored in the session. He didn't show how to expire entries in the cache though.

The keynote demo displayed the restful stuff and he mentioned that you get search for free with the stuff in edge. The convention that is put forth with the REST approach will make writing and reading existing app code that much easier to deal with.

The talks have been very good and the ones that are popular are ridiculously packed. I approached the "Standing on the shoulders of giants" talk which was a guided tour through the code of several ruby/rails projects that were considered to be good code examples.

At the entrance a couple of middle aged ladies were guarding the doors and fending off hordes of geeks salivating at the code porn being shown just beyond those doors. I made my way through the crowd to the front and one of the lady's was like "Sorry it's full". Hmm.... but I'm here as press damnit, I have an obligation to the geek community. I figured "what the hell?" and I asked "Does this get me in?" as I lift up my press pass. "Nope". OK, time to move on to "bouncer" number 2. "Hi, I'm press and I'd like to get in". "OK go on". Sweet! I'm in! Holy crap there's a ton of people in here! Luckily I found a seat and we proceeded to be taken on a tour of Rick Olson's handywork for the most part. Adam did a good job of walking through the code and picking out good examples. He also did a good job of describing his process of "code spelunking" as he put it. I don't think I need to tell all you SouthPark fans out there why that's funny.

Alright I'm off to see about a BOF or if those Powerset guys are wandering the streets of Portland helping Rocko find his gym. If only there were something out there that Rocko could use, in his own natural language to tell him where to find his gym. Oh well, I'm sure something's bound to come out soon, like this year. In the meantime it's very gracious of them to perform user searches with such a personal touch.

JavaOne 2007 Day 3 - My groovy redux

2007-05-10T23:55:00.001-07:00

I still remember the first time I was exposed to groovy. James Strachan stood on stage (I think it was 2003 or 2004) and with his very smooth and soothing voice dazzled everyone in the room with this new language that allowed you to get more done with less. In the period since that time groovy has had its ups and downs but lately it really seems to be coming of age since there's finally a release (1.0 was released in January of this year), there's the grails project, and the popularity of ruby and rails has at least raised the awareness of dynamic scripting languages to new levels. For java developers that haven't made the venture outside the confines of Java it appears now is as good a time as any to put a new weapon to your arsenal. Groovy is certainly a natural choice for many java developers that don't wish to learn a new API with ruby though there's quite a bit of the groovy API that extends java that appears to be at least partially inspired by ruby.

Today I attended Rod Cope's "Advanced Groovy" talk. So while I'd never written a line of groovy until today (I copied Rod's numerous examples for today's post) I felt up to the task of attending an "advanced" talk based on the level of most talks at JavaOne. It turned out I was right, as Rod spewed out code example after code example I felt quite at home with a few minor syntax differences that I will say are less "beautiful" than ruby but that's probably because I'm used to ruby now. But you could take any ruby developer, give them groovy and they would have no problems working with it based on the examples I saw in today's talk.

Let's look at some of the advanced features from Rod's examples:

Safe navigation - Allows safe traversal without getting NPEs and avoid doing null checks. When you call the property with "?" if anything in the chain is null the result is null.

people = ['rod' : ['age' : 36, 'height' : "5'9"]]
people.rod.age
-> 36
people?.joe?.age
-> null

Expando - a dynamic etch-a-sketch object that you can add methods and properties to on the fly

import groovy.util.Expando

rod = new Expando(name: 'Rod', age: 36)
rod.drinkWater = {num -> num.times { println "yummy" }}

print rod.age
-> 36
rod.drinkwater(2)
-> yummy
-> yummy

Template engines - A closure as template engine

t = {p -> "${p.name} is ${p.age()}" }
rod = new Person(name: 'Rod', age: 36)
println t(rod)

He also mentioned the existence of a GStringTemplateEngine. groovy.text.GStringTemplateEngine

Default parameters - just like ruby it supports default param values in method signatures

Single object iteration/identity. You can iterate over any object whether a collection or not. If it's not a collection you'll get back the object itself once in the block.

currentCustomer.employees['joe'].manager.secretary.each { it.bonus = 1000 }

With identity it's a way to have an implicit object set in the block. I'm not really clear on why this is such a big win at the moment.

currentCustomer.employees['joe'].manager.secretary.identity { 
println "salary = $salary"  } <- same as saying secretary.salary

Currying - This is the process of using functions to manufacture other functions.
First a groovy example:

c1 = {a, b -> a + b}
c2 = c1.curry("Hi ")  result = c2 = {b -> "Hi " + b}

Now let's see the same thing in ruby for folks that have never heard of currying before. The following code isn't mine it's taken from the the ruby quiz site.

require "curry"

scale = lambda { |size, object| object * size }
puts "3 scaleded to a size of 10 is #{scale[10, 3]}." # 30
puts

# curry some functions
double = scale.curry(2)
triple = scale.curry(3)
halve = scale.curry(0.5)

puts "4 doubled is #{double[4]}." # 8
puts "1 tripled is #{triple[1]}." # 3
puts "Half of 10 is #{halve[10]}." # 5.0

Dynamic language extensions - mixins. Of all the things that were shown the implementation of mixins made me cringe because you have to create a new class and then pollute your implementation code that uses the mixin with the "use" method. The ruby way is seamless and much more elegant to me but the groovy way is arguably a little safer because it's so explicit and you'd always know that you're dealing with mixed in implementation. Still, I don't like it :-)

class PropertiesHelper 
{
  public static List getProperyNames(Object bean)
  {
    def methodNames = bean.class.methods.name.findAll { it.startsWith('get') }
    def goodNames = methodNames - ['getMetaClass', 'getClass', 'getProperty']
    def propertyNames = goodNames.sort().collect {
      // "getName" -> "n" + "ame" -> "name"
      it[3].toLowerCase() + it[4..-1]
    }
    return propertyNames
  }
}

rod = new Person(firstName: 'Rod', lastName: 'Cope')
use(PropertiesHelper) {
  for (prop in rod.propertyNames) {
    println "${prop} = ${rod[prop]}"
  }
}
-> firstName = Rod
-> lastName = Cope

Method aliasing

def p = System.out.&println
p('hi')

def doSomething(method) { method('dog') }
doSomething(p)
-> dog

After these simple examples Rod broke into a couple more complex examples that really showed the power of groovy and to me rivals DHH's video that made RoR so attractive to so many people.

Demo of xml-rpc
First start up a server

import groovy.net.xmlrpc.*

server = new XMLRPCServer()
server.testme = {name -> "$name is cool"}
server.startServer(new ServerSocket(9047))
go

Then create and run the client code

import groovy.net.xmlrpc.*

server = new XMLRPCServerProxy('http://localhost:9047)
println server.testme("Groovy")
go
Groovy is cool

Going back to the server let's add a new method to our service:

server.multiply = {it * 7}
go

Back to client, let's call it:

println server.multiply(3)
go
21

No reboots were needed in the above example code which is impressive

Next up was the ActiveX demo using http://danadler.com/jacob (Java API to COM)

import org.codehaus.groovy.scriptom.ActiveXProxy

excel = new ActiveXProxy("Excel.Application")
excel.visible = true
go

This opens excel on your machine

book = excel.workbooks.add()
go

Creates a new workbook in your opened excel instance

sheet = book.activesheet
go

Selects the first sheet in the workbook

He then proceeded to add data to the sheet programmatically, create charts and add formulas (this code isn't complete as I wasn't able to keep up with this section)

a1 = sheet.range('a1'); a2 = sheet.range('a2')
co = sheet.chartobjects.add(50,50,400,200)
go

After that he demonstrated the SwingBuilder and updated the excel spreadsheet via that UI

swing = new groovy.swing.SwingBuilder()
mybutton = swing.button(text: 'click me')
mybutton.actionPerformed = { 
  a1.value = new Random().nextFloat() * 500
  chart.export('graphname.gif)
  mybutton.icon = new javax.swing.ImageIcon('graphname.gif') 
}

frame = swing.Frame(title: "The frame")
frame.show()

The above code shows the swing GUI and when you click the button the chart is updated both in excel and in the button that you've just clicked. The speed was fast with no noticeable slowness.

A couple final examples that were thrown in at the end

"cmd /c dir".execute().text -> execute a system process
Thread.start { any code } -> firing off a thread, this is just like ruby

It's great to see groovy finally coming into its own. Performance isn't bad and will only get better with optimization and for java devs that want to get into scripting or a ruby dev that needs to work in java and can't use jruby groovy's a really comfortable choice for all but the most religious ruby zealots :-)

JavaOne 2007 Day 2 Newbie enterprise on rails

2007-05-10T15:35:00.001-07:00

Day 2 of Javathehutt's ruby coverage at JavaOne. Huh? Yeah that's right. Next week at Railsconf I may just have to talk about all the java related discussions that are occurring there. So what happened on day 2 that would be of interest to the ruby faithful? Well today there was "Ruby on Rails Meets the World of Enterprise Applications" given by Daniel McWeeney from Colgate-Palmolive. I walked into another pretty good sized room that was full, perhaps about half the size of the room for the JRuby session.

Daniel was a very charismatic speaker who would lift his arm in the air and bark out "demo" or "slides" to switch from one context to another. He spoke about his company's need to create a more user friendly interface to an SAP system. The system is a project/resource management system where they create projects and then assign resources (people, for those in the non-enterprisey world). The current interface is pretty unfriendly to the untrained user and as a result they weren't seeing a satisfactory level of usage of their SAP system.

So it was the job of our hero Daniel and his crack team of young energetic developers (actually I think it was just him) to figure out a way to come up with an interface on this system that would be easy to use, do it on zero budget, and with minimal time. He said that when he started he had zero knowledge of ruby and rails, and while it by no means a knock on him it actually was pretty easy to see that it was his first rails app from looking at his code as well as some of the UI that he'd built. He did a pretty good job of walking through his code and explaining exactly what was happening at all times. He made heavy use of RJS and drag and drop, and while there is certainly room for improvement he generally did a pretty good job.

One thing he made use of that was new to me was a gem called SAP4rails that he used to make calls into SAP to read/write the project data. It looked pretty straightforward to use and I hope I never have to use it :-)

In non-ruby related news I attended a press/analyst lunch panel on international developer perspectives where I learned that the entire country of Brazil loves java and that the guy from the Philippines was surprised at how much a developer in Singapore makes and was thinking of flying there to work every week.

I wanted to attend the prototype, scriptaculous, and rico talk but the line was too long and well, I'm likely to already know much of what they're talking about so I skipped out on that and headed to the press room to linger and talk to some journalists and espouse the great benefits of PitchWire to them. I actually ended up meeting a couple of coders in there including Tim O'Brien who blogs for O'Reilly and is into rails development. I gave him a quick rundown of my sortable table plugin and he immediately identified need in his current apps. Always nice to build stuff that people use.

Later in the day Tim and I headed over to the blogger meetup and then the Google party. I'm going to defer to Hani's coverage which is pretty on target :-)

I will say that it was great to run into Josh Bloch again after meeting him at last year's JavaOne. We chatted about his API design talk and he also disclosed to Cedric and myself that he had now written his first line of ruby code this week :-) Can "Effective Ruby" be far away?

Oh and top quote overheard during a press event from a member of the press "I was a college professor and I graduated students that could neither read nor write"

JavaOne 2007 Day 1 - JRuby, Appistry, Layer7, SF "outsourcing", and shots at the Tangosol party

2007-05-09T17:20:00.001-07:00

Last year Sun latched on to JRuby and hired the developers that work on the project mostly because of the astuteness of Tim Bray. It's been amazing to watch this project grow from relative obscurity to headliner in such a short amount of time. Yesterday as I made my way through the halls at Moscone to attend the JRuby talk I was thinking to myself "It shouldn't be too bad finding a seat here, I mean this is "Java" one, not ruby or jruby one". While it wasn't difficult to find a seat I was surprised when I walked through the doors of Gateway 104 to find a large room that was full for this talk. A quick estimate put it somewhere in the neighborhood of at least 1,000 people which is way more than I would've thought going in.

The talk itself was really very introductory. Charles and Tom assumed no prior ruby knowledge and even asked the question "Who here doesn't know what ruby is?" As I thought to myself "there's no way... ", I looked around and saw at least 5-6 hands raised in just my visible radius. I didn't stand up to see the aggregate total of folks who wandered in seemingly off the street with no idea of what they were attending. Later in the afternoon I mentioned this to Hani and we were theorizing about how that could happen. We proposed various reasons as to how someone could be attending a talk about a different programming language and yet have zero idea of that fact.

Were they plants in the audience by Sun? Charles' and Tom's relatives? Though I didn't see anyone with a "We're Nutter about you Charles" sign or anything like that. Though I did see one poor soul holding up a "Vote for Sanjaya" sign. I'm pretty sure he had his hand raised during the "Does anyone not know what ruby is?" question. We finally settled on the notion that those people had lost a bet. "OK if you don't get her number you have to go to the JRuby talk."

Charles and Tom did a great job breaking down the features in ruby that would be new to java developers and what makes them interesting, modules, blocks, duck typing, etc. They went over rails and its pieces, calling ActiveRecord an "ORM on steroids", which I can't say I agree with. I'd call EJB3 or Hibernate or Kodo an ORM on steroids. ActiveRecord is just an ORM.

I'm really pleased with the great lengths the JRuby team has gone to make it easy to get working. Simply download the package and run jruby from the command line and pass it your ruby script.

During the talk they provided a simple example of a JRuby script that was something like the following:

require 'java'

a = java.util.ArrayList.new
a << 'all your code belong to jruby'
a.each do |el|
  puts el
end

Pretty neat stuff. As a ruby developer that's as seamless as one could expect, and for java developers it's great insurance that they don't have to leave their world behind. While I didn't really have a look at perf on the simple example above appeared to be on par with the regular ruby VM.

During the presentation they created a sample rails app and demonstrated migrations and scaffolding. First they showed the sample app running using webrick, and then they created a WAR file and deployed the same app to glassfish. Unfortunately they only showed the app load once and didn't actually use the app at all as I would've liked to see if there was any noticeable performance change even for a single user in development mode, but still an impressive nonetheless.

They demonstrated portions of the "Goldspike" project. This is the project that contains the tools required to build a WAR file containing your rails app and all dependent gems. Basically you create a ruby file that describes your dependencies and you run the tool over your app and it builds a deployable WAR file that you just drop into glassfish, tomcat, etc.

The only caveats that I can see right now are probably still performance and usage of native libraries, like RMagik. Charles indicated that you'd run into problems with such a library and that there are plans to port them.

Roaming around the pavilion floor I had a chat with the guys over at Appistry about their application "fabric". In a nutshell it's a deployment framework that allows you to scale your applications while you kick back and work on learning rails/grails/sails/snails or level your rogue in WoW. I also stopped by and spoke with Layer 7 Technologies about their XML appliance. I have to admit before I went over and talked with them I didn't think I'd find any of it interesting because I just lumped it in as part of the WS deathstar debacle but they were really pragmatic and intelligent guys. They clearly position their appliance as something for the enterprise and for folks that have fairly complex systems of web services that they need to secure and have a single point of management. Their product basically serves as an entry point and central managing system for an enterprise's services.

After the day's activities I met up with some friends over on the Embarcadero for dinner. The conversation was lively, geeky, and engaging as always. One topic of note was the revelation of companies in London that look to outsource their development work to San Francisco because of how "cheap" it is compared to hiring developers in London. I sure hope they don't forget to account for the language barrier in their cost analysis ;-)

After dinner we strolled over to the Tangosol party where there was an open bar. Congrats Cam and his team for a well deserved exit and thanks for the great party! Wednesday night is the blogger party at Thirsty Bear and the Google party. I'm on my way to a session to be named right now. Hopefully it'll be about something completely foreign to me so that someone else can shake their head in disbelief at my ignorance.

Rails realities part 25.1 (Do what you say, but say the right thing)

2007-05-01T13:12:00.001-07:00

After yesterday's post about fine grained column updates with update_attribute I was discussing the matter with Sam Pullara and Patrick Linskey with regards to how Hibernate and Kodo deal with these kinds of updates.

First off as a reminder of the data and scenarios I'm talking about:

class Reservation < ActiveRecord::Base
end


# end user action
def edit_reservation
  reservation = Reservation.find(params[:id])
  reservation.update_attributes(params[:reservation])
end


# admin only action
def confirm_reservation
  reservation = Reservation.find(params[:id])
  reservation.update_attribute('confirmed', true)
end

The desire is to be able to update the "confirmed" field without saving the rest of the record. The update_attribute that is part of ActiveRecord::Base updates the field and saves the whole record which seems wrong. I wanted to be able to "cheat" and not have to add either optimistic concurrency or a new table to support the notion of confirming a reservation and only allowing an admin user to do so.

Speaking with Patrick he said that Kodo doesn't allow for explicit partial object flushing as it is fraught with peril. He asserted that optimistic concurrency is the only way to go and it's really cheap. He actually went as far as to suggest always having an optimistic lock column on all tables.

Yesterday I said that I felt it was too heavy handed but as I was lying in bed last night at my new apartment, kept awake by the unknown man living above me clearing his throat with great vigor every 20 minutes or so, just long enough intervals to doze off and be abruptly awoken at the next "clearing", fun... What was I saying? Oh right, heavy handed optimistic concurrency.

After thinking about it more I realized that Patrick was right (Wow imagine that, the guy who's been focused on O/R mapping for the past 6 years or so :-). Even doing fine grained updates like I talked about yesterday isn't a good solution to my particular problem and is probably something that you shouldn't be doing at all unless you know that you're never going to have concurrent editing (and we know how often application requirements change so this probably isn't a good assumption to make and bake into your app). I was so concerned with not forcing the end user to deal with OC errors and thinking "well I just need to update this flag that's not edited by the user at all", that I failed to remember that because AR always saves all values that I still have a race condition, only the other way now, where a user could potentially change the "confirmed" value that I've so carefully set with my tricked out update_attribute method.

So my choices really are:

1) Add an optimistic lock to the table which has the undesired effect of possibly forcing a user to retry their edit, or
2) Create a new table for the "confirmed" flag which would only be editable by the admin users.

I think that for my case I'm going to add a new table because I really don't think it's appropriate to either have end users retry an operation that should always work, nor do I think it's a good policy to just try again on their behalf if it fails the first time. The "confirmed" flag is really an admin function and only used internally to the company so while it feels like a bit much to create a table for just that flag I may have to, but will reevaluate if there's an appropriate design that's a little more practical and not so "wasteful".

Anyway, for the folks that are doing single field updates, don't believe that the patch I created is something that's going to safeguard you against concurrency because it won't. It's the wrong solution. The update_attribute ability doesn't even exist on other O/R mappers and I can see why more clearly now. They get around a problem like this by offering users the ability to define lock groups, where only certain fields are used for optimistic concurrency, and more.

ActiveRecord isn't as sophisticated so if you're going to use it know your limitations in terms of what you should or shouldn't do when designing your schema as it relates to your app's requirements. So in the end it really doesn't matter that update_attribute saves the entire record by default because if you're desiring a fine grained update you're likely asking for trouble at some point. Time to unhack my hack :-)

Rails realities part 25 (Do what you say. updating activerecord update_attribute)

2007-04-30T10:22:00.001-07:00

I've been working on adding a data field or two on some of my user objects but these fields are really only ever editable by an administrator. You may argue that such fields belong in an entirely different table. Well in the interest of keeping things simple I chose to add it to the existing user object as it is directly applicable.

Anyway, illustrating by example let's say I have a reservation system and after a user creates a reservation an admin user needs to perform some manual operations and then update the reservation as being confirmed. Meanwhile some attributes on this reservation are still editable by the end user.

Ok so let's look at the active record API and we see there's a method called "update_attribute" that takes the name of the attribute and the value you'd like to set for the attribute.

Alright so I just call:

reservation.update_attribute('confirmed', true)

Right?

Well yes that does indeed update the targeted attribute, BUT (and you knew there'd be a but otherwise there's no blog post), it also saves the entire object which updates all attributes.

Here's the active record code for update_attribute

      def update_attribute(name, value)
        send(name.to_s + '=', value)
        save
      end

The send call of course sets the attribute value and save eventually boils down to this:

      def update
        connection.update(
          "UPDATE #{self.class.table_name} " +
          "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
          "WHERE #{self.class.primary_key} = #{quote(id)}",
          "#{self.class.name} Update"
        )
        
        return true
      end

As you can see update simply updates all attributes for the current object.
The quoted_comma_pair_list simply takes the attribute values and builds up the SQL parameter list, e.g. "id = 15, `confirmed` = 1", etc

OK so what's the problem here? Well none if you never care about concurrent editing of the data. "But what about optimistic/pessimistic concurrency?" you ask. Indeed we could use either of those approaches to solve the race condition of two users editing this data simultaneously, but in this instance it's really too heavy handed and doesn't really fit the situation.

As I mentioned at the outset we have a single column named "confirmed", that we'd like to have updated by an administrator. Updating this field would never conflict with a user editing the other fields for this object. Ideally what we'd like is to have is some way to update a single attribute's value... hmm.... perhaps an instance method that when invoked only updates the specified attribute. Hmm... what would we call such a method? Oh, I know, "update_attribute". Uh oh! Who smells an active record mixin patch? In the words of Matt Puppet "I'm about to hack a bitch". I don't think a plugin is the right thing here as I think this is a bug as opposed to a feature.


# put in lib/active_record_ext/base.rb
# append "require 'active_record_ext/base'" to your config/environment.rb
 
module ActiveRecord
  class Base 
    # Updates a single attribute and saves the record. This is especially useful for boolean flags on existing records.
    # Note: This method is overwritten by the Validation module that'll make sure that updates made with this method
    # doesn't get subjected to validation checks. Hence, attributes can be updated even if the full object isn't valid.
    def update_attribute(name, value)
      send(name.to_s + '=', value)
      # safely escape the value before we update
      atts = attributes_with_quotes(false)
      connection.update(
        "UPDATE #{self.class.table_name} " +
        "SET #{quoted_comma_pair_list(connection, {name => atts[name]})} " +
        "WHERE #{self.class.primary_key} = #{quote(id)}",
        "#{self.class.name} Update"
      )
      
      return true
    end
  end
end

The above is my new implementation of "update_attribute" that performs as advertised. It will only update the specified column value for the given object. I haven't modified this in the rails codebase and run the tests to see if there's any breakage but I imagine anything that breaks as a result of this behavior change was using the API incorrectly to begin with as it means there would be reliance on the fact that an entire object save is performed when you update a single attribute value. I can't think of scenarios where this would be required behavior, please correct me if I'm not thinking of them.

So now when you add this patch you'll see "UPDATE reservations SET `confirmed` = 1 WHERE id = 20" instead of an update that includes all attributes.

I did a search and sure enough there are some others that agree that the behavior change I've prescribed is the correct thing to do:
http://dev.rubyonrails.org/ticket/8053

There is also a recent discussion on the rails core mailing list on this topic but mostly related to the lack of validation triggering for this call. On that very thread Peter Marklund discusses his need to write a custom method called "update_column" for the very same purpose I've described here.

Anyway, enjoy and happy updating.

Rails realities part 24 (log files, the lies they tell and tuning MySQL)

2007-04-28T11:01:00.001-07:00

I've read from a couple of folks that the log file data isn't completely accurate. Well sometimes you really don't learn just how true something is until you learn it yourself the hard way.

I've been using a VPS provider and for the most part things have been pretty good. Uptime is good, throughput is good, etc. But unfortunately I was experiencing intermittent slowness with my app. And when I say slowness we're talking about going from X req/sec to 40+ seconds for a single request. The problem would appear suddenly, and with no increased traffic on my box, and then leave just as suddenly.

With the help of my VPS provider we tracked down the slowness as being tied to heavy I/O usage by other users on the same machine. There were a few times where another user's xen instance (my host uses xen for virtualization) was completely pegged and hogging all the I/O. They would reboot that user's instance and suddenly my application would spring back to life.

Looking at the logfile the time for rendering appeared to be responsible for the entire slowdown and the DB access time looked exactly the same as when the app was performing normally.

After many weeks of on and off attempts at trying to figure out what's wrong and thinking that it was somehow related to fetching the template files from disk (even though they should be cached in memory), I believe that the problem may be finally solved with the help of Evan Weaver. I was on IRC and Evan overheard (overread?) me talking about maybe having to switch providers because of the inability to throttle I/O fairly among all users on a machine.

He asked what was happening and after explaining he said he'd seen this before and asked to see my MySQL configuration. I showed it to him and explained that I had taken one of the template configurations from the MySQL installation as a start. Well as it turns out that template configuration is way off in terms of memory allocation for InnoDB (I used the medium sized deployment template).

The MySQL configuration options are akin to the cockpit of the space shuttle (or so I'm guessing) but like you've seen in many a cartoon even with all those crazy switches and buttons there's always the one or two buttons that really do something important. Basically Evan took me aside and said "Hey doc, see this big red button right here and this blue one here, just press those." For me those big buttons were:


[mysqld]
innodb_buffer_pool_size = 384M
innodb_additional_mem_pool_size = 16M

Those two were originally set to 16M and 2M respectively. I started with the "my-medium.cfg" template as it prescribed it for systems with 128MB of RAM that also ran a webserver. I figured "well I also have mongrel processes as well as backgroundrb processes so this might be a good starting point for my 512MB VPS". Boy was that ever wrong.

I also made a few modifications recommended by the MySQL performance blog


key_buffer = 16M
myisam_sort_buffer_size = 8M
thread_cache = 16
table_cache = 256
innodb_log_file_size = 64M
innodb_log_buffer_size = 8M

Since I've made these changes (about 3 days ago now) there has been no I/O blocking slowdown. I'm running the log file analysis tool pl_analyze to look for slow actions and it's been clean so I'm hopeful that in the end MySQL running with too little memory allocated ends up being the culprit. It does make sense that this would be the case as MySQL would have to go to disk quite a bit since it's unable to cache much of anything and of course when the disk is getting slammed that's going to negatively impact performance. We'll see if this keeps up but I'm optimistic that this was the problem.

Unfortunately the production log file led me to draw some early and incorrect conclusions about where things were bottlenecking. So add another voice to "the log file stats are inaccurate" with an exclamation mark and further stating that it's not just req/sec that can't be trusted it's the breakdown of DB and rendering time as well. Time to look into railsbench.

Best regulatory cost recovery fee ever!

2007-04-28T08:34:00.001-07:00

I'm in the market for a new mobile phone and today while I was shopping on Amazon I added a phone and plan to my cart. While browsing the items in my cart I saw the following link under my phone/plan entry:

http://www.amazon.com/Regulatory-Cost-Recovery-Fee/dp/B00020KCBK/ref=dp_return_1/102-0955861-5109717?ie=UTF8&n=301185&s=wireless

Now if only they'd let you review some of the other fees that get tacked on to various utility bills and bank accounts.

SVRuby Conf -> JavaOne 2007 -> RailsConf 2007

2007-04-23T10:50:00.001-07:00

I'm going on a conference bender here in late April to mid-May. This weekend was the 2nd annual SV ruby conference which was a pretty good conference, despite the influx of vendors this year (SAP seems to run from conference to conference trying to convince people to use their stuff). The most interesting talks to me were Ezra's talk on merb and the Twitter scaling talk because they are both immediately applicable to me. Merb basically is a way to write parts of your app that require more speed and don't require all of rails, RSS feeds for example. It works as a mongrel handler which basically works exactly like a servlet in the Java world.

It was great to finally put some faces with some of the names. There are really some very smart folks working in the ruby community and they are all very friendly and fun to hang out with. I'm looking forward to RailsConf next month in Portland but next up for me is JavaOne and how I'm going is an interesting story.

The other day I was pitched via my PitchWire page (I have one of course but it's not because I consider myself an influencer and receive tons of PR inquiries, though perhaps times are a changin). It was somebody from Sun's PR department who presented me with an invitation to this year's JavaOne conference as a member of the press. I was pretty happy to receive the invite and immediately accepted. I thought for sure this would be the first time in 7 years that I would be unable to attend JavaOne but lady luck smiled upon me with a free invite. Regardless of the conference itself it's always fun to go and hang out at the parties :-)

It's been quite awhile since I've had the chance to see what's really new in the Java world and this is a good opportunity to see what's happening. Of course I'm well aware of the jruby project and watch with great interest as I'm hopeful that the JVM becomes a higher performance deployment option for rails. Interestingly, a quick search through the conference catalog for the word "ruby" yielded nearly a full conference schedule's worth of sessions to attend.

Of course there are the obligatory sessions on Swing and threading as well as EJB3 and SOA. I'll probably end up in a few of the webapp sessions like Gavin and Bob's webbeans talk, I'm looking forward to the advanced groovy as well as the various rails comparison sessions including what appears to be a real world case study of rails by a large company.

So if you're there look for me. I'll wearing my press pass and walking around lookin for the hot story to blog or twitter and basically playing the part of an influencer. I'm also looking forward to meeting legitimate influencers and informing them of PitchWire and helping build the community further. The response we've received thus far has been fantastic from both publicists and influencers.

Play Ball! PitchWire's opening day

2007-04-02T12:31:00.000-07:00

Today's opening day in MLB and while I'm sure this is finally "next year" for my beloved Indians, today is also opening day for PitchWire. PitchWire is my latest business venture, a product that will help redefine the relationship between publicists and influencers (journalist, analysts, and bloggers).

The basic premise is that influencers are pitched via email quite a bit and dealing with that volume of information is difficult for a couple of reasons:

A large segment of email pitches (about 65%) are not relevant to where an influencer's interests lie.
Email is broken for managing processes, like the development of a story idea between two parties.

You can check it out here: http://www.pitchwire.com

As you might imagine the site is built entirely on rails (1.1.6 at the moment) and makes use of some of the following wonderful plugins:

Acts as attachment (Soon to be attachment_fu for the s3 goodness)

Backgroundrb Ezra's fine background processing creation. I use it for processing incoming emails and file uploads.

Foreign Key Migrations Been using this one for awhile. Used it on LoanBack as well. Very handy.

Live tree This fantastic little plugin make displaying and selecting tree based data nice and easy. I ended up doing some javascript hacking to customize behavior I needed but this is a great starting point for anyone requiring a tree for their data.

Rails rcov Should be required for any rails project. In fact it should just come with rails. While rcov doesn't tell you the quality of your tests it does tell you "hey buddy this section of code here... completely untested"

Responds to parentThis little gem makes it nice and easy to perform file uploads and be able to remain on the same page and track progress and display updates.

Tabnav Nice simple plugin that makes it easy to add tab navigation to your app.

SortableA plugin that I extracted out of my work with PitchWire. It makes it pretty easy to get a sortable, searchable, filterable, table of data up in a few minutes. And not just for a single object you can traverse relations and sort by attributes on those objects as well. Here's my blog post about it.

I'm also using YUI grids as the basis of my app's layout. It does a pretty good job of working the same across browsers. The only problem I've run into really was IE6 and min-width which I managed to fix with a hack.

I also make heavy use of a modified version of Lightbox gone wild. I'm basically using this as a modal dialog for my app in numerous places instead of either going to a new page or showing an inline div which has it's problems when you're trying to edit form items. More about my usage in rails can be found in this blog post.

And finally I also use really easy field validation with Prototype for my client side validation. It's really easy to add your own custom validations for the fields in your form.

I've blogged about some of the above in the past but I may get into a little more detail about how to extend and use some of these various plugins if you want to achieve some of the same results that I have in the PitchWire app. In the end there's certainly more ways than one to achieve some of what I've done and in fact I may find that there may be a better way (perhaps using the YUI widget library more extensively) but as it is now I've got all the pieces to a small app framework that allows me to easily whip up editable lists using dialogs as well as sortable, searchable, filterable, paginated tables.

I looked into the various autogeneration projets (streamlined specifically) but at the time I started building my app nothing was really there yet for my needs. I suspect the landscape is much better these days and I'll have a look to see if there's anything out there that I can use in conjunction with or as a replacement for what I have now.

Installing Wordpress with MySQL 4.1 and higher

2007-03-29T02:33:00.000-07:00

Some 5 minute install that was. Just finished installing Wordpress for our site's blog and it would've been easier if I didn't have to build and install PHP though that wasn't hard. The harder part was the lack of information that came out of wordpress when the install script didn't work.

Turns out that the password for the user I created in MySQL needed to be hashed in the "old" way for PHP 4.

The way I figured out the problem was I created a PHP file in the root of my wordpress install that contained the following:

$username = "blog";
$password = "passowrd";
$hostname = "localhost";
$dbh = mysql_connect($hostname, $username, $password) 
        or die("Unable to connect to MySQL");
print "Connected to MySQL
";
// you're going to do lots more here soon
mysql_close($dbh);
?>

Running that page gave me:

"Client does not support authentication protocol requested by server; consider upgrading MySQL client"

OK so now we're getting somewhere. Googling that error eventually led me here:
http://www.digitalpeer.com/id/mysql

going to modify my blog user in the manner prescribed in that posting fixed me right up and my wordpress installation was done. So minus that hangup it really would've been a 5 minute install.

Anyhow, I know most folks reading here are probably using something like mephisto which I considered as well but I decided to go with wordpress for various reasons, one of which was that PHP is going to run a bit faster and take up less memory than a mongrel running rails. Then again nginx would take up much less than Apache but that's a battle for another day.