Requirements

• Ruby 1.8.6 patch level 114+
• RubyGems 1.3.1+
• Rails 2.3.5
• GData Gem

Introduction

I’m sure your mind is positively buzzing with ideas for how to use Google App Engine, and a few of you might be Google Data AtomPub APIs. Quite of few of Google’s products expose a Google Data API, (a few interesting examples are YouTube, Google Calendar, and Blogger–you can find a complete list here) and these APIs can be used to read and edit the user-specific data they expose.

In this article we’ll use the Google Documents List Data API to walk through the process of requesting access from and retrieving data for a particular user. We’ll use Google App Engine’s webapp framework to generate the application pages, and the Users API to authenticate users with Google Accounts.

Google’s AuthSub APIs

Some Google Data services require authorization from your users to read data, and all Google Data services require their authorization before your app can write to these services on the user’s behalf. Google uses AuthSub to enable users to authorize your app to access specific services.

Using AuthSub, users type their password into a secure page at google.com, then are redirected back to your app. Your app receives a token allowing it to access the requested service until the user revokes the token through the Account Management page.

In this article, we’ll walk through the process of setting up the login link for the user, obtaining a session token to use for multiple requests to Google Data services, and storing the token in the datastore so that it can be reused for returning users.

Using the GData on Rails client library

Google offers a Data on Rails client library that simplifies token management and requesting data from specific Google Data APIs. In this article we’ll use this library, but of course you’re welcome to use whatever works best for your application. Download the Gdata on Rails client library.

To use this library with your Google App Engine application, simply install the library gem and require it as you usually would. There’s nothing more to it than that!

Installing the Google Data Ruby Utility Library

To obtain the library, you can either download the library source directly from project hosting or install the gem:

sudo gem install gdata

config/enviroment.rb

config.gem 'gdata', :lib => 'gdata'

config.ru

require 'appengine-rack'
require 'image'
require 'image-upload'
require 'user'
require 'gdata'
AppEngine::Rack.configure_app(
    :application => 'jruby-gdata',
    :precompilation_enabled => true,
    :sessions_enabled => true,
    :version => "1")

AppEngine::Rack.app.resource_files.exclude :rails_excludes
ENV['RAILS_ENV'] = AppEngine::Rack.environment

deferred_dispatcher = AppEngine::Rack::DeferredDispatcher.new(
    :require => File.expand_path('../config/environment', __FILE__),
    :dispatch => 'ActionController::Dispatcher')

map '/contacts' do
  use AppEngine::Rack::LoginRequired
  run deferred_dispatcher
end

map '/' do
  run deferred_dispatcher
end

Gemfile

# Critical default settings:
disable_system_gems
disable_rubygems
bundle_path '.gems/bundler_gems'

# List gems to bundle here:
gem 'rails_dm_datastore'
gem 'rails', "2.3.5"
gem 'appengine-apis'
gem 'gdata'

Step 1: Generating the Token Request Link (AuthSub)

Applications use an API called AuthSub to obtain a user’s permission for accessing protected Google Data feeds. The process is fairly simple. To request access from a user to a protected feed, your app will redirect the user to a secure page on google.com where the user can sign in to grant or deny access. Once doing so, the user is then redirected back to your app with the newly-granted token stored in the URL.

Your application needs to specify two things when using AuthSub: the common base URL for the feeds you want to access, and the redirect URL for your app, where the user will be sent after authorizing your application.

To generate the token request URL, we’ll use the GData::Auth::AuthSub module included in the Google Data client library. This module contains a method, get_url, which automatically generates the correct URL given the base feed URL(scope) and your website’s return address (next_url). In the code snippet below, we use this method to generate a URL requesting access to a user’s Google Document List feed.

In our routes.rb file, we will define a URL mapping to create a separate URL for each step. Here’s an example:

    map.connect 'step1', :controller => 'step1', :action => 'get'
    map.connect 'step2', :controller => 'step2', :action => 'get'
    map.connect 'step3', :controller => 'step3', :action => 'get'

To illustrate this first step of using AuthSub in the app, we will create a step1_countroller.rb that looks something like this:

class Step1Controller < ApplicationController

  def get
    scope = 'http://docs.google.com/feeds/'
    next_url = url_for :controller => self.controller_name, :action => self.action_name
    secure = false  # set secure = true for signed AuthSub requests
    session = true
    @authsub_link = GData::Auth::AuthSub.get_url(next_url, scope, secure, session)
  end
end

Step 2: Retrieving and Updating a Token

Once we’ve generated an authorization request URL for a particular Google Data service, we’ll need a way to use the token returned to our app to access the feed in question. Now, we need to retrieve the initial token returned to us for the Google Documents List API, and upgrade that token to a permanent session token. Remember that we told the service to redirect the user to the URL ‘http://jruby-gdata.appspot.com/step1′. Let’s extend our simple example above to do a few things. We’ll call this new version step2.

Let’s write the functionality that will handle the return request from the Google Data service the user signed in to. The Google Data service will request a URL that will look something like this:

http://jruby-gdata.appspot.com/?auth_sub_scopes=http%3A%2F%2Fdocs.google.com%2Ffeeds%2F&token=CKC5y...Mg

Which is just our return URL appended with the initial authorization token for the service which grants our app access for our user. The code below first takes this URL and extracts the service and the token. Then, it requests an upgrade for the token for the document list service.

We use two new methods to achieve this. First, we try to obtain the single use AuthSub token by examining the current page’s URL. The params[:token] function handles token extraction for us. To upgrade this initial token to a session token, we use client.auth_handler.upgrade().

require 'appengine-apis/users'

class Step2Controller < ApplicationController
  def get
    @client = GData::Client::DocList.new
    next_url = url_for :controller => self.controller_name, :action => self.action_name
    secure = false  # set secure = true for signed AuthSub requests
    sess = true
    @authsub_link = @client.authsub_url(next_url, secure, sess)

    if params[:token].nil? and session[:token].nil?
      @url = "nothing"
    elsif params[:token] and session[:token].nil?
      @client.authsub_token = params[:token] # extract the single-use token from the URL query params
      session[:token] = @client.auth_handler.upgrade()
    end

    @url1, @url_linktext = if AppEngine::Users.current_user
        [AppEngine::Users.create_logout_url(request.url), 'Sign Out']
      else
        [AppEngine::Users.create_login_url(request.url), 'Sign In']
      end

    @client.authsub_token = session[:token] if session[:token]

  end
end

After we upgrade the initial token using the client.auth_handler.upgrade() method. Below, we will take you through the steps to use this token and fetch your user’s feed in your application.

Step 3: Using a session token and fetching a data feed.

Now that we have obtained and stored the session token, we can use the AuthSub session token to retrieve the user’s document list feed with our application. The final step is to get the user feed from Google Docs and display it on our site!

Lets add a new method to our app to request the feed and handle a token required message. We will call this method fetch_feed and add it to the Fetcher request handler class. In this example, the app uses client.Get to try to read data from the feed.

Some Google Data feeds require authorization before they can be read. If our app had previously saved an AuthSub session token for the current user and the desired feed URL, then the token will be found automatically by the client object and used in the request. If we did not have a stored token for the combination of the current user and the desired feed, then we will attempt to fetch the feed anyway. If we receive a “token required” message from the server, then we will ask the user to authorize this app which will give our app a new AuthSub token.

Here is the code for the fetch_feed method:

def fetch_feed (client, feed_url)

  if feed_url.nil?
    'No feed_url was specified for the app to fetch.<br/>'
  else
      begin
        @feed = @client.get(feed_url).to_xml
        # If fetching fails
        rescue GData::Client::AuthorizationError
          @error = 'authorization error'
      end
  end
end

Now that we have a method to fetch the target feed, we can modify the Fetcher class’ get method to call this method after we upgrade and store the AuthSub token.

Our app also needs to know the URL which should be fetched, so we add a URL parameter to the incoming request to indicate which feed should be fetched. The below code for the get method adds the ability to find out which URL the app should fetch and fetches the desired feed.

require 'appengine-apis/users'
require 'appengine-apis/urlfetch'

class Step3Controller < ApplicationController

  def get
    @client = GData::Client::DocList.new
    next_url = url_for :controller => self.controller_name, :action => self.action_name
    secure = false  # set secure = true for signed AuthSub requests
    sess = true
    @authsub_link = @client.authsub_url(next_url, secure, sess)

    if params[:token].nil? and session[:token].nil?
      @url = "nothing"
    elsif params[:token] and session[:token].nil?
      @client.authsub_token = params[:token] # extract the single-use token from the URL query params
      session[:token] = @client.auth_handler.upgrade()
    end

    @url1, @url_linktext = if AppEngine::Users.current_user
        [AppEngine::Users.create_logout_url(request.url), 'Sign Out']
      else
        [AppEngine::Users.create_login_url(request.url), 'Sign In']
      end

    @client.authsub_token = session[:token] if session[:token]

    feed_url = params[:feed_url]

    if feed_url.nil?
      @sample_url = next_url + '?feed_url=http%3A%2F%2Fdocs.google.com%2Ffeeds%2Fdocuments%2Fprivate%2Ffull'

    end

    fetch_feed(@client,feed_url)

  end
end

In the above, we request the feed by calling fetch_feed(@client, feed_url).

You can see the final program at work by visiting: http://jruby-gdata.appspot.com/. Also, view the complete source code, where we put all of this together at the Google App Engine sample code project on Google Code Hosting.

The AuthSub session tokens are long lived, but they can be revoked by the user or by your application. At some point, a session token stored in your data store may become revoked so your application should handle cleanup of tokens which can no longer be used. The status of a token can be tested by querying the token info URL. You can read more about AuthSub token management in the AuthSub documentation. This feature is left as an exercise to the reader, have fun

Conclusion

Using the Google Data on Rails client library, you can easily manage your user’s Google Data feeds in your own Google App Engine application.

The Google Data on Rails client library includes support for almost all of the Google Data services. For further information, you can read the getting started guide for the library, visit the project to browse the source, and even ask questions on the ‘s Google group.

As always, for questions about Google App Engine, read Google’s online documentation and visit our google group.

Appendix: ClientLogin

This example uses AuthSub to authorize the app to act on the user’s behalf, but the Google Data APIs support other authorization mechanisms. In some cases, you might want to temporarily use ClientLogin while developing your application. If you are going to use ClientLogin, the Ruby library has a client class for each of the APIs and a Base class:

client = GData::Client::DocList.new
client.clientlogin('user@gmail.com', 'pa$$word')

client_login_handler = GData::Auth::ClientLogin.new('writely', :account_type => 'HOSTED')
token = client_login_handler.get_token('user@example.com', 'pa$$word', 'google-RailsArticleSample-v1')
client = GData::Client::Base.new(:auth_handler => client_login_handler)

You may receive a CAPTCHA challenge when requesting a ClientLogin token which you will need to handle in your app before you can receive a ClientLogin token. For this and a few other reasons, I don’t recommend using ClientLogin in Google App Engine, but the above is how you could use it while developing your app.

Resources

• Using Google Data Services – Google App Engine
• Retrieving Authenticated Google Data Feeds with Google App Engine with Python
• GData on Rails
• Using Ruby with the Google Data APIs – Google Data Protocol – Google Code

Here’s a list of what you’ll need to get started with the demo:

• a Google AppEngine account
• Ruby 1.8.6
• Rails 2.3.5
• Ruby on Rails AppEngine Gem

Instructions

The first steps that you’ll want to follow are from John Woodell’s Gist on Rails 2.3.5 on App Engine with DataMapper.

As you’ll notice, the last couple of steps generate a RESTful resource called Contact and also it’s associated DataMapper Model.

Adding REST

Now in order to add JSON to the mix, we’ll need a couple more things:

• JSON gem
• dm-serializer gem

We only have to make a few very small changes to the demo app that you got from the Gist to get JSON integrated. They’re listed below, and also at this Gist.

Gemfile changes: adding the json-jruby and dm-serializer to the gems for bundler

# Critical default settings:
disable_system_gems
disable_rubygems
bundle_path '.gems/bundler_gems'

# List gems to bundle here:
gem 'rails_dm_datastore'
gem 'rails', "2.3.5"
gem "json-jruby"
gem "dm-serializer"

config.ru changes: adding require ‘dm-serializer’ and ‘json’

require 'appengine-rack'
require 'cgi'
require 'json'
require 'dm-core'
require 'dm-serializer'

AppEngine::Rack.configure_app(
    :application => 'iphone-json',
    :precompilation_enabled => true,
    :sessions_enabled => true,
    :version => "1")

AppEngine::Rack.app.resource_files.exclude :rails_excludes
ENV['RAILS_ENV'] = AppEngine::Rack.environment

deferred_dispatcher = AppEngine::Rack::DeferredDispatcher.new(
     :require => File.expand_path('../config/environment', __FILE__),
     :dispatch => 'ActionController::Dispatcher', :isolate => true)

map '/admin' do
  use AppEngine::Rack::AdminRequired
  run deferred_dispatcher
end

map '/user' do
  use AppEngine::Rack::LoginRequired
  run deferred_dispatcher
end

map '/' do
  run deferred_dispatcher
end

and finally, the contacts_controller.rb needs the corresponding format.json render statements.

class ContactsController < ApplicationController
  # GET /contacts
  # GET /contacts.xml
  # GET /contacts.json
  def index
    @contacts = Contact.all

    respond_to do |format|
      format.html # index.html.erb
      format.xml  { render  ml => @contacts }
      format.json { render :json => @contacts }
    end
  end

  # GET /contacts/1
  # GET /contacts/1.xml
  # GET /contacts/1.json
  def show
    @contact = Contact.find(params[:id])

    respond_to do |format|
      format.html # show.html.erb
      format.xml  { render  ml => @contact }
      format.json { render :json => @contact }
    end
  end

  # GET /contacts/new
  # GET /contacts/new.xml
  # GET /contacts/new.json
  def new
    @contact = Contact.new

    respond_to do |format|
      format.html # new.html.erb
      format.xml  { render  ml => @contact }
      format.json { render :json => @contact }
    end
  end

  # GET /contacts/1/edit
  def edit
    @contact = Contact.find(params[:id])
  end

  # POST /contacts
  # POST /contacts.xml
  # POST /contacts.json
  def create
    @contact = Contact.new(params[:contact])

    respond_to do |format|
      if @contact.save
        flash[:notice] = 'Contact was successfully created.'
        format.html { redirect_to(@contact) }
        format.xml  { render  ml => @contact, :status => :created, :location => @contact }
        format.json { render :json => @contact, :status => :created, :location => @contact }
      else
        format.html { render :action => "new" }
        format.xml  { render  ml => @contact.errors, :status => :unprocessable_entity }
        format.json { render :json => @contact.errors, :status => :unprocessable_entity }
      end
    end
  end

  # PUT /contacts/1
  # PUT /contacts/1.xml
  # PUT /contacts/1.json
  def update
    @contact = Contact.find(params[:id])

    respond_to do |format|
      if @contact.update_attributes(params[:contact])
        flash[:notice] = 'Contact was successfully updated.'
        format.html { redirect_to(@contact) }
        format.xml  { head  k }
        format.json { head  k }
      else
        format.html { render :action => "edit" }
        format.xml  { render  ml => @contact.errors, :status => :unprocessable_entity }
        format.json { render :json => @contact.errors, :status => :unprocessable_entity }
      end
    end
  end

  # DELETE /contacts/1
  # DELETE /contacts/1.xml
  def destroy
    @contact = Contact.find(params[:id])
    @contact.destroy

    respond_to do |format|
      format.html { redirect_to(contacts_url) }
      format.xml  { head  k }
      format.json { head  k }
    end
  end
end

Final Notes

1. You may have noticed that by default you get RESTful XML when you generated the resource. It doesn’t work without the needed dm-serializer. Remember, we’re using DataMapper here and not ActiveResource. If you try, you’ll get this beautiful error.
   SEVERE: [1272067889120000] RuntimeError (Not all elements respond to to_xml)
2. If you inspect your DataMapper model, you’ll notice that every field is a required field. This is key for when you’re testing your POST method.
3. The last thing that is currently being looked into, is that the POST requires you to pass in the Class in lowercase for it to properly work. I’m not sure if this is a case-sensitive issue, or just purely needing to change the param to be “:Contact” instead of “:contact” in the controller.

Source Code

• The fully working demo can be found running on Google AppEngine at: iphone-json.appspot.com
• source is available on Github.
• And there is an accompanying iPhone REST client also available on Github. (Android client is currently in development.)

Alternatively, if you just want to quickly test your newly created JSON RESTful resource, you can use the REST Client for Firefox or REST Client for Google Chrome.

I learned quite a few lessons as a speaker about giving a better talk.

Internet Access

I didn’t run into any problems on Internet Access at Unconferenz, but I did make sure to ask the host if there would be Internet access provided. I also brought along a personal USB 3G Modem as a backup.

Power

Power actually could have been a problem. I currently use a MacBook Pro which about 2-3hrs of battery life. However, something to consider is the computer going to sleep mode while you’re in the middle of a presentation. Also, the power outlet may not be somewhere remotely close to how long your power cable reaches. For this, I carry both my power adapter and also a 10ft extension cable. You may also want to be a kind person and bring a multi-outlet mini surge protector so not to take the only one or 2 power outlet available.

Backup Plan

Always have a backup plan. The one thing that I did not have at all was a Mini-DisplayPort to VGA adapter for my laptop to connect to the projector. That was a bad thing. Luckily, someone at the conference did have one and I was able to borrow it. There was also a computer in the room that I could have used as another fallback as long as I had my presentation on a USB Key or uploaded somewhere like DropBox on the web.

Contact Info

I ran out of business cards. That was a bad thing. Always bring lots of those. I was lucky enough that some people had iPhones with the Bump app to swap contact info and also some who were willing to either give me theirs so I could contact them or just quickly add me to either Twitter or Gmail email address.

Double-Check Everything, Maybe Even Triple-Check

I had uploaded my slides ahead of time in case anyone wanted to download them. Unfortunately for me, I misspelled the file name and the link was dead. I quickly corrected the link and made sure to tweet it back out. That was very embarrassing to say the least. Make sure your stuff is set before you announce it.

Resources

• The Future of the Cloud by Simon Wardley
• 10 Kick Ass Presentation Techniques | Carsonified
• Presentation Zen: Simple Ideas on Presentation Design and Delivery – Garr Reynolds
• Presentation Zen Design: Simple Design Principles and Techniques to Enhance Your Presentations
  – Garr Reynolds

REWORK is a brilliant book. Check out the book’s website. The website contains videos and sample images of the contents.

Why You Should Read REWORK

The book is dirty cheap. It’s under $10 on the Amazon Kindle and just over $12 in hardcover on Amazon. It’s also an extremely short book coming in at just under 300 pages. I finished reading it less than 3 hours. All of the principles detailed in the book are brilliantly worded to the point that they’ll feel like common sense. The principles are also nice and short so that you can actually remember and apply them. Jason and David don’t throw a bunch of mumbo jumbo and useless buzz words.

This is a quick but very powerful read and definitely recommended for everyone. It’s not a book just for business owners, CEOs or the cubicle workers. REWORK is a book that everyone at every level should read.

What’s Next?

Head on over to the book’s website and check out the PDF excerpt for a sample or just go straight to Amazon and order the Kindle version or Hardcover version.

So What Does This All Mean?

For starters, It means that I’m going to be attempting to move all technical related posts (maybe just the future ones) to the Fresh Blocks Blog.

Secondly, I’m going to do monthly and yearly goals for both Fresh Blocks and myself. Of which, I will be using the blog to document my progress, successes and failures similar to John O’Nolan’s concept.

I plan on separating content into a few broader categories, such as following my Thoughts and my Learnings. I’ll likely keep this page more personal and the Fresh Blocks page more professional.

Hello World

It seems appropriate in a way to start anew. But as we all know, Google never forgets. Some of the things that I am looking to document will be highly related to personal development. Of course, it will also overlap with what Fresh Blocks does, simply because Fresh Blocks is a large part of my development.

I’m going to be going over goals and what was achieved, what was not and why not. I will also go into noting special blog posts from around the web that have in some way contributed to my personal development.

The Year That Was 2009

Last year brought a bunch of changes. In the beginning of the year, I started up a company called Fresh Blocks. It was created to transition my freelance work from my personal name to a more distinguishable brand. The creation of Fresh Blocks also allowed me to learn what it takes to run a business and be a freelancer. I quickly became involved in social media networks such as Twitter and Friendfeed to connect to others in the fields and learn from them.

Another by product of Fresh Blocks was getting into iPhone app development. This of course meant learning a complete new programming language (Objective C) and framework of Cocoa (Touch.) I signed up for a developer’s account and began reading through tons of Apple Documentation, Dave Mark’s Beginning iPhone SDK Development book, and following along with Stanford’s CS193P iTunesU iPhone Programming Course. I also joined various Google Groups, the iPhone Dev SDK forum and Apple’s own Beta forum. I quickly developed 2 internal iPhone apps and 1 that was rejected by Apple’s App Store due to being a purely self-marketing app. All in all, I learned a great deal and am still thoroughly excited about iPhone programming.

On the web design and development end of things, I got my feet wet with some jQuery, seeing as I haven’t done much Javascript since back in 1999, it was quite a breath of fresh air. I also got started with some frameworks such as 960.gs and BlueprintCSS. I started getting down to learning Ruby on Rails and Python. I also introduced myself to Git towards the middle of the year and been working on transitioning from SubVersion over to Git.

And quite possibly, the biggest accomplishment of last year, was my engagement. One that I’m quite proud of and very excited about.

The Books

The following is the list of books that I read as part of my personal development last year.

• The Principles of Successful Freelancing
• Good to Great
• Escape from Cubicle Nation: From Corporate Prisoner to Thriving Entrepreneur
• Web Standards Solutions: The Markup and Style Handbook (Pioneering Series)
• Bulletproof Web Design: Improving flexibility and protecting against worst-case scenarios with XHTML and CSS (2nd Edition)
• Don’t Make Me Think: A Common Sense Approach to Web Usability, 2nd Edition
• Beginning iPhone SDK Development
• The Principles of Beautiful Web Design
• Learning jQuery: Better Interaction Design and Web Development with Simple JavaScript Techniques
• Designing with Web Standards (2nd Edition)
• CSS Mastery: Advanced Web Standards Solutions
• iPhone SDK Development (The Pragmatic Programmers)
• Adobe Illustrator CS4 Classroom in a Book
• Free
• Unclutter Your Life in One Week
• The Complete Graphic Designer: A Guide to Understanding Graphics and Visual Communication
• A Designer’s Research Manual: Succeed in Design by Knowing Your Clients and What They Really Need

Where I Am Now

I’ve started my Mobile Programming course at Hawaii Pacific University. The course is centered around Google Android and iPhone OS programming. The class runs until the middle of May. I’ve also got an iPhone app I’ve been working on that I plan on finishing up and submitting it for an Apple Design Award. Hopefully winning one as well. I have a Magento project that I’m also working on.

I’m also in the process of re-arranging content and the overall design of this site. Primarily making it easier for future clients and employers to find information about me and at the same time documenting my personal development growth.

What’s on Deck for 2010

I currently have the following upcoming for the remainder of the year:

1. Getting deeper into Android Development
2. Starting up on iPad SDK Programming and releasing some Beta apps
3. Finishing up some iPhone apps and getting them published on the App Store
4. Getting back into Ruby on Rails and Python/Google App Engine
5. Learning more about ExpressionEngine 2.0
6. Finishing up a Magento eCommerce site client project

And I’m fairly sure I’ll come up with some more goals and such along the way.

It’s Official

I’ve started a web and mobile design/development company called Fresh Blocks. The focus is on creating either website design and web apps or iPhone and Android apps. I’ve been working under the name since earlier this year, and the the small site launched for the company.

The idea of Fresh Blocks came around during a moment of “Designer’s Block.” Where I was looking for fresh ideas to work with. Hence the name of the company being born. A lot of work went into making sure the name was viable as a brand. ThinkVitamin has a great article about choosing a name: What’s in a Name? What we’re trying to do is help individuals and businesses grow their online presence through the web and mobile web.

Here’s to new beginnings! Head on over and say hello to Fresh Blocks. Alternatively follow Fresh Blocks on Twitter or become a fan on Facebook.

Further Education

I’ve also registered as a Special Status Student at Hawaii Pacific University for the Mobile Application Development course. This course will be focusing on teaching both iPhone and Android Application Development. I’m looking forward to enhancing my knowledge of both the iPhone and Android SDK.

Hot off the trails of the news that Apress acquired the publishing rights to Kapsoft’s iPhone Application Sketch Book, comes the new iPhone Stencil.

In Detail

The new Apress Book is has been improved. A new cover. It’s now 1.5x scale (150% of actual size iPhone). Pages have been increased by 25 – that’s 50 more templates. And the pages have been perforated for easy tear out.

The Stencil is also 1.5x scale but includes a 1.0x scale iPhone should you need it. It is made of green plastic, much the same as most stencils you buy at a design store. It also features a nice little ruler on the side. Something extra that I had not anticipated, but find very handy. The stencil itself, features the majority of UIKit elements you will use in sketch design and comes in very handy. While, it is a bit on the larger end, it does fit nicely within the new sketchbook pages for carrying.

The Stencil will cost you $9.99 while the new Apress version of the Sketchbook comes in at $14.99.

Compared against Design Commission’s Stencil

While both stencils are larger scale than the actual iPhone size, the new Kapsoft one is a tad bit bigger. 1.5x the size of the iPhone. Design Comission’s stencil seems to be roughly 1.25x scale.

Kapsoft’s stencil is also cheaper in cost. $9.99 vs $17.95. Though, I’m sure that the material cost plays quite a role in this. Plastic against Stainless Steel.

I do find the Design Commission’s Stencil to be much more portable due to it’s smaller footprint. And the stainless steel material feels a bit more Apple-like and sturdier. Plastic can break easily.

Overall

You really can’t go wrong with either Stencil kit. And you definitely should be sketching designs before jumping into XCode. If you are planning to use the Apress Sketchbook, you’ll want to get the new Kapsoft Stencil due to the matching iPhone scale. Similarly, Design Commission offers both a downloadable PDF template and now a Sketchpad for $7.95 to go with their own Stencil Kit.

Gallery

The general questions were centered around: The importance of passion.

In the Boagworld podcast, there were quite a few thoughts and options to the questions since it was an interview with the Clearleft crew. So, you got the perspective of not only Paul Boag and Marcus Lillington from Headscape, but also Andy Budd and Jeremy Keith. The discussion centered mostly on how one finds the time to keep up with new trends, technologies, etc in the web design industry. The general consensus being that there’s a very blurry line between the work-life balance when it comes to this kind of thing. One of the important takeaways from listening to Andy talk about it, was that if it’s not making you all jumpy and gitty to want to know what’s changing, what the new hot trend is, or what new technologies are coming out, that it raises a red flag and you should really take a step back and re-evaluate if this is really your passion. Of course, you could just be burnt out. As Paul mentioned that he does the majority of his RSS feeds reading in bed on his own time, it’s important to remember, most of us would be doing this anyway because it’s what we love to do.

Although, not exactly the same question, the same topic was brought up in a different manner on the StackOverflow podcast. This time in regards to what technology to choose to learn for future profit. Specifically, the listener was not interested in coding in Objective-C for the rest of his life, yet concerned if Ruby on Rails would still be a viable way to make a living in the area he currently lives in. To this question, both Jeff Atwood and Joel Spolsky answered similarly with:

• “Joel and I concur: it probably doesn’t matter what language and toolchain you use, as long as it has a certain level of critical mass. What you should be more concerned about is the product you’re creating.
• If you’re happy with your current tool chain, then there’s no reason you need to switch. However, if you can’t list five things you hate about your favorite programming language, then I argue you don’t know it well enough yet to judge. It’s good to be aware of the alternatives, and have a healthy critical eye for whatever it is you’re using.
• Most programming languages don’t evolve particularly well over time. They’re usually replaced by other languages rather than new iterations of themselves. Why? What languages would you point to as the best example of growing and evolving in useful, relevant ways?”

While neither Joel or Jeff mentioned anything along the lines of picking something because it’ll make you a lot of money. I can’t imagine either of them would even come close to making any suggestion like that to anyone. Picking something just because it’s the new “money pot” or pot of gold at the end of the rainbow, is just asking for short term gain and potentially, long term unhappiness.

In the End

It’s my own opinion that you should not do or choose a path just because it has the potential to make you a lot of money if it doesn’t interest you at all. More so, if you have some inner hatred for Objective-C and think you should just suck it up and make something for the iPhone because it can net you a lot money. It’s not my recommendation, but do as you will.

What are your thoughts on Doing for the Money vs Doing for the Love?

The Art Pen

The Art Pen itself has a much bigger tip area than the Grip Pen that comes with the tablet. The Art Pen’s bigger tip area also doesn’t have the user swap-able color rings. One thing to note, the nibs do only fit in one way and they will rotate a bit during use. The nib won’t fall out, so you don’t have to worry about that when swapping nibs.

Even though the drivers for the Intuos4 are a bit old, they were able to successfully identify the Art Pen just fine from the start. Wacom just updated drivers for the new Bamboo Touch series, Graphire and Cintiq tablets for Windows and Mac OSX, but the Intuos set hasn’t been updated yet. As such, I still have to launch the 32-bit Settings for the tablet. Not a big deal.

After using the Art Pen with Corel Painter 11, I have noticed that I don’t have much of a tactile response from the pen during barrel rotation. As such, it’s really useful to have the Enhanced Brush Ghosting setting enabled while you get used to the feeling. It’s quite a bit different than the Grip Pen. After spending a bit of time getting used to it, I was able to turn off the ghosting setting again.

The Pen Stand

The Art Pen stand also has exactly enough slots for all of the Nibs that come with the Art Pen with one nib in the pen itself. It also fits the Professional Kit’s Nib Extractor in the middle spot of the stand just like the one that comes with the tablet and grip pen.

The Nibs

The Art Pen comes with 11 nibs. 1 on the pen itself and 10 replacement nibs. The 10 replacement nibs fit in nicely into the new housing of the Pen stand. The nibs have 1 shaft, just like the ones for all the other pens. This is a change from the Intuos3 Art Pen’s nibs which previously had 2 shafts. The difference being that the 2 shafts on the Intuos3 version, prevented a rotation effect on the nib when rotating the Art Pen.

The Details

The following come in the box:

• 2 Chisel POM Nibs
• 2 Chisel Felt Nibs
• 3 Bullet POM Nibs
• 3 Bullet Felt Nibs
• 1 Pen Stand
• 1 Art Pen with 1 Bullet POM Nib inside

Model #: KP701E
Price: $99.95

Final Thoughts

Although Wacom’s eStore states: “The Intuos4 Art Pen ships with the following accessories: 10 replacement nibs, a nib puller, and a weighted pen stand.” The package does NOT come with a nib puller. There was not one anywhere in the packaging and others from the ConceptArt forums have had the same results.

As for the Art Pen itself, I love it. Barrel rotation is definitely it’s main feature and it does it extremely well. It’s an amazing feature to have. Corel Painter 11 recognized the barrel rotation immediately, and it also works wonderfully with Illustrator using the 6D Art Brushes set or in Photoshop, by using the Wacom Brushes 3. All in all, it’s the one additional pen for the tablet that I need. I have very little use for the classic pen, airbrush pen or inking pen.

The Pictures

“I happened to be auditing the Stanford iPhone Programming course,” says Kaplan, “and one of the guest speakers discussed how he went about creating his user interface designs. Paper was one option he mentioned. Almost instantly the notebook idea light bulb went off. Other options of various computer programs were mentioned, but it always got back to paper and pencil. Subsequently, I did my own online survey that revealed designers prefer paper 95% of the time.” – theAppleBlog

The sketchbook contains 100 grid pages with an iPhone designed to scale on it. Each page has it’s own header that allows you to put in the name of the app and the name of the screen. The pages are big. There is ton of free space for taking side notes during group sessions and team meetings. The notebook itself is paperback, plastic spiral bound, and can be ordered from Amazon.com for $14.99.

Q & A with Dean Kaplan

1. What are your plans for the future of the sketchbook?
   “There will be a huge exciting announcement concerning the book next week. Stay tuned.”
2. Do you plan on creating a Stencil Kit similar to The Design Commission’s one? Or perhaps making the iPhone on the pages slightly larger to be more compatible with the Stencil Kit?
   “LOL. Are you spying on me? As for size….I guess you are saying size matters. And I’m listening to feedback and it is likely that you “might” see a version that is 1.5X actual very soon. (DC’s stencil is smaller then 1.5x and I don’t think its very useable. )”
3. Have you considered perforated pages for easier tear-off?
   “I’ve heard the perforated request once before. Not likely on that one. As one reviewer told me he like to tear the pages right out of the book and paste them on the frig.)”
4. A folder built-in either the front or back cover for keeping materials given from other team members or clients together?
   “I love that idea. It crossed my mind a few months ago. Likely in a future UBER Sketch Book.”

The Good

• Keeps all your apps and screens together instead of having multiple pieces of paper that can get easily lost.
• Grid pages are very handy for going from sketching to computer rendering.
• To scale iPhone keeps you in the restriction of the small space while also reminding you to beware of your font sizes.
• Cheap. $15! If you’re just getting into iPhone app design, this can definitely help you on your way in keeping your ideas organized.

The Bad

• Not compatible with The Design Commission has created an iPhone Stencil Kit. Different companies, Can’t really complain.
• The to scale iPhone on the page is also a bit harder to draw stuff inside it.
• Since there’s no stencil, you need to keep in mind what you get with the SDK and what needs to be custom made. Thought it’s not that big of a deal.

The Pictures

Final Thoughts

Right now, I’m using a Moleskine Squared Notebook to do my sketches for iPhone apps and other web related work. It’s much smaller than the iPhone sketchbook, but it does allow me to put other thoughts and ideas inside. For what the purpose it was designed for, the iPhone sketchbook delivers and does so very well. Compatibility with the Stencil Kit would definitely put it over the top. The last things that I would like included in the sketchbook, would be a small folder built in and perforated pages. Those are some very small personal requests though.

Special Note: If you order between September 10th and October 10th you’ll be entered to win ONE free ticket to the Voices That Matter iPhone Developers Conference 2009.