Fortunately, after much searching, I found there is an easy solution. You need to change the typesetter behavior of the NSTextView's underlying NSLayoutManager, since I don't believe there is a way to the change the typesetter behavior of the string drawing methods.

[[textView layoutManager] setTypesetterBehavior:NSTypesetterBehavior_10_2_WithCompatibility];

That's it and your text will render exactly the same. You should also do this if you're programmatically calculating the height of a text block before drawing, or you'll get one height for the calculation, but when you draw the text, it won't fit.

¹Apple's docs that mention this: http://developer.apple.com/mac/library/documentation/Cocoa/Conceptual/TextLayout/Tasks/DrawingStrings.html#//apple_ref/doc/uid/20001808-SW1

HTTP Client by Todd Ditchendorf (creator of Fluid) has quickly become an indispensable tool for me when writing code that interacts with RESTful API web services. For building the request, HTTP Client allows to you use any of the HTTP verbs (GET, POST, PUT, DELETE, etc) as well as setting custom headers, body, and use basic authentication. The response view will show you all the headers and the raw request body. If you're still using cURL, it's time for an upgrade.

Typically, the biggest problem with using APIs is poor documentation. Even when the request docs are pretty good, the response docs often fall short. Either they don't document the response at all, only document a portion of it, or only show it in one format. So my first step in implementing some API code is looking at the docs, and seeing how the request is formed. Twitter has a simple API, and pretty good documentation, so it's easy to figure out how to get the public timeline as JSON on this page http://apiwiki.twitter.com/Twitter-REST-API-Method%3A-statuses-public_timeline. The URL for this request is just "http://twitter.com/statuses/public_timeline.json" and the HTTP method is "GET".

The next step is firing up HTTP Client and making the request to see what it looks like (see screenshot to the right). Twitter is a simple case where you shouldn't have trouble, but for more complex APIs with a lot of options (like the Google Analytics API), it might take a bit of trial and error to get the exact data you're after. It's much quicker to iterate in HTTP Client to get your requests working right than to try to do so in code. This will allow you to get your request formatted correctly, and find any problems, like authentication errors or unexpected redirects, right away.

Once I have the correct request, the final step is to look at the structure of the response so I know how to parse it. I prefer to use JSON whenever possible, so it's mostly seeing what is an array, what is an object, and how things are nested. HTTP Client seems to do a pretty good job with syntax highlighting of XML and HTML responses that make them nice and readable, but unfortunately not with JSON. A quick solution is to copy the response, paste it into TextMate, set the document as JSON, and use JSON-> Reformat Document. (You'll need the JSON bundle to do that) That will give you a nice, readable view of the structure.

In the screenshot to the right, you can see the JSON response of the public Twitter timeline. By looking at the response, I can immediately see first off, that the main structure is an array. The elements of the array are status objects and each status object contains a user object. Without looking at the formatted response first, it might not be obvious that the user is a nested object of the status.

That's it. Now I know exactly how the request and response are formatted, and I can easily write the implementation code without any surprises. It seems like a bit of work, but it's all of 5 minutes when you're familiar with the process, and is much faster than trying to locate a bug in code that's really due to a malformed request or unexpected response structure.

Fortunately, this is really easy to accomplish with WordPress. Take a look at my archives page for an example. This list all the posts I've written from newest to oldest. Someone can instantly took a look and see if there is something they want to read.

To create an archives page, create a new "Page", and set the template to "Archives" (see image). This should appear automatically in the dropdown, if it doesn't, create an archives.php file in your current theme, and make sure there is a header like this:

<?php
/*
Template Name: Archives
*/
?>

Once you save that page, if you're using the default WordPress archives.php, it will list "Archives by Month" and "Archives by Subject". Edit the archives.php file, remove those sections, and add the following code:

<? $posts = get_posts('numberposts=-1');
  foreach ($posts as $post) :
     setup_postdata($post);
  ?>
    <div class="post" id="post-<?php the_ID(); ?>">
      <h2><a href="<?php the_permalink() ?>" rel="bookmark" title="Permalink to <?php the_title_attribute(); ?>"><?php the_title(); ?></a></h2>
      <p class="date_comments"><?php the_time('M j, Y'); ?> - <?php comments_number('0 Comments', '1 Comment', '% Comments', 'comments_count'); ?></p>
    </div>
<? endforeach; ?>

Of course, you'll want to adjust this for your own site as this formatting is specific to my site. Now you have a nice, useful page with all your posts clearly displayed. I'm a proponent of this view even if you have a couple hundred posts, I'd still like to be able to see everything in one shot.

¹ Of course I actually do care when it was written, especially if it's technology related. If it was written in 2001, it may be obsolete, but I'm not going to find content based on date.

Dropbox¹ is a service to sync files across multiple computers and to the cloud, and It's free to use with 2GB of storage. It makes it dead simple to keep files in sync and you can access those files from the web as well. All you have to do is store your TextMate specific files in your Dropbox account, and then point TextMate to use those files.

1. 1. Quit TextMate if you have it running

2. 2. Move the ~/Library/Application Support/TextMate folder to your Dropbox

3. 3. Open up Terminal and create a symbolic link from your ~/Dropbox/TextMate folder to your ~/Library/Application Support folder:

4. $ ln -s ~/Dropbox/TextMate ~/Library/Application\ Support/TextMate

5. 4. Repeat steps 1-3 on all the computers you want to sync.

Now any changes you make to your TextMate bundles on any computer will be synced across all your machines. For this to work transparently, you'll want to make sure Dropbox is running at login.

¹If you don't have a Dropbox account, sign up using this link and we both get extra storage space for free.

For example, if I'm reading an email that has links, I want to open them as I read it so I don't forget to look at them, but I don't want to have to switch applications mid-sentence just to open a url. This is even more prevalent when reading feeds. I use NetNewsWire for my RSS reader, but I don't use it to actually read the content. I like going to the site. I just use an RSS reader as means to get there more efficiently. So as I go through the links, if there is something interesting, I open the link. When I've gone through all the new items, I have everything open in tabs in Firefox. I find it too jarring to open a link, read it, go back to NNW, open a link, read it, etc. NNW handles this with ease by having a "Open links in background" preference. A simple one checkbox option that makes the experience all that more enjoyable and seamless for me.

So, to all developers out there, if your app involves people opening links, please provide this functionality. It's the attention to detail on these types of user interactions that really make or break an application. And so there's no excuse, here's an objective-c method to do it for you:

// Opens a URL in the default browser in background or foreground
- (void)openURL:(NSString *)url inBackground:(BOOL)background
{
  if (background)
  {
    NSArray* urls = [NSArray arrayWithObject:[NSURL URLWithString:url]];
    [[NSWorkspace sharedWorkspace] openURLs:urls withAppBundleIdentifier:nil options:NSWorkspaceLaunchWithoutActivation additionalEventParamDescriptor:nil launchIdentifiers:nil];    
  }
  else
  {
    [[NSWorkspace sharedWorkspace] openURL:[NSURL URLWithString:url]];
  }
}

12 lines of code and your app just became 10x more useful to me. While we're on links and usability. If your app does implement this functionality, make sure to provide some indication that the click actually worked or users will keep clicking the link all the while opening the same page a hundred times in their browser. NetNewsWire handles this by providing a subtle animation and changing the color of the text of the links you opened.

Here's an Objective-C method to retrieve the IP address of the wifi connection as a NSString.

Update (7/10/09): if this isn't working for you you may need to include the following C headers in the top of your class implementation as well

Note: this code will work with the Simulator as well though the interface may not be en0. The iPhone Simulator seems to just use the underlying active Mac OS X network interface. On my macbook pro using wifi, this is en1, but your mileage may vary.

This will also work in Mac OS X since the iPhone OS and Mac OS X both use a lot of the same unix underpinnings.

2.) Open the dmg, and drag the JSON folder into your project in Xcode. Check "Copy items into destination group's folder (if needed)" when prompted.

#import "JSON.h"

// Create SBJSON object to parse JSON
SBJSON *parser = [[SBJSON alloc] init];
	
// parse the JSON string into an object - assuming json_string is a NSString of JSON data
NSDictionary *object = [parser objectWithString:json_string error:nil];

// Create new SBJSON parser object
SBJSON *parser = [[SBJSON alloc] init];

// Prepare URL request to download statuses from Twitter
NSURLRequest *request = [NSURLRequest requestWithURL:[NSURL URLWithString:@"http://twitter.com/statuses/public_timeline.json"]];

// Perform request and get JSON back as a NSData object
NSData *response = [NSURLConnection sendSynchronousRequest:request returningResponse:nil error:nil];

// Get JSON as a NSString from NSData response
NSString *json_string = [[NSString alloc] initWithData:response encoding:NSUTF8StringEncoding];

// parse the JSON response into an object
// Here we're using NSArray since we're parsing an array of JSON status objects
NSArray *statuses = [parser objectWithString:json_string error:nil];

// Each element in statuses is a single status
// represented as a NSDictionary
for (NSDictionary *status in statuses)
{
  // You can retrieve individual values using objectForKey on the status NSDictionary
  // This will print the tweet and username to the console
  NSLog(@"%@ - %@", [status objectForKey:@"text"], [[status objectForKey:@"user"] objectForKey:@"screen_name"]);
}

Update (9/16/09): I just wrote a post about debugging API requests that might be helpful if you're having problems using this with another API - Debugging API requests with HTTP Client

user = User.find(1)
user.to_json
{"user" : {"name" : "John Doe", "id" : 1}}

This becomes a pain when you're pulling this data via AJAX and you're doing something like this:

def show
  user = User.find(params[:id])

  # to_json is called automatically so you don't need to call it explicitly
  render :json => {:status => 'ok', :user => user}
end

In your client side code, you then have to type user twice, once for the hash key, and once for the ActiveRecord model name, to get to the user's attributes:

$.getJSON(url, function(json){
  if(json.status == 'ok')
  {
     // do something with user data
     alert(json.user.user.name);
  }
});

Unnecessarily redundant and inconvenient. This seems to have been changed in Rails 2.1, but the old behavior can be restored by editing config/initializers/new_rails_default.rb and changing:

# Include Active Record class name as root for JSON serialized output.
ActiveRecord::Base.include_root_in_json = true

to

# Include Active Record class name as root for JSON serialized output.
ActiveRecord::Base.include_root_in_json = false

Restart your app, and you'll now get just the attributes for the model and not the model name.

Errno::EMLINK (Too many links - /usr/lib/ruby/1.8/fileutils.rb:243:in `mkdir'

This error was occurring when the system tried to make a new directory to store the uploaded images in. After researching (googling) the error, I find out that the Linux ext3 filesystem can only have a maximum of 32,000 links per inode which means a directory can only have 31,998 sub-directories. It just so happens that this particularly directory had exactly 31,998 directories in it.

When a user uploaded an image, multiple sizes were generated, and a directory was created to hold all the images for a particular item. The directory could never be created due to a filesystem error, so the upload was failing. To fix this problem, you can use a different filesystem without this limitation or I believe you can patch ext3 to support more inode links. But of course the easiest solution is partitioning your data, which is what I did. Fixing this problem required some relatively minor re-architecture of the app by partitioning the items into different sub-directories to avoid the ext3 limit.

You may not need the chmod 777, but I was getting a permission denied error before that. I don't know what negative effects this could have on your repository, so proceed at your own risk.