bitfluent

Tethering over Celcom 3G on the iPhone 3.0

Thu, 18 Jun 2009 17:42:00 +0800

Open this link in MobileSafari - my_celcom.mobileconfig and install the profile. Alternatively, you can download this file and mail it to yourself and open it up in the iPhone Mail.app.

Credits go to http://help.benm.at/help.php. I downloaded the settings for SG telcos from that site to see which parts were customizable and pretty much found you just need to change the APN to use celcom3g.

Also, for you people on DiGi: DiGi.mobileconfig courtesy of Snuffykl from LYN.

EDIT: I’m on the RM68/month unlimited data plan. Is it the cheapest unlimited 3G plan around?

EDIT: I can confirm that tethering and MMS does not work on the iPhone 2G (1st-gen) right now. It will probably require jailbreaking which should be out on Friday, 19th June.

EDIT: “Does not work” means the MMS and tether options are nowhere to be found in Settings.

Are You Coming To #barcampkl?

Tue, 31 Mar 2009 16:26:11 +0800

#barcampkl is happening this weekend, 4-5th April 2009, at Inti College Subang. Some pretty interesting talks have been scheduled ahead of time although the organizers have promised to implement a “real” unconference where the talks are voted at the opening of each day.

So, are you coming? Register here.

Secure and Signed AuthSub Requests in Ruby

Wed, 18 Mar 2009 23:21:00 +0800

I pulled the trigger in my last blog post about solving Google AuthSub’s warning. It solved only half the problem - the not-showing-the-warning half. I was too quick to assume it would work since Google returned a token. Actually performing GET on the contacts feed would yield me a 401 Unauthorized.

So, what did I get wrong? A few things.

Firstly, I didn’t have to set the sig in the request authorization URL. A simple secure=1 would have been sufficient. I confused this concept with other request schemes like Facebook’s which signs the request and appends the sig to the URL parameters.

Secondly, for secure AuthSub requests, you need to set special signed headers. Regular non-secure AuthSub requests only need a short header.

However, if you want secure requests, you need to sign the request. It’ll look something like this.

I thought I nailed it but it still returned me 401 Unauthorized. I downloaded the Python GData client to compare the sig values and indeed the sig I generated was off.

So the final piece of the puzzle is how do I correctly generate the signature. google-authsub (and my contacts commit) got it wrong. This is what it was doing:

After much googling, I found the answer. Immad Akhund posted the solution on the Google Data Protocol mailing list in June 2008. The correct way to sign data is to use the OpenSSL::PKey::RSA#sign method and remove the newlines after Base64 encoding.

So, there you have it. I’ve pushed a new commit to the contacts library with all the fixes. I’ll be forking google-authsub and pushing fixes there too in hopes that another person wouldn’t need to spend a day figuring it out like I did.

Solving "This website has not registered with Google to establish a secure connection for authorization requests"

Wed, 18 Mar 2009 01:47:00 +0800

I recently ran into an ominous warning on the Google Contacts Access Request landing page.

After some googling, the solution is to register the requesting domain and upload a self-signed X.509 certificate.

Once completed, I retried the request and got a slightly less threatening warning.

The solution was to add two additional parameters to the request: secure=1 and a signature. Fortunately, I found how to generate the signature in the google-authsub gem. A few minutes later, I added support for signing AuthSub requests to Mislav’s contacts library and got the results I wanted. Commit.

Update: I got it wrong about appending the signature to the parameter. I posted a follow up on how to correctly perform signed AuthSub requests in Ruby.

#rubinius

Thu, 22 Jan 2009 17:28:00 +0800

evan: i'm curious, how do you know the JVM is deopt'ing in certain cases?
headius: it tells us
evan: twitter?
evan: us post?
evan: collect call?
headius: reaches out of the screen and slaps us sideways
evan: hah
headius: there's a bunch of debug options for hotspot
evan: NOT SO FAST BUCKO
headius: some in the released jdk, some require a debug build
headius: LogCompilation, PrintInlining, PrintAssembly
evan: -XXSlapRatio=1persecond

Sharing Contracts

Tue, 23 Dec 2008 12:41:00 +0800

I love it when companies that provide professional services share the contracts they use when dealing with clients. Many people consider contracts to be part of their secret sauce and competitive advantage over their competition so it’s understandable that these documents are not discussed much (plus they also cost money having to go through legal counsel).

However, Obie Fernandez of HashRocket and Andy Clarke of Stuff and Nonsense have been awesome by sharing the contracts they use in their daily business:

Master Services Agreement Part 1
Master Services Agreement Part 2
Contract Killer (via @cheeaun)
Flavert Media Lab’s Contract (thanks @tekong!)

I’d love to collect more of these kinds of write-ups. Do you have some? Twitter me!

Test autoposting from Posterous

Sat, 20 Dec 2008 15:14:31 +0800

I never knew posterous could autopost to other services as well. That’s pretty rad.

Posted via email from kamal’s posterous | Comment »

Full List of 1,339 Rails Contributors

Fri, 31 Oct 2008 15:42:27 +0800

One of the biggest plus points of using git for open source projects is the preservation of the original author of the patch. Here’s how it looks like when displayed in GitHub:

In the Subversion days, patches into Rails were attributed by adding an arbitrary combination of the author’s name/email/nick at the end of the commit messages. Makes it kind of hard to keep track of the number of distinct contributors over the lifetime of the project.

Fortunately, Xavier Noria whipped up a script to parse the legacy commit messages to extract the number of commits per author using these rules:

First extract authors from commit message
If empty, check changelogs via git show id
If empty, author is the committer

The full list is below (you probably can’t see it if you are reading this via Google Reader)

Tumblr Client On The iPhone

Sat, 09 Aug 2008 23:43:54 +0800

Would having a tumblr client on my iPhone see me posting more frequently? Obligatory test post.

Posted with LifeCast

On the Beauty of Rubinius' Design (I Wish I Had Rails.new)

Mon, 02 Jun 2008 17:13:00 +0800

In Rubinius, you can spawn off a brand new complete VM by simply calling Rubinius.new. It’ll behave exactly as though it was invoked directly from an rbx binary sitting in your $PATH, complete with STDIN/STDOUT (which you can override). I believe this is one of the basis of how Rubinius’ multi-VM architecture works.

Anyway, I bring this up because I really, really wish Rails was architected in a similar fashion. I am building a CMS on top of Rails and would love to get my hands on a Rails.new if there ever was one. Here’s why.

In a CMS setting, very little of what Rails offers out of the box is usable. You don’t have access to Rails routes so from the very beginning, you don’t have Rails automatically invoking the right controller, the right action and rendering the right view. This doesn’t make sense anyway - you don’t expect your CMS users to start writing controller code in your web editor, do you? (Unless you are Heroku.)

On a slight tangent, the assumption when writing a CMS is that when you ship, you would have written every conceivable controller and model there is (views don’t fall into this because users are generally familiar with the concept of customizable templates). One strategy to extend your “frozen code base” is via the use of widgets and third-party apps (like Facebook) so that you can create seemingly new pages served by custom controllers.

So how do you design a CMS? I’ve been prototyping something for the past week and came up for a breather to check out how other people have solved it. I am delightfully surprised to find out that Radiant does it very close to what I have. In particular, Radiant has one single controller that accepts all requests (lets ignore the entire admin portion for the time being). Based on the path array (provided by the globbed route), it decides what to do / where to dispatch. It takes care of locating the page that corresponds to the URL (it uses a Page model), rendering it and returning the result to the user. It is interesting to note that Radiant directly manipulates the request and response objects, something that Rails developers almost never had to reach for in a regular app. On the other hand, I am exploring the use of serializing the templates to disk and simply calling render :template on it.

Wait a minute. Holy cow, we just built (a simplified) Rails on top of Rails!

What I’d love to see here instead is a Rails.new method just like Rubinius. Boom, a full blown MVC at your fingertips. Configure it right and there you have your very own CMS with minimal work. Or maybe there is. Lazyweb?

An update in a really long while

Fri, 02 May 2008 03:53:52 +0800

Woah, one month with no updates.

I started contracting for a startup in Seattle, WA since beginning of April and have been neglecting to update stuff. It’s pretty nice here plus I get to access things that people here take for granted like attending Seattle.rb hack nights, Pandora, Hulu and this weekend, Barcamp Portland!

See you guys in a bit.

http://dev.rubyonrails.org/ticket/11491

Tue, 01 Apr 2008 12:03:51 +0800

http://dev.rubyonrails.org/ticket/11491:

Finally, render :partial => some_collection will pick the right template based on each object in the collection. I can now retire my workaround:

<% some_collection.each do |item| %>
  <%= render :partial => item %>
<% end %>

Best part is that the partial_counter is maintained across the different partials.

Updating Counter Cache in Migrations

Sun, 30 Mar 2008 01:34:00 +0800

I’m nearly complete with an app I’ve been working on, so I thought I’d dedicate some time for optimization. One of the first things I did to my models was to add counter caches so that performing counts on my association were fast.

First try,

class AddCommentCounterCacheOnTopics < ActiveRecord::Migration
  def self.up
    add_column :topics, :comments_count, :integer, :default => 0
  end

  def self.down
    remove_column :topics, :comments_count
  end
end

Very standard. However, it initializes the column to 0, effectively “losing” all my comments (they’re there in the DB, but Rails adds an additional optimization whereby it won’t fetch the association if the counter cache is 0). Looks like I need to update the comments_count column to whatever it was at the time of migration.

Second try,

class AddCommentCounterCacheOnTopics < ActiveRecord::Migration
  def self.up
    add_column :topics, :comments_count, :integer, :default => 0

    Topic.find(:all).each do |t|
      t.comments_count = t.comments.count
      t.save!
    end
  end

  def self.down
    remove_column :topics, :comments_count
  end
end

Two things to note: First, I’m using the #count method in t.comments.count because calling #size will use the value in t.comment_count which is 0. #count on the other hand will perform a SQL count(). Second, this won’t work! Why? Because counter cache columns are set to attr_readonly.

To work around this, a little hack. Final result,

class AddCommentCounterCacheOnTopics < ActiveRecord::Migration
  def self.up
    add_column :topics, :comments_count, :integer, :default => 0

    def Topic.readonly_attributes; nil end # A little evil hack

    Topic.find(:all).each do |t|
      t.comments_count = t.comments.count
      t.save!
    end
  end

  def self.down
    remove_column :topics, :comments_count
  end
end

Excellent panel on scaling customer support. Definitely...

Mon, 24 Mar 2008 11:56:00 +0800

Excellent panel on scaling customer support. Definitely something to take into account whenever you think of launching a new product out there. Are you too caught up in the idea and the development, forgetting the most important ingredient of your success: the users?

My First Podcast Mention!

Thu, 20 Mar 2008 22:03:55 +0800

It’s the first time I’ve ever gotten mentioned in a podcast! It’s on Episode 023 of the Rails Envy Podcast for my blog post on using the Fire Eagle gem with Rails.

Download the episode and fast forward to 11:24 :)

Google Gears for Safari Soon?

Tue, 18 Mar 2008 22:40:20 +0800

Adds support for offline storage for Web applications in SQL databases ^link »
- from About the Safari 3.1 Update via sharedcopy.com

Jaws drop How it recovered from the guy kicking it and later...

Tue, 18 Mar 2008 09:07:49 +0800

Jaws drop How it recovered from the guy kicking it and later slipping on ice was freaking amazing! via SvN

#ruby-lang

Mon, 17 Mar 2008 17:07:00 +0800

ddfreyne: Somebody decided that the best way to let all tests pass... is to comment out the tests that fail
ddfreyne: ...
kamal_fariz: i'd go one further and mock rspec's expectation matcher to return true
ddfreyne: heh

via Paragon Adrift

Fri, 14 Mar 2008 11:29:57 +0800

via Paragon Adrift

Interfacing a Rails App to Fire Eagle Pt 1: Exploration via IRB

Tue, 11 Mar 2008 12:57:29 +0800

Here are my notes as I explore interfacing a Rails app to Fire Eagle. Tokens have been masked to protect the innocent :)

Create a new application.

Get the fireeagle gem.

MacBook-Pro:src kamal$ git clone git://github.com/kamal/fireeagle.git fireeagle
Initialized empty Git repository in /Users/kamal/src/fireeagle/.git/
remote: Generating pack...
remote: Done counting 377 objects.
remote: Deltifying 377 objects...
remote:  100% (377/377) done
remote: Total 377 (delta 192), reused 0 (delta 0)
Receiving objects: 100% (377/377), 75.91 KiB | 9 KiB/s, done.
Resolving deltas: 100% (192/192), done.
MacBook-Pro:src kamal$ cd fireeagle
MacBook-Pro:fireeagle(master) kamal$ rake install_gem
(in /Users/kamal/src/fireeagle)
sudo gem install --local pkg/*.gem
Successfully installed fireeagle-0.6.1
1 gem installed
Installing ri documentation for fireeagle-0.6.1...
Installing RDoc documentation for fireeagle-0.6.1...

Fire up irb and instantiate a client with the Consumer Key and Secret provided by Step 1.

MacBook-Pro:~ kamal$ irb
>> require 'fireeagle'
=> true
>> client = FireEagle::Client.new(
  :consumer_key    => 'AAAAAAAAAAAA',
  :consumer_secret => 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB')
=> #

Generate a Request Token and associate it with the user because we’ll need to locate who authenticated our app.

>> client.get_request_token
=> #
>> current_user.update_attributes!(
  :request_token        => client.request_token.token,
  :request_token_secret => client.request_token.secret)

Redirect the user to the Authorization URL.

>> client.authorization_url
=> "https://fireeagle.yahoo.net/oauth/authorize?oauth_token=mGxmGcGPNyjr"

After the user grants us permission, Fire Eagle will redirect the user’s browser to our Callback URL (defined in Step 1) with the same oauth_token params.
```
http://yourapp.example.com/your_call_back_path?oauth_token=mGxmGcGPNyjr
```

Find the User by the oauth_token and instantiate a new client (client2 in our IRB session) with the request token and secret.

>> user = User.find_by_request_token(params[:oauth_token])
>> client2 = FireEagle::Client.new(
  :consumer_key         => 'AAAAAAAAAAAA',
  :consumer_secret      => 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB',
  :request_token        => user.request_token,
  :request_token_secret => user.request_token_secret)

Convert the Request Token to a long-lived Access Token and save it. Optionally, you can nil out the Request Token because you are not going to need them anymore.

>> client2.convert_to_access_token
=> #
>> user.update_attributes!(
  :access_token         => client2.access_token.token,
  :access_token_secret  => client2.access_token.secret
  :request_token        => nil
  :request_token_secret => nil)

Go to town! From here on out, you can directly instantiate a client using the user’s Access Token to read or update their location.

>> client3 = FireEagle::Client.new(
  :consumer_key        => 'AAAAAAAAAAAA',
  :consumer_secret     => 'BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB',
  :access_token        => user.access_token,
  :access_token_secret => user.access_token_secret)
>> client3.update(:q => 'petaling jaya')
=> #
>> client.user.best_guess.name
=> "Petaling Jaya, Malaysia"

A lot of the stuff above can be extracted into a Rails plugin. First dibs on acts_as_hatchling!