Logging on to gaming websites on a mobile browser can be painfully slow given most of them are full of ads, images, flash and videos. I wanted something fast and simple that would allow me to see upcoming and recent releases across a variety of popular platforms so I developed TooGame.

• You can view upcoming and recent releases within a 30 day span
• View YouTube videos, details, box art, and genres
• Reserve or purchase on Amazon using amazon’s mobile site

Check it out on the app store!

UPDATED: Fixed the permission issue on the download link

The current crop of tools

There are some excellent HTTP libraries available for the iPhone and OS X. So why do we need another one? Balance. There are two particularly popular libraries that I’m going to talk about: ASIHTTPRequest and ObjectiveResource. I’ll explain the benefits and tradeoffs of each and also explain where HTTPRiot fits in to this equation.

ASIHTTPRequest

ASIHTTPRequest is a highly flexible lower level tool (relative to HTTPRiot & ObjectiveResource). It can do a lot of things and do them well. Besides the basic GET, POST, PUT and DELETE you can also upload files, post form encoded data, handle basic authentication and a host of other really nice things. Not to mention it can handle synchronous and asynchronous requests–something HTTPRiot and ObjectiveResource can’t do. This library is all about flexibility and this flexibility doesn’t take away from how easy it is to use. This is code you should definitely have in your bag of tricks when you’re in need of an all purpose HTTP library.

The tradeoff for ASIHTTPRequest is that it can’t automatically convert XML and JSON. There is also no mechanism for setting default configuration options which results in you having to configure things like delegates and selectors for every asynchronous request. To be fair, ASIHTTPRequest was never meant to be used this way, thus I would take these tradeoffs with a grain of salt.

ObjectiveResource

If you’ve ever used ActiveResource with Rails you’ll probably be familiar with ObjectiveResource’s style. ObjectiveResources is a high-level library that does a lot of behind the scenes work. It’s built specifically to consume REST resources. It can convert to and from JSON and XML (ASIHTTPRequest can’t) and it will automatically initialize models and do all sorts of other work for you. This makes it a great fit for working in conjunction with a Rails app.

The tradeoff of ObjectiveResource is that it doesn’t handle XML and JSON that’s not produced by Rails well. I’m not sure what kind of results you’d get if you fed it something like Govtrack’s bill data. ObjectiveResource is also a big library with a lot of moving parts. In addition to the networking code, the library also includes ObjectiveSupport, a nice library in itself that’s loosely based on ActiveSupport.

One final thought about ObjectiveResource—there are a lot of methods added to NSObject. Apple doesn’t explicitly say not to do this, but they do warn you of the consequences:

“You can define categories that add methods to the root class, NSObject. Such methods are available to all instances and class objects that are linked into your code. Informal protocols—the basis for the Cocoa delegation mechanism—are declared as categories on NSObject. This wide exposure, however, has its dangers as well as its uses. The behavior you add to every object through a category on NSObject could have consequences that you might not be able to anticipate, leading to crashes, data corruption, or worse.”

With all that being said, ObjectiveResource is definitely worth checking out. I know a few people who are using it and love it.

HTTPRiot

Like ObjectiveResource, HTTPRiot was inspired by its Ruby counterpart: John Nunemaker’s httparty. Hence the name. HTTPRiot serves as a balance between ASIHTTPRequest and ObjectiveResource. You get a certain amount of flexibility and a higher level api. Like ASIHTTPRequest, you can send GET, POST, PUT, and DELETE requests, also like ObjectiveResource the XML or JSON response will automatically be converted to an Objective-C type (NSArray or NSDictionary).

The tradeoff with HTTPRiot is that it makes no attempt to convert the data further or automatically compose instances of other objects for you. It gives you the data and lets you do what you want with it. This means that you must be aware of the data you receive because it’s up to you to decide what to do with it after it’s been converted to a native type. For instance, if two request originate from the same model they will both use the same delegate methods to handle the response. It’s up to you to decide what’s what.

Some examples

Some quick examples to give you an idea of how you use HTTPRiot.

GET Request: Reads JSON from the server.

[Person getPath:@"/people" withOptions:nil object:nil];

POST Request: POSTs the body set in options to the server.

NSDictionary *options = [NSDictionary dictionaryWithObject:[foo JSONRepresentation] forKey:@"body"];
[HTTPRiotRestModel postPath:@"/person" withOptions:options error:nil];

Setting default options: You can subclass HRRestModel and set default options like basic auth, headers, params, etc. Every request you make from MyModel will use these default options.

@implementation MyModel
+(void) initialize {
    [self setBasicAuthWithUsername:@"justin" password:@"pass"];
    [self setDefaultHeaders:[NSDictionary dictionaryWithObject:@"Some Header Value" forKey:@"My-Header"]];
}
@end

Implementing the delegate methods

You’ll need to implement a few delegate methods to deal with the responses. I’ll explain why I settled on this approach in another post, but for now here is sample of what you’ll have:

- (void)restConnection:(NSURLConnection *)connection didReturnResource:(id)resource object:(id)object {
    //resource contains the NSDictionary or NSArray version of the XML or JSON you requested
    for(id item in resource) {
        //Do something with your data
    }
}

- (void)restConnection:(NSURLConnection *)connection didReceiveError:(NSError *)error response:(NSHTTPURLResponse *)response object:(id)object {
    //Recieved a bad status code 404, 500, etc.
}

Summing up

All three libraries have a job they are well suited for. Hopefully I’ve given you an idea of what to expect with each one. On a final note regarding HTTPRiot, it is a young library so there will <strike>likely</strike> be bugs along the way. If you spot one, cease development and report it to the proper authorities.

• HTTPRiot Website
• Online Documentation
• Source Code
• Report Bugs & Get Help

From the Net:SCP documentation:

”Net::SCP implements the SCP (Secure CoPy) client protocol, allowing Ruby programs to securely and programmatically transfer individual files or entire directory trees to and from remote servers. It provides support for multiple simultaneous SCP copies working in parallel over the same connection, as well as for synchronous, serial copies.”

The only thing we’re interested in is uploading, so lets get down to the code which I’ve packaged as a rake task.

REMOTE_DIR = "/home/caged/public/website.com/public"

desc 'Upload the site'
task :deploy do
  Net::SCP.start("hostname", "caged", :port => 3000) do |scp|
    scp.upload! 'site/index.html',  REMOTE_DIR
    scp.upload! 'site/stylesheets', REMOTE_DIR, :recursive => true
    scp.upload! 'site/images',      REMOTE_DIR, :recursive => true
    scp.upload! 'site/article',     REMOTE_DIR, :recursive => true
  end
end

Now lets take a look at the code. If you’re not using a public-key authentication, you’ll need to set :password in the start method. The upload! method is a synchronous (blocking) upload. If you’re uploading a lot of large files, you should consider using upload (no !) which will return immediately and continue processing your script while the upload is in progress. Finally, instead of specifying the name of every file inside a directory, you can set :recursive => true and Net::SCP will create the directory on the remote server and upload the files contained in it.

That’s it, the no-frills way to deploy a small static website.

The Post-Bush vs. Kerry Boom

• Reddit - Founded 2005
• Memeorandum & Techmeme - Founded September 12, 2005
• Digg - Launched December 5, 2004
• Youtube - Created February 2005
• Twitter - Officially launched October 2006

It’s been a whirlwind of a political season. In 2004, we might never have seen a hoard of angry Redditors opposing the bailout; We’d have to do some real digging to find a video of Jeremiah Wright saying “God Damn America”; We’d be hard pressed to find the speech that was the tipping point for “YES WE CAN” and the subsequent song and video inspired by that speech that went on to win an Emmy. We may have never been able to see Sarah Palin in the Alaskan Gubernatorial Debate in 2006. You can almost conclude that anything that has happened in the last four years of politics can be found online in some form or fashion if your Google skills are up to par.

Unlike today’s modern, up-to-the-minute websites, in 2004, old media websites such as CNN, MSNBC, Fox News were not so flattering.

CNN - Nov 5, 2004
Kudos to those who spotted Obama winning the Illinois Senate

MSNBC - Oct 27, 2004

FOX News - Oct 14, 2004

Pioneering the way. Open APIs and Open Source efforts

I must admit, when I started to research Open Source efforts in government, I was skeptical. I haven’t heard of much in passing, even given my rationale that tech news will always be accompanied by political news. But, I pressed on and I was soon exposed to a small, but extremely active and knowledgeable community of Open Source hackers and organizations committed to bringing transparency to our government.

Govtrack: The Granddaddy of them all

From my research, Govtrack is the data provider for an overwhelming majority of the websites I found. Govtrack describes itself:

An independent, non-partisan, non-commercial website launched in September 2004, GovTrack.us was the first website whose primary goal was to provide comprehensive legislative tracking for everyday citizens and was the first congressional transparency website to embrace Web 2.0 and principles of open data.

Earlier this year, Joshua Tauberer, the creator and primary maintainer of Govtrack decided to open source the Govtrack application.

Sunlight Foundation: The Incubator

Sunlight Foundation is the YCombinator of the open government movement (in spirit). They give small grants to help fund websites whose mission is to open government and provide transparency in some fashion.

A List of Resources

Open Data & APIs

• Govtrack Congressional Data [XML] - Everything from votes to the full text of speeches.
• Sunlight Labs API [XML, JSON] - A meta API that links candidates to external services such as Eventful, Govtrack, VoteSmart, etc. Also provides a short bio.
• Project Votesmart API [XML, JSON] - A wealth of information including votes grouped by issues, state, etc.
• Watchdog [N3, XML, JSON] - Recently started by Reddit’s Cofounder, Aaron Swartz, contains all types of information relative to a candidate such as Interest Group Alignment, Earmark data, and Money. This project can also be found on GitHub.
• Metavid US Legislative Footage API [RSS, XML] - A nice search API for public domain legislative videos. Find when John McCain mention’s “my friends” and when Barack Obama mentions “change”.
• Open Secrects [XML, JSON] - In depth tracking of campaign contributions.
• FEC Data [TXT, CSV, ZIP] - FTP access to all the data collected by the Federal Election Commission.
• Follow The Money [XML] - State-level campaign donor data.

Mailing Lists

• Govtrack developers list - Get help with Govtrack resources.
• Open House Project -A non-partisan group working to enhance public access to Congressional information.
• Open House Project -Dedicated to those who are parsing political data
• Watchdog Volunteers - Volunteer collaboration for watchdog.net

Other Resources

• Members of Congress who Twitter - Group effort to track congress on twitter fostered by the Sunlight Foundation
• oGosh Facebook Group - Open Government Open Source Hacking
• Public Markup - Review and comment on proposed bills before they are even introduced—or while they are pending—in Congress.

Burn Baby Burn

Unlike RubyCocoa, MacRuby is based on Ruby 1.9, powered by the YARV bytecode interpreter, resulting in significantly faster execution times. From the “Why MacRuby” page:

In MacRuby, all Ruby classes and objects are actually Objective-C classes and objects. There is no need to create costly proxies, convert objects and cache instances. A Ruby object can be toll-free casted at the C level as an Objective-C object, and the Ruby VM can also handle incoming Objective-C objects without conversion.

Also, the primitive Ruby classes, such as String, Array and Hash in MacRuby have been re-implemented on top of their Cocoa equivalents, respectively NSString, NSArray and NSDictionary. As an example, all strings in MacRuby are Cocoa strings, and can be passed to underlying C or Objective-C APIs that expect Cocoa strings without requiring a conversion. And it is possible to call any method of the String interface on any Cocoa string too.

That’s exciting news. MacRuby applications significantly outperform RubyCocoa applications and aim to enable the creation of full-fledged Mac OS X applications which do not sacrifice performance in order to enjoy the benefits of using Ruby.

Syntax

Considering String, Array, and Hash/Dictionary require no conversion, we get both the Ruby methods and the Objective-C methods without needing to cast back and forth.

#MacRuby
components = "foo/bar/baz".pathComponents

# RubyCocoa
components = "foo/bar/baz".to_ns.pathComponents
# or...
components = OSX::NSString.stringWithString("foo/bar/baz").pathComponents

#Objective-C
NSArray *components = [@"foo/bar/baz" pathComponents];
# or...
NSArray *components = [[NSString stringWithString:@"foo/bar/baz"] pathComponents];

And the biggest change is probably keyed arguments. I’ve grown to like keyed arguments in Objective-C because of their descriptive nature. Normally you can look at a method definition and determine what’s what.

def fetch_url(url, timeout)
  ...
end

However, unless you look up the method definition in the source or documentation, you don’t fully understand what the second argument encompasses during invocation.

obj.fetch_url("http://foo.com", 60)

This is where keyed arguments come into play. Take a look at how this method would be composed in Objective-C.

- (void)fetchURL:(NSURL *)url timeout:(float)theTimeout {
  ...
}

[obj fetchURL:[NSURL URLWithString:@"http://foo.com"] timeout:60.0];

And finally, we could write this method in MacRuby with the new keyed arguments syntax.

def fetch_url(url, timeout:timeout)
...
end

obj.fetch_url("http://foo.com", timeout:60.0)

We get the added benefit of clarity at the cost of verbosity. And finally, there is an additional nuance: CamelCase or under_score. I think I’ve settled with camelCase for now, because it’s not possible (practical ATM) to use underscored Objective-C methods, however, I’ve been told it’s being considered.

The Big Macs: macruby, macrake, macirb, macgem

Once you’ve set yourself up with MacRuby, you should know your programs are given a prefix of mac unless you specify a different prefix when compiling by hand. This means we’ll need to use macruby to invoke our Ruby scripts written for MacRuby.

In a completely convoluted example, lets grab the name of every application running on our machine; print it’s application name, and replace “Applications” in it’s path with “FOO”.

framework 'AppKit'

NSWorkspace.sharedWorkspace.launchedApplications.each do |app|
  appname  = app["NSApplicationName"]
  fullpath = app["NSApplicationPath"]
  puts appname
  puts fullpath.stringByReplacingOccurrencesOfString("Applications", withString:"FOO")
end

Save this file and run with macruby thisfile.rb. You should see a list of applications running and their paths, with FOO replacing Applications. Got it? Schweet!

framework is a new method of Kernel that allows you to import any framework, including your custom frameworks. In this example, we’re including the AppKit framework and iterating over the launched applications.

Gems: A ruby in the rough

At the time of writing this article, it’s not possible to use rubygems or macruby gems in the traditional require and run method. However, you can vendor your gems and include them directly which should work perfectly fine. This is a bug that will be addressed very soon.

Get Involved

MacRuby is an official effort by Apple to make Ruby a first class citizen in Cocoa. It’s still very early in development and you’re definitely encouraged to start playing with it, writing about it, and getting involved in the project. And one final note, you can join the very helpful #ruby-osx channel on freenode.net if you’re looking for assistance.

What is launchd?

According to the launchd guide on Apple’s website:

The launchd daemon takes over many tasks from cron, xinetd, mach_init, and init, which are UNIX programs that traditionally have handled system initialization, called systems scripts, run startup items, and generally prepared the system for the user

launchd stores tasks in plist format. You can find your agents in ~/Library/LaunchAgents. Here is a typical launcd file that will open iTunes every 60 seconds:

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
  <plist version="1.0">
  <dict>
    <key>Label</key>
    <string>com.alternateidea.article.test</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/open</string>
        <string>-b</string>
    <string>com.apple.iTunes</string>
    </array>
    <key>RunAtLoad</key>
    <false/>
    <key>StartInterval</key>
    <integer>60</integer>
  </dict>
  </plist>

Obviously this would be seriously annoying, but for the purpose of this demonstration, save this file as “com.alternateidea.article.test” in your ~/Library/LaunchAgents folder.

This script won’t run automatically, so we need to load it up first using the launchctl program:

launchctl load ~/Library/LaunchAgents/com.alternateidea.article.test.plist

Our agent is loaded up now. After 60 seconds, you should see iTunes.app open. Pretty nice, eh?

Ok, so we don’t want to keep running this agent. Lets unload it:

launchctl unload ~/Library/LaunchAgents/com.alternateidea.article.test.plist

Never gonna give you up. Never gonna automate your Mac.

So, here’s the trick: Wait until your coworker goes to lunch or you know they’ll be out of the office for 10 minutes or so. Then, let the mischief begin.

The first thing we need to do is create our agent:

  <?xml version="1.0" encoding="UTF-8"?>
  <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
  <plist version="1.0">
  <dict>
    <key>Label</key>
    <string>com.youtube.rickroll</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/bin/open</string>
        <string>-b</string>
            <string>com.apple.Safari</string>
            <string>http://www.youtube.com/watch?v=eBGIQ7ZuuiU</string>
    </array>
    <key>RunAtLoad</key>
    <false/>
    <key>StartInterval</key>
    <integer>1800</integer>
  </dict>
  </plist>

Everything should be pretty obvious in this plist. The StartInterval is in seconds. I want to be an asshole every 30 minutes (1800) seconds. If you want to be a bigger asshole (or Son of a Bitch) you could set this to run in shorter intervals.

Now, we need to save this and load it up on your coworkers computer. Save this to ~/Library/USERNAME/LaunchAgents/com.youtube.rickroll. And load it up:

  launchctl load ~/Library/LaunchAgents/com.youtube.rickroll.plist

If you want to test and make sure everything is in working order, you can run:

launchctl start com.youtube.rickroll

Question: Did you just Rick Roll yourself?

Now, if your test ran successfully slip back to your desk and wait in anticipation for that awesome intro.

Disclaimer: If you destroy your coworkers computer or end up scrapping in the street, I’m not responsible.