Another Big Change

On July 18th I will be leaving to move Plano, TX to move to Campbell, CA. While in California I will be working for Apple Inc. What this means for this blog and my writing is two things:

1. I might actually stand a chance of having some free time to write again.
2. That writing will no longer be of a technical nature, regardless of where it is posted.

This is a huge change for me, I've been in Texas (and more specifically the Dallas area) my entire life. I'm very exited to start my new job and see what the future holds. See you on the flip side.

Change of Pace

Well, it has been quite some time since I posted anything here. I have been quite busy since April, and I'd like to take an opportunity to cover some of what has happened since then.

First, however, I would like to state that I do intended to state posting more regular updates to this blog.

In June I accepted a position working on iOS development full-time for Rockfish Interactive. This was quite fulfilling and I enjoyed meeting and working with some very talented people. At the same time I also continued improving my skills on my own time and also working on some side projects.

In late September this effort paid off in a big way when I accepted an offer to go to work at Zarra Studios with Marcus and his team starting October 15th. Since that time I have been caught up in a whirlwind of working on amazing projects with amazing people and loving every minute of it.

Because of the fact that I now work for Marcus and Zarra Studios I am making changes around here. Effective immediately this blog will for the foreseeable future target personal posts and shorter technical posts. The longer articles I have been working on and any other technical content non-trivial length will now be worked up and posted to Cocoa Is My Girlfriend.

I realize that I don't have many followers, but I believe that posting future technical content to Cocoa Is My Girlfriend will serve both my limited audience and myself better than posting things here would.

Thanks for sticking around this long if you have. I look forward to getting out some new content in the near future.

Introducing Continuations for Objective-C

On February 5 Mike Ash wrote about continuations in Objective-C. I immediately liked the style of continuations (from Mike's article) based on two separate blocks, but I had the same concern as Mike: "obviously the annoyance of having to write adapters makes for a big hit to the niceness of using CPS for error handling."

In response I came up with a crude version of automated continuations for Objective-C. About one month, several email exchanges with Mike, and a lot of NSProxy usage later, I ended up with a new framework that handles several different styles of automatic continuations in Objective-C.

If you are interested in the technical details of what's going on behind the scenes please see my project on GitHub, especially the following files:

• Classes/JBBObjectProxy.h
• Classes/JBBObjectProxy.m
• Classes/Extensions/NSInvocation+JBBContinuations.h
• Classes/Extensions/NSInvocation+JBBContinuations.m
• Classes/Extensions/NSObject+JBBContinuation.h
• Classes/Extensions/NSObject+JBBContinuation.m

The key to making all of this work is ensuring that continuation blocks always recieve an object. To achieve this I pass objects straight through the proxy and wrap everything else in an NSValue (with type encoding specified).

If you call +[JBBObjectProxy getStoredInvocation] directly instead of using the WRAP_MSG_SEND() macro, the call must be from the same thread that messaged the proxy. If you need to invoke the NSInvocation on a separate thread you should still call +[JBBObjectProxy getStoredInvocation] on the original thread, then pass the returned NSInvocation instance to the other thread.

The following are basic samples demonstrating how to use JBBContinuations:

1. Do not use continuations (provided for comparison). (This sample on GitHub)

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       NSError *anError = nil;
       NSString *aString = nil;
       NSString *anotherString = nil;
   
       aString = [NSString
                  stringWithCString:"this is a test"
                           encoding:NSUTF8StringEncoding];
       NSLog(@"%@", aString);
   
       anotherString = [NSString
                        stringWithCString:"this is another test"
                                 encoding:NSUTF8StringEncoding];
       NSLog(@"%@", anotherString);
   
       if (![NSString
             stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                             encoding:NSUTF8StringEncoding
                                error:&anError]) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       } else {
           NSLog(@"no error occurred");
       }
   
       [localPool drain];
       return 0;
   }
   

2. Create an empty proxy; message it directly. The proxy automatically passes through return values. (This sample on GitHub)

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       NSError *anError = nil;
       NSString *aString = nil;
       NSString *anotherString = nil;
   
       aString = [[NSString jbb_proxy]
                  stringWithCString:"this is a test"
                           encoding:NSUTF8StringEncoding];
       NSLog(@"%@", aString);
   
       anotherString = [[NSString jbb_proxy]
                        stringWithCString:"this is another test"
                                 encoding:NSUTF8StringEncoding];
       NSLog(@"%@", anotherString);
   
       if (![[NSString jbb_proxy]
             stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                             encoding:NSUTF8StringEncoding
                                error:&anError]) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       } else {
           NSLog(@"no error occurred");
       }
   
       [localPool drain];
       return 0;
   }
   

3. Create an empty proxy; message it directly; use +[JBBObjectProxy getStoredInvocation]; invoke the NSInvocation with continuations and error handlers. Optionally you may use the WRAP_MSG_SEND() macro. (This sample on GitHub)

   #define WRAP_MSG_SEND(anObject, ...) \
           ([[anObject jbb_proxy] __VA_ARGS__], \
            [JBBObjectProxy getStoredInvocation])
   

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       [WRAP_MSG_SEND(NSString,
                stringWithCString:"this is a test"
                         encoding:NSUTF8StringEncoding)
        jbb_invokeWithContinuation:^(id anObject) {
           NSLog(@"%@", anObject);
       }];
   
       __block NSString *anOutsideObject = nil;
       [WRAP_MSG_SEND(NSString,
                 stringWithCString:"this is another test"
                          encoding:NSUTF8StringEncoding)
        jbb_invokeWithContinuation:^(id anObject) {
           anOutsideObject = [anObject retain];
       }];
       NSLog(@"%@", [anOutsideObject autorelease]);
   
       [WRAP_MSG_SEND(NSString,
          stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                          encoding:NSUTF8StringEncoding
                             error:nil)
        jbb_invokeWithContinuation:^(id anObject) {
           NSLog(@"no error occurred");
       }
                      errorHandler:^(NSError *anError) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       }];
   
       [localPool drain];
       return 0;
   }
   

4. Create an empty proxy; message it with continuations and error handlers attached. (This sample on GitHub)

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       [[NSString jbb_proxy]
         stringWithCString:"this is a test"
                  encoding:NSUTF8StringEncoding
              continuation:^(id anObject) {
           NSLog(@"%@", anObject);
       }];
   
       __block NSString *anOutsideObject = nil;
       [[NSString jbb_proxy]
        stringWithCString:"this is another test"
                 encoding:NSUTF8StringEncoding
             continuation:^(id anObject) {
           anOutsideObject = [anObject retain];
       }];
       NSLog(@"%@", [anOutsideObject autorelease]);
   
       [[NSString jbb_proxy]
        stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                        encoding:NSUTF8StringEncoding
                           error:nil
                    continuation:^(id anObject) {
           NSLog(@"no error occurred");
       }
                    errorHandler:^(NSError *anError) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       }];
   
       [localPool drain];
       return 0;
   }
   

5. Create a proxy with an associated continuation and error handler; message it directly. (This sample on GitHub)

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       [[NSString jbb_proxyWithContinuation:^(id anObject) {
           NSLog(@"%@", anObject);
       }] stringWithCString:"this is a test"
                   encoding:NSUTF8StringEncoding];
   
       __block NSString *anOutsideObject = nil;
       [[NSString jbb_proxyWithContinuation:^(id anObject) {
           anOutsideObject = [anObject retain];
       }] stringWithCString:"this is another test"
                   encoding:NSUTF8StringEncoding];
       NSLog(@"%@", [anOutsideObject autorelease]);
   
       [[NSString jbb_proxyWithContinuation:^(id anObject) {
           NSLog(@"no error occurred");
       }
                               errorHandler:^(NSError *anError) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       }] stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                          encoding:NSUTF8StringEncoding error:nil];
   
       [localPool drain];
       return 0;
   }
   

6. Create a proxy with an associated continuation and error handler; message it with overriding continuations and error handlers attached. (This sample on GitHub)

   #import <Cocoa/Cocoa.h>
   #import <JBBContinuations/JBBContinuations.h>
   
   int main(int argc, char *argv[]) {
       NSAutoreleasePool *localPool = [[NSAutoreleasePool alloc] init];
   
       id baseProxy = [NSString
                       jbb_proxyWithContinuation:^(id anObject) {
                          NSLog(@"base continuations");
                      }
                                    errorHandler:^(NSError *anError) {
                          NSLog(@"base errorHandler");
                      }];
   
       [baseProxy
        stringWithCString:"this is a test"
                 encoding:NSUTF8StringEncoding];
   
       [baseProxy
        stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                         encoding:NSUTF8StringEncoding error:nil];
   
       [baseProxy
        stringWithCString:"this is a test"
                 encoding:NSUTF8StringEncoding
             continuation:^(id anObject) {
           NSLog(@"%@", anObject);
       }];
   
       __block NSString *anOutsideObject = nil;
       [baseProxy
        stringWithCString:"this is another test"
                 encoding:NSUTF8StringEncoding
             continuation:^(id anObject) {
           anOutsideObject = [anObject retain];
       }];
       NSLog(@"%@", [anOutsideObject autorelease]);
   
       [baseProxy
        stringWithContentsOfFile:@"/tmp/completely_fake_file.txt"
                        encoding:NSUTF8StringEncoding error:nil
                    continuation:^(id anObject) {
           NSLog(@"no error occurred");
       }
                    errorHandler:^(NSError *anError) {
           if (anError) {
               NSLog(@"an error occurred: %@", anError);
           } else {
               NSLog(@"an error occurred");
           }
       }];
   
       [localPool drain];
       return 0;
   }
   

Style no. 2 is equivalent to a straight message send (except that it caches the invocation in case you ask for it later). No. 3 is the most like traditional Objective-C message sending without being dangerous. No. 5 is useful when you use the same continuations multiple times. Styles no. 4 and 6 are the most dangerous because the fake selectors are not known in any header files (the compiler assumes id is the return type), but their syntax is almost identical to straight message sends. For safety I ensure an id is returned (wrapping non-object values in NSValue); however, the compiler warnings from the unknown selectors render -Werror useless.

In less than two months, I created a system for automatically using continuations with Objective-C. This system is useable and works in Snow Leopard without modifications of any kind. It is also likely to work under Leopard or iPhone OS using PLBlocks.

10.6.2: CFBinaryHeap's CopyDescription Still Broken

So, 10.6.2 came out recently and unfortunately CFBinaryHeap is still broken. In CFBinaryHeap you can provide a callback .copyDescription in the struct you use to initialize things. When you then do a CFShow() or a CFCopyDescription() on the CFBinaryHeap instance it should automatically print its own info, and also the info for each item in the heap.

Unfortunately as of 10.6.2 CoreFoundation still has a problem in that the CFBinaryHeap is using "%s" to print the string even though it is a CFStringRef and not a char*.

Hopefully at some point this will get fixed since it would be nice to not have to manually iterate over a CFBinaryHeap to print it out. Thanks go to Dave Dribin for helping me track the problem down to CoreFoundation itself. A radar has been on file since shortly after 10.6.0.

Just a Quick Note

My blog will be moving here shortly from its current Tumblr location.