Damien DeVille

Stephen Wolfram on the .data domain for the Data Web

2012-01-10T00:00:00+00:00

Fascinating concept.

NSURLConnection setDelegateQueue is broken on iOS

2011-12-29T00:00:00+00:00

On Mac OS 10.7 and iOS 5.0, a very handy method has been added to NSURLConnection: setDelegateQueue:.

Using a URL connection in an NSOperation subclass has always been quite tedious because of the fact that one has to run a runloop for as long as the delegate callbacks have to happen. As suggested by Marcus Zarra in this StackOverflow answer, this has usually been achieved by calling CFRunLoopRun() when calling the start: method on NSURLConnection and CFRunLoopStop(CFRunLoopGetCurrent()) when the connection finishes loading or fails.

However, as my colleague Keith Duncan pointed out on CocoaBuilder, this is not optimal and should be avoided.

So, by creating an NSOperationQueue in your NSOperation subclass and scheduling the delegate callbacks into this queue, we do not need to run the current runloop for the length of the operation and consume a thread. In a nutshell, this is very handy and a much cleaner way to achieve this!

Here comes the problem: even though everything works perfectly fine on Lion, when performing the very same thing on iOS, the delegate callbacks are never called. It looks like the connection has to be started (and the delegate queue set) on the main queue for the delegate callbacks to happen. This obviously defeats the point of using it within an NSOperation subclass given that since Snow Leopard (and iOS 4.0) the start method of NSOperation will likely not be called on the main thread.

For this reason, in my opinion, the setDelegateQueue: method is unusable as per iOS 5.0 and should be avoided until Apple fixes this problem.

I have filed a bug at rdar://10529053 and you should dupe it if you observe the same behavior as I do.

I have created a small sample project to demonstrate the bug that I have attached to the radar. Feel free to run it on your side and see for yourself. You can download it from here.

MIME type to UTI and back again in Cocoa

2011-12-28T00:00:00+00:00

Often when working with web services in Cocoa, I need to convert between MIME type and Uniform Type Identifier (UTI).

I have seen many hacky way to do this but, in my opinion, following is the correct way to achieve it.

First let's import the appropriate framework based on the platform (you might also need to add the framework to your project if not previously done).

#if TARGET_OS_IPHONE
#import <MobileCoreServices/MobileCoreServices.h>
#else
#import <CoreServices/CoreServices.h>
#endif

To get the UTI from a MIME type.

NSURLResponse *response = ... // assume a URL response from somewhere else.
NSString *responseMIMEType = [response MIMEType];
CFStringRef MIMEType = (__bridge CFStringRef)[response MIMEType];
CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, MIMEType, NULL);
NSString *UTIString = (__bridge_transfer NSString *)UTI;

And to get the MIME type from the UTI.

NSString *filePath = ... // assume the path to a file from somewhere else.
CFStringRef fileExtension = (__bridge CFStringRef)[filePath pathExtension];
CFStringRef UTI = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, fileExtension, NULL);
CFStringRef MIMEType = UTTypeCopyPreferredTagWithClass(UTI, kUTTagClassMIMEType);
CFRelease(UTI);
NSString *MIMETypeString = (__bridge_transfer NSString *)MIMEType;

Sophiestication Apps on Sales

2011-12-22T00:00:00+00:00

All Sophiestication Software apps are $0.99 for the Christmas period.

I own all of them and am a big fan of Groceries and Articles for both iPhone and iPad in particular. Go check them out!

Updated Realmac Company Page

2011-12-20T00:00:00+00:00

Check out the updated company page at Realmac Software and our new avatars!

UCL Computer Science Short Courses

2011-12-06T00:00:00+00:00

The UCL Computer Science department has released a list of short courses for the summer of 2012.

The Time-Series Modelling one looks quite nice (and would remind me of the time when I used to be a student there actually!). I also like Popular Writing. Many of us can indeed very well write when targeting a technical audience but writing for the general public is definitely another story.

New Google+ for iOS icon

2011-12-06T00:00:00+00:00

Google+ for iOS. Keeping up with good design and inconsistencies.

Alfred app goes 1.0 on the Mac App Store

2011-12-06T00:00:00+00:00

Today, Alfred app version 1.0 has been released on the Mac App Store (it's actually been available to download from their website for a couple of days).

I love Alfred. I've never been a fan of Quicksilver or LaunchBar, always preferring the simpler Spotlight but Alfred seriously got me!

Also, if you feel like you want to give some money to the developers, make sure you check Alfred Powerpack. Plenty of awesome additions.

LLVM 3.0 Release Notes

2011-12-02T00:00:00+00:00

Check out the new goodies.

Birds vs Chickens

2011-12-01T00:00:00+00:00

This is getting seriously ridiculous.

Welcome to the New Way to Navigate Google

2011-11-30T00:00:00+00:00

Not sure I like it.

Analog Update on the Mac App Store

2011-11-01T00:00:00+00:00

The 1.01 version of Analog has just been approved this morning and is available on the Mac App Store. Update through the Mac App Store or if you didn't purchase it yet, go get it!

A Sister's Eulogy for Steve Jobs

2011-10-30T00:00:00+01:00

A very poignant article from Mona Simpson, Steve Jobs' sister. Such a touching story, extremely well narrated.

Recursive Blocks in Objective-C

2011-10-29T00:00:00+01:00

Blocks are an awesome feature added to Objective-C with Mac OS X 10.6 and iOS 4.0.

Most of the Cocoa API now includes block-based alternatives and some new APIs (like the AssetsLibrary framework for example) are only based on blocks. So you do not have a choice anymore, you have to use blocks.

One cool feature that you might run into is recursive blocks. Even if there is in fact no reason why a block could not be recursive, there are a couple of rules to follow. An example of a recursive block would be something like the following:

void (^blocky) ();
blocky = ^ void (){
    blocky();
};
blocky();

Note that this piece of code has a couple of problems, apart from the fact that it loops forever, but explaining them being the point of this post we will discuss them later (no spoilers!).

So why would we ever want to use a block recursively? Well, think about a common pattern in Cocoa, particularly in CocoaTouch. You have a UINavigationController on which you push instances of subclasses of UITableViewController in order to display some sort of tree structure of data. This structure will most likely be fetched from Core Data and resides in a single place in your application, probably in the root view controller of your navigation controller.

Now suppose that each of these instances of (subclasses of) UITableViewController has to perform a specific action when one of its cells is clicked. It could be modifying the cell, pushing a new UITableViewController on the navigation stack or even do nothing. Since, as we have seen, the whole data structures would be owned by a single object (the root view controller), you do not really want controller down the stack to have to decide what to do with this data. You would rather have the root view controller, that actually manages the data, react to events down the chain.

You could have a simple protocol in your UITableViewController subclass that the root view controller would conform to but you would end up with your logic for cell selection handling residing in two spots: in the table view cell selection callback in your root view controller and in the table view controller subclass delegate methods in this very same root view controller.

So why not having a block that handles the cell selection in the root view controller and passing this block down the stack. Once a cell down the navigation controller is clicked, the controller subclass simply invokes that block and the root view controller will perform anything it has to do at that stage.

So let's write some (pseudo)code. First, assume that we will use the same subclass of UITableViewController for any level of navigation down the stack. At the end, it probably will display the same kind of data so why create a custom subclass for each level of navigation. We will also have a simple class representing a data object to be displayed. Think about it as the data backing up the content of your cells. These objects are probably organized in an NSArray that itself resides in the root view controller. Each data object has a children array containing other data objects further down in the data hierarchy.

First the very elementary MyDataObject class:

@interface MyDataObject : NSObject

@property (strong) NSArray children;

@end

@implementation MyDataObject

@synthesize children = _children;

@end

Next, the UITableViewController subclass used to manage the table view used to display content down the navigation stack:

typedef void (^CellSelectionHandlerBlock)(MyDataObject clickedItem);

@interface MyTableViewControllerSubclass : UITableViewController

@property (strong) MyDataObject dataObject;
@property (copy) CellSelectionHandlerBlock selectionHandlerBlock;

@end

@implementation MyTableViewControllerSubclass

@synthesize dataObject = _dataObject;
@synthesize selectionHandlerBlock = _selectionHandlerBlock;

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    if (_selectionHandlerBlock != NULL)
    {
        MyDataObject *clickedDataObject = [[[self dataObject] children] objectAtIndex: [indexPath row]];
        _selectionHandlerBlock(clickedDataObject);
    }
}

// some other methods, in particular UITableView dataSource and delegate

@end

And finally the root view controller, itself a subclass of UITableViewController, that manages the table view used at the first level of hierarchy. It also manages the data objects and handle the cell selection in both its own table view and down the stack:

@interface MyRootTableViewController : UITableViewController

@property (strong) NSArray *dataObjects;

@end

@implementation MyRootTableViewController

@synthesize dataObjects = _dataObjects;

- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    CellSelectionHandlerBlock selectionHandlerBlock = nil;
    selectionHandlerBlock = ^ void (MyDataObject clickedItem) {
        if ([[clickedItem children] count] > 0)
        {
            MyTableViewControllerSubclass *viewController = [[MyTableViewControllerSubclass alloc] init];
            [viewController setDataObject: clickedItem];
            [viewController setSelectionHandlerBlock: selectionHandlerBlock]
            [[self navigationController] pushViewController: viewController animated: YES];
        }
        else
        {
            NSLog(@"Do some funky stuff with the cell!");
            // like presenting a modal view controller with some content.
        }
    }
    
    MyDataObject *dataObject = [[self dataObjects] objectAtIndex: [indexPath row]];
    selectionHandlerBlock(dataObject);
}

// some other methods, in particular UITableView dataSource and delegate

@end

So as you can see, we only need to write the selection handling code once. In function of the data object underlying the clicked cell, the root view controller create a new MyTableViewControllerSubclass with the appropriate data object and pass the selection handler block to it. Whenever a cell is clicked in a view controller down the stack, we first retrieve the data object corresponding to the clicked cell and invoke the block.

Also, every time a table view cell is clicked in the root view controller itself, the very same block is invoked.

However, this piece of code creating the block is wrong for two reasons that I am going to explain. As you can see, the block is recursively called inside the block itself. In order to explain the problems with the current approach, let's get back to our simpler blocky example.
In this example, a block is created and then called inside the content of the block creating infinite recursion. Leaving aside the infinite part here, this piece of code would crash on the first recursive call. To understand why, let's first discuss how a block treats its enclosing scope variables. Consider the following example:

int i = 1;
void (^block) () = ^ void () {
    NSLog(@"i = %i", i);
    i++;
};

This piece of code would correctly print i = 1 but would crash on the second line i++. The reason is that the block captures local variables in its scope and treat them as constant.
In the case of Objective-C objects, captured objects are retained (and automatically released when the block goes away).
Blocks are actually Objective-C objects themselves. When first created, a block lives on the stack. If you intend to use the block beyond the current scope, you need to copy it to the heap. Once the block has been copied to the heap, it can be retained and released as a regular object (it does not make sense to retain a stack-based block though).
In order for a block to change its enclosing scope, we can use the __block storage type. Consider the following example:

__block int i = 1;
void (^block) () = ^ void () {
    NSLog(@"i = %i", i);
    i++;
    NSLog(@"i = %i", i);
};

In this case, the program will run correctly and print i = 1 and i = 2. The block was able to modify the variable in its enclosing scope. Also note that __block captured objects are not retained.

So coming back to our blocky example, we now understands better why the crash is occurring. Since the block itself is invoked inside the block, it is const copied even before the assignment occurs. We can fix this by rewriting the program as:

__block void (^blocky) ();
blocky = ^ void (){
    blocky();
};
blocky();

Similarly, in our navigation controller example, we would have to rewrite:

__block CellSelectionHandlerBlock selectionHandlerBlock = nil;
selectionHandlerBlock = ^ void (MyDataObject clickedItem) {
    ...
}

So far so good, and to be honest, during my testing, I did not have to do anything else for this to run perfectly in Debug mode. However, the first time I ran it in Release mode, my program crashed on the block invocation. It took me a while to understand what was going on until I realized that there was a small problem here.
I was reusing my block outside the current scope and even copied it later on (when passed to another objects).
If you think about it, the first block that is assigned to the __block type variable is a stack-based block. The block that is called inside the block is this very same stack-based block.
When the block is moved to the heap, captured variable are moved to the heap too. So our block variable is moved to the heap once the block is copied so we need to make sure that the reference variable points to the copy of the block and not the original stack-based one.

The solution to this problem is to copy the block while creating it and assign this copied version to our __block variable:

__block void (^blocky) ();
blocky = [^ void (){
    blocky();
} copy];
blocky();

I have no idea why this was not crashing in Debug.

Blocks are very handy but are a tricky concept to grasp at first. However, there are a very powerful tool and I can only tell you that once you go block you never go bock (sorry, that was lame).

I definitely recommend the following articles and books to learn more:

Joachim Bengtsson - Programming with C Blocks
Bill Bumgarner - ^ Blocks Tips & Tricks
Mark Dalrymple - Advanced Mac OS X Programming chapter 3 "Blocks"

Moving to Jekyll

2011-10-28T00:00:00+01:00

I haven't had much time to blog about it since I made the switch but you might have noticed the new feel and look of my site!

I have moved away from WordPress for various reasons but mainly because I really did not like the idea of having my content living in a database. Also, I wanted to code the CSS myself and did not particularly want to go through the whole WP theme stuff.

So, the story in a nutshell, I am now generating a static version of this site with Jekyll. I write all the posts and bits in Markdown that I store as plain text files. I have written all the CSS using Sass (highly recommended by the way). I store my media files on Amazon S3 that I access with Amazon Cloud Front. I use TypeKit for serving and managing the fonts and the MathJax JavaScript display engine for rendering the mathematics formulae written with LaTeX. I am also using DISQUS for the comments on the posts.

I use quite a few new goodies of HTML 5 and CSS 3 so the site will render best on WebKit and fairly alright in Firefox. I checked that the site looked ok on the latest version of IE but I have no idea how it does on former versions. But frankly, I don't even give a rat's ass!

I am very happy with the look of the site on a desktop browser and Safari on the iPad (and I guess this applies to all tablet even though I haven't tested it). However, I still will have to write a mobile stylesheet for the iPhone (and other smartphones).

The very cool stuff is that I can now version control my entire website.

Norman's Dream Device

2011-10-27T00:00:00+01:00

Donald A. Norman in The Design of Everyday Things, 1988:

Would you like a pocket-size device that reminded you of each appointment and daily event? I would. I am waiting for the day when portable computers become small enough that I can keep one with me at all times. I will definitely put all my reminding burdens upon it. It has to be small. It has to be convenient to use. And it has to be relatively powerful, at least at today's standards. It has to have a full, standard typewriter keyboard and a reasonably large display. It needs good graphics, because that makes a tremendous difference in usability, and a lot of memory - a huge amount actually. And it should be easy to hook up to the telephone; I need to connect it to my home and laboratory computers. Of course, it should be relatively inexpensive.

What I ask for is not unreasonable. The technology I need is available today. It's just that the full package has never been put together, partly because the cost in today's world would be prohibitive. But it will exist in imperfect form in five years, possibly in perfect form in ten.

In my opinion, even if PDAs have existed for quite a long time, almost 30 years later, the first device that actually meets every criteria mentioned by Norman (apart from the cost maybe) is the iPhone.

Min Nya Fjällräven Kånken

2011-10-27T00:00:00+01:00

Yesterday I received my new laptop bag. I am really satisfied with it so I thought I would share my story.

Deciding on a bag is tricky. It's quite hard to find an item that matches your criteria for appearance, comfort and usability.

Since high school, I have been using a DJ bag form Manhattan Portage in black. It fits perfectly a 15'' laptop. I used it through most of university and have been quite happy with it. When I got my first 13'' MacBook, I logically got another bag from Manhattan Portage, a School Backpack that fits a 13'' laptop (and has a special compartment for it). I have been using this bag for a few years and absolutely loved it.

Last year, my girlfriend gave me a Swedish bag apparently quite trendy over there, a Fjällräven Kånken, the classic model in red. This bag is very fun, comfy and of very (very!) good quality (this was a second hand for I don't know which year but sincerely, I wouldn't know how to break the damn thing!). It fits a 13'' laptop quite alright, even if there is no special pocket for the laptop. I have used it for nearly a year and enjoyed it a lot. I also used it as my every day bag when my girlfriend and I went on a trip one month in Brazil last May and it's been a great companion!

However, when I got a 15'' MacBook Pro, I was not able to use it anymore so I had to get back to my DJ bag and outch! I forgot how uncomfortable a shoulder bag is versus a backpack. So I had to hunt for a new bag.

Tough times.. I couldn't decide on a model that I found attractive and that would take great care of my laptop (and my back). Until I realized that Fjällräven Kånken were not only doing the classic model but had recently released a 15'' laptop backpack. So I got one in black. It basically matches the appearance of the classic but is a bit bigger and also have a special back pocket for the laptop. You can thus use the front part of the bag as you would do with a normal bag but you have extra storage specially for your laptop against your back (the pocket actually matches perfectly the 15'' MackBook Pro so I guess they designed the bag with this laptop in mind). The back pocket is sensational; enough saying that it's the first time I dare putting my laptop into a bag without a sleeve (the laptop + the sleeve wouldn't fit in the back pocket anyway).

I highly recommend this bag. If you are interested, they also do the laptop backpack model for 13'' and 17'', just check their store.

My Thoughts About iMessage

2011-10-23T00:00:00+01:00

When iOS 5 came out, I logically turned on iMessage on both my iPhone and iPad. What I liked with iMessage was not being able to send free texts (I have 500 texts included in my plan for free and rarely use more than 50-100 a month so cost is definitely not in the equation here), but rather the idea of having my messages delivered (and stored) to all my devices seamlessly.

Well, at first, my iMessages were not delivered to both devices but only on the iPhone. We later discovered we had to set the callerID to the email rather than the phone number, that should work. Well, that solves the problem is someone iMessages me to my email address but if an iMessage is sent as a regular text to my phone number, I still only receive it on my iPhone.

The major problem so far, however, has been reliability. I don't seem to receive every message sent to me. Also, I often sent a message to a friend that seems to be routed via iMessage. The message seems to be sent, nothing comes back (the user might not have turned on the "Send Read Receipt" setting). However, 30 minutes later I receive an alert from my carrier (I am on pay-as-you-go hence the alerts) that a text has been sent. I go to my messages and discover that the message has been sent as Text Message. I'm ok with that, the only problem is that it took 30 minutes for my text to reach its destination without myself knowing about it. This is definitely a problem for me. I use text messages for fast communication with friends and I really expect any text I send to be received the second it leaves my device.

I have disabled iMessage for now. I will keep looking at it and I can wait to enable it back, but it seems not reliable enough at the moment.

Whale Trail

2011-10-22T00:00:00+01:00

With all the repetitive, low quality games hitting the App Store these days, I am very rarely surprised by a new one. Once on a while, however, a simple game comes out and blows my mind away. Whale Trail is one of these.

The concept of Whale Trail is nothing really innovative. You are some sort of a flying whale (!) and you fly up and down (in a similar fashion as Tiny Wing), trying to catch bubbles. Bubbles actually give you power and when you run out of power, well, you loose. There are also evil clouds that when you fly into electrocutes you and consequently diminish your power.

More than the concept, what really makes Whale Trail such an amazing game are the graphics and the music. Both are extremely well curated. UsTwo really took extreme care in creating both an ambient music and sound effects that completely enhance the game experience.

Go get it on the App Store!

My First Bit

2011-08-21T00:00:00+01:00

This is my first bit. I will blog in bits rather than posts whenever I have some short stories that I want to talk about that wouldn't fit in (a series of) tweets but wouldn't be long enough to become a proper blog post.

My Backup Solution

2011-08-11T00:00:00+01:00

I recently decided to have a serious look at my backup strategy.
For the past few years, I have simply been using a Time Machine hard disk that I have been trying to plug to my laptop at least daily. I have also been keeping my code in sync to GitHub as much as possible.

Given that my Time Machine hard disk is sitting on my desk, this backup solution is not very robust since in case of fire or theft (knock on wood!), I would not be protected at all. My code would surely be easily to get back from GitHub but I write way more code than I can host in my private repositories on GitHub. Thus, I decided to take a step forward and here is my current backup strategy:

Time Machine: I own a Western Digital 2TB hard drive which is partitioned into two 1TB parts, one of them being exclusively for Time Machine (I store mainly media on the second half). It supports Firewire 800 which makes Time Machine backups super fast with my Macbook Pro. I try to keep it plugged to the MBP as much as possible during the day but I make sure that it’s plugged at least once everyday, most of the time at night.
Dropbox: My main Documents folder is pretty much empty since I use Dropbox for my documents. All my work related stuff, old university coursework and notes, photos are also stored on Dropbox. Having multiple computers, I use Dropbox extensively and am very happy with it. I pay $9.99/month for 50GB and I seriously think it is a bargain given the quality of the service.
I have also set up a Library folder in my root folder where I store Application Support data for various applications that I want to access from multiple computers such as 1 Password, Things, Papers and MoneyWell.
Finally, I have a Code Collection folder where I store code samples I found around the Internet or small projects I have been messing around and that do not require a proper version control.
Amazon S3: I currently use Arq.app for uploading hourly backups of my drive to Amazon S3 storage. Arq is an excellent software and I’m extremely happy with it. It uploads in the background through an agent (Arg Agent) and is pretty fast. The backups are also encrypted which is a very neat feature.
I have opted for an Amazon S3 monthly budget of $5 which gives me 53.76GB of storage and seems to meet my space requirements. Also, Amazon recently made the data transfer-in free so there is no fee for uploading the backups to S3. Data transfer-out still costs a few cents per GB but this should rarely happen giving that the data is a backup. As you understood, the total monthly cost is mainly the storage.
It is recommended to backup the whole User directory but I preferred to pick the folders to backup manually. Note that I have an extensive Music folder (over 100GB) that for obvious reasons I do not backup to S3. It is however part of my Time Machine backup and I hope to be able to transfer it to the cloud soon once iTunes offers it. If it did not happen this fall, I might decide to back it up to S3 though.
The folders that I backup are thus as following:
- /Library/Application Support
- /Applications
- ~/Desktop
- ~/Documents
- ~/Dropbox
- ~/Library (excluding Caches and Logs)
- ~/Movies
- ~/Pictures/iPhoto Library
GitHub: I have a GitHub micro plan ($7/month) which allows me to keep up to 5 private repositories. My main projects are stored on GitHub. I have added the public keys associated to my various machines to GitHub which allows me to push and pull from any of my computers. I am extremely happy with GitHub since the first day I have started using it!
Gitosis on Linode: I have a Linode VPS that I use to store my websites, web services and messing around. I have setup a Git “server” with Gitosis and there I store any project that requires Version Control but not important enough to be a proper private repository on GitHub. Setting up Gitosis was a bit of a pain on the ass but now that it is up and working, I am quite satisfied. Similarly, I have uploaded the public keys of my various machines to be able to push and pull.

I am now fairly confident with my backups. I am easily able to revert changes locally with Time Machine or even from the cloud with Arq (both these backups are done hourly).
In case of hard disk failure or theft on my Macbook Pro, I can easily restore the whole disk from Time Machine.
In case my Time Machine hard disk is also corrupted, I can now restore my main files and configuration from Amazon S3 with Arq.
Every piece of code I write is also version controlled so reverting mistakes is trivial.

DDProgressView, a Custom Progress View

2011-03-21T00:00:00+00:00

I was quite bored of the classic blue UIProgressView provided in UIKit so I decided to write a custom progress view, very much inspired by the one used in the official Twitter for iPhone app.

It lets you specify the tint color of both the inner and outer parts of the control. You can use DDProgressView exactly as you would use a classic UIProgressView. In the future I might add support for different shapes too.

You can find the source code on Github.

Add Variables to an Existing Class in Obj-C

2011-03-14T00:00:00+00:00

Categories are a great way to add functionality to existing classes in Objective-C without extending them.

Say you want to add a method to MD5 hash a particular string. A Java way of doing this would be to create your own string class by subclassing NSString and add the hashMD5 method to it. With Objective-C, you don't have to subclass at all, you can simply write a category on NSString that declares the hashMD5 method. Then, you'll be able to call the hashMD5 method on any NSString instance, assuming you correctly imported the category header. Categories are very elegant and powerful, however there is a drawback with them: you cannot add instance variables! The interface/implementation of a category looks like following:

#import <Foundation/Foundation.h>

@interface NSString (StringAdditions)

@end


#import "NSString+StringAdditions.h"

@implementation NSString (StringAdditions)

@end

As you can see, there is no room for instance variables! So you think you'll maybe be able to add a property to it. You can indeed declare the property in the interface with

@property (nonatomic,retain) NSString *coolString ;

but if you try to synthesize it in the implementation, you will get an error "@synthesize not allowed in a category implementation". The problem is that @synthesize will create a getter and setter for us but by doing that, it will also have to create a instance variable of the same name where to store the value and get it from, hence the problem.

However, starting with Snow Leopard and iOS 3.1, the objective-C runtime adds Associated Object support. It might sound a bit of an obscure term but it literally adds some magic! From the Apple runtime documentation, it allows you to "Returns the value associated with a given object for a given key" and "Sets an associated value for a given object using a given key and association policy". Let see it with an example: assume you want to set a default string that your hashMD5 method would return in case it cannot compute the hash (not very pertinent example, sorry about that ;)). You would then define the retained defaultHash string property as following:

#import <Foundation/Foundation.h>

@interface NSString (StringAdditions)

@property (nonatomic,retain) NSString *defaultHash ;

- (void)printString ;

@end

As we've seen earlier, you won't be able to @synthesize this property in your implementation so let's write the getter and setter ourselves. You need to make sure that you correctly import the objective-c runtime header.

#import "NSString+StringAdditions.h"
#import <objc/runtime.h>

@implementation NSString (StringAdditions)

static char defaultHashKey ;

- (NSString *)defaultHash
{
    return objc_getAssociatedObject(self, &defaultHashKey) ;
}

- (void)setDefaultHash:(NSString *)aString
{
    objc_setAssociatedObject(self, &defaultHashKey, aString, OBJC_ASSOCIATION_RETAIN_NONATOMIC) ;
}

- (void)printString
{
    NSLog(@"the string is: %@", defaultHash) ;
}

@end

So, let's see what we've done here. We first declare a static char which address will act as the (constant) key to our variable. We then defined the getter defaultHash and setter setDefaultHash:. In the getter, we simply return the object associated with our object (in this case self which is an instance of NSString) and the address of the key. Similarly, in the setter we set the object associated with our object, the given key (again the constant address of the char we declared earlier) and the memory policy that will match what you declared in the property (in our case nonatomic and retain). If you have a look at the runtime header, you can see that the following is defined, allowing you to match every kind of memory policy you are used to use in you properties.

enum {
    OBJC_ASSOCIATION_ASSIGN = 0,
    OBJC_ASSOCIATION_RETAIN_NONATOMIC = 1,
    OBJC_ASSOCIATION_COPY_NONATOMIC = 3,
    OBJC_ASSOCIATION_RETAIN = 01401,
    OBJC_ASSOCIATION_COPY = 01403
};
typedef uintptr_t objc_AssociationPolicy;

If you now try to do the following in another class in you project

#import "NSString+StringAdditions.h"

- (void)test
{
    NSString *string = [NSString string] ;
    [string setDefaultHash: @"Ciao"] ;
    [string printString] ;
}

you should see the following printed in the console: the string is: Ciao. Magical!

As a bonus, here are the function declaration from the runtime header

OBJC_EXPORT void objc_setAssociatedObject(id object, void *key, id value, objc_AssociationPolicy policy)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_1);
OBJC_EXPORT id objc_getAssociatedObject(id object, void *key)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_1);
OBJC_EXPORT void objc_removeAssociatedObjects(id object)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_1);

Hope that helps ;)

Create an Encrypted ZIP File on Mac OS X

2011-02-11T00:00:00+00:00

I recently needed to password encrypt a ZIP file on my Mac. Most of the free GUI software (Stuffit, Unarchiver, etc..) can only unarchive and decrypt file but you have to purchase a premium version in order to encrypt a file. Fortunately, if you're ok with using the Terminal, Mac OS X already comes with an easy way to password encrypt a ZIP file. Simply type in a Terminal

zip -ejr [name_of_archive] [path_to_file]

where name_of_archive is the name that you want to give to your ZIP file and path_to_file is the complete path to the file or folder that you want to compress. You will then be asked for a password that will indeed be the password used to decrypt the archive. In the ejr options, e stands for encrypt, j for junk-paths (do not store directory names) and r for recursive-paths (travel the directory structure recursively).

Creating Shared Instances of Non Thread-Safe Classes

2011-02-03T00:00:00+00:00

Often, when coding, you find yourself allocating the very same object again and again. A common use in order to avoid wasting resources is to store a static reference to a single instance of this class and keep returning it when needed. A classic example is NSDateFormatter. Assume you have a UITableView displaying a date in each UITableViewCell in a particular format. You might have the date stored in a database but you will need an instance of NSDateFormatter to be able to transform it into a string the way you intend. Obviously, creating an instance of NSDateFormatter with the same NSLocale and format for each cell of your UITableView is wasting resources and memory. This is the reason why many programmers use the following sort of method

+ (NSDateFormatter *)dateFormatter
{
    static NSDateFormatter *dateFormatter = nil ;
    if (dateFormatter == nil)
    {
        dateFormatter = [[NSDateFormatter alloc] init] ;
        [dateFormatter setLocale: [[[NSLocale alloc] initWithLocaleIdentifier: @"en_GB"] autorelease]] ;
        [dateFormatter setDateFormat: @"YYYY-MM-dd HH:mm:ss ZZZ"] ;
    }
    return dateFormatter ;
}

This way, whenever you need an instance of NSDateFormatter, call

NSDateFormatter *dateFormatter = [[self class] dateFormatter] ;

to get a reference to the shared NSDateFormatter.

The problem with this method is that NSDateFormatter is not thread-safe. This means that if you happen to call this method from different threads, you might get unexpected behaviors. Obviously, you are not left with creating single instances for every time you need one, there is an easy way to create an instance for every thread you call this method from. This way, you won't have to create as many objects as the number of times you call the method but simply as many objects as the number of different threads your are calling the method from. To achieve this, we use a cool feature in NSThread:

- (NSMutableDictionary *)threadDictionary

The thread dictionary is a classic dictionary where you can store thread-specific data. Any thread has got its own dictionary and anyone is free to store any interesting data. We can thus rewrite our shared NSDateFormatter as following:

+ (NSDateFormatter *)currentDateFormatter
{
    NSMutableDictionary *threadDictionary = [[NSThread currentThread] threadDictionary] ;
    NSDateFormatter *dateFormatter = [threadDictionary objectForKey: @"DDMyDateFormatter"] ;
    if (dateFormatter == nil)
    {
        dateFormatter = [[NSDateFormatter alloc] init] ;
        [dateFormatter setLocale: [[[NSLocale alloc] initWithLocaleIdentifier: @"en_GB"] autorelease]] ;
        [dateFormatter setDateFormat: @"YYYY-MM-dd HH:mm:ss ZZZ"] ;
        [threadDictionary setObject: dateFormatter forKey: @"DDMyDateFormatter"] ;
    }
    return dateFormatter ;
}

Let's go through this method. We first get a reference to the current thread dictionary. We then check whether we previously store an instance of NSDateFormatter with a specific key. In case we did, we simply return it. If it is the first time we access this method from this thread, the dictionary won't have any NSDateFormatter object stored for the key and we will simply create one and store it in the dictionary before returning it. Easy!

PS: For the same reason, I also have to implement this method for NSCalendar.

A Cocoa App for Resizing Retina Images

2011-02-02T00:00:00+00:00

I have added a small Cocoa app call DDRetinaResize to my retina extensions project on GitHub.

The app is nothing special, it simply takes a folder containing images scaled and named for the retina display as input and populate a destination folder with scaled-down and renamed images.

Assume you have a folder filled with images named xxx@2x.png or yyy@2x.jpg and scaled for the retina display (so twice the size of the original image). The app will remove the @2x extension to all images and scale them down half. It will then copy the newly created images to your destination folder.

Again, this is nothing special and the code is far from being nice, but hey, I had a folder of 500 retina images to resize and rename and it only took me 2 seconds ;)

The project is on GitHub here.

Find All Emails in iPhone Address Book

2011-01-30T00:00:00+00:00

For a project I am currently working on, I had to retrieve all the emails from the user's iPhone address book. The purpose was to later check against the web service database and find whether some of the user's friends already were using the app. Diving into the AddressBook framework is pretty trivial but since it is all C-based, it can feel unfamiliar to coder mainly used to the Objective-C syntax.

Following is the code I wrote in order to achieve the previously described. Note that this code does not check for errors throughout the execution. It is only written in order to roughly describe the method but some checks would definitely have to be added.

// we will finally store the emails in an array so we create it here
NSMutableArray *emails = [NSMutableArray array] ;
        
// get the address book
ABAddressBookRef addressBook = ABAddressBookCreate() ;
        
// get an array of all the persons (records) in this address book
CFArrayRef addressBookRecords = ABAddressBookCopyArrayOfAllPeople(addressBook) ;
        
// loop through the address book records
for (int i = 0 ; i < CFArrayGetCount(addressBookRecords) ; i++)
{
    // get a single person as a record
    ABRecordRef person = CFArrayGetValueAtIndex(addressBookPersons, i) ;
    // get all email associated with this person
    ABMultiValueRef emailProperty = ABRecordCopyValue(person, kABPersonEmailProperty) ;
    // convert it to an array
    CFArrayRef allEmails = ABMultiValueCopyArrayOfAllValues(emailProperty) ;
    // add these emails to our initial array
    [emails addObjectsFromArray: (NSArray *)allEmails] ;
    // release memory
    CFRelease(allEmails) ;
    CFRelease(emailProperty) ;
}

// release memory
CFRelease(addressBook) ;
CFRelease(addressBookRecords) ;

// print the elements in the array to check everything worked fine     
for (NSString *email in emails)
{
    NSLog(@"%@", email) ;
}

Also, make sure you import the Address Book framework by inserting the following line at the top of your header. You will also need to manually add the framework to your project.

#import <AddressBook/AddressBook.h>

A Mandelbrot Set Visualization on the iPhone

2011-01-30T00:00:00+00:00

A colleague of mind was reading a book about Mandelbrot lately and that reminded me of a coursework I was given at UCL in my introductory course to Java. The purpose was to draw a visualization of the Mandelbrot set in Java. I looked back through my university folder on my Mac to find the coursework. Well, my first impression was: you can write pretty ugly code while a student ;). But then while reading through my code I thought it would be quite funny to try to re-implement that on the iPhone. Obviously, given the dozens of fractal apps already available on the App Store this would never become an app but it was a funny one so I gave it a go.

In a nutshell, the Mandelbrot set is a mathematical set of points in the complex plane (the complex plane being a geometric representation of complex numbers on a real and imaginary axis). A complex number c belongs to the Mandelbrot set if the orbit of 0 under iteration of the complex quadratic iteration $Z_{n+1} = Z_{n}^{2} + c$ remains bounded. So assuming we have a complex number c with real part x and imaginary part y such that $c = x + iy$, we can conclude that it belongs to the Mandelbrot set if given the following iteration: $$Z_{0} = c$$ $$Z_{n+1} = Z_{n}^{2} + c$$ Z never escapes to infinity. It has been shown that if the magnitude of Z ever becomes greater than 2, it will eventually escapes to infinity. We thus simply have to compute the magnitude of Z for a large number of iterations and check whether it goes beyond 2 to conclude it does not belong to the set. Before going any further, we have to define two properties of complex numbers: how to multiply two complex numbers and how to compute the magnitude of a complex number. Assuming we have two complex numbers defined by $$c_{1} = a + ib$$ $$c_{2} = c + id$$ their product is then given by $$c_{1}c_{2} = (ac-bd) + (bc+ad)i$$

Thus taking the square of $c_{1}$ would result in $$c_{1}^{2} = (a^{2}-b^{2}) + 2abi$$

The magnitude (or absolute value) of a complex number c is defined as $$|c| = \sqrt{a^{2}+b^{2}}$$

Given these 2 definitions, we now simply have to check whether the magnitude for each step of the complex quadratic iteration exceeds 2 (to avoid computing a square root, we can simply check whether the sum of the squares of both real and imaginary parts exceeds 4).

The C function written to check that is the following

BOOL isInMandelbrotSet(float re, float im)
{
    float x = 0 ;  float nx ;
    float y = 0 ;  float ny ;
    bool fl = TRUE ;
    for(int i = 0 ; i < MANDELBROT_STEPS ; i++)
    {
        // We calculate the real part of the sequence
        nx = x*x - y*y + re ;
        // We calculate the imaginary part of the sequence
        ny = 2*x*y + im ;
        // We compute the magnitude at each step
        // We check if it's greater than 2
        if((nx*nx + ny*ny) > 4)
        {
            fl = FALSE ;
            break ;
        }
        x = nx ;
        y = ny ;
    }
    
    return fl ;
}

The number of steps is arbitrary but we can obtain accurate results by only taking 50 steps.

We then have to compute the previous check for each pixel on the frame. In order to get faster computation, I decided to create a bitmap context, draw the Mandelbrot set offscreen and simply create an image from the bitmap context and draw it to the current context in the drawRect: method.

We first need to create a bitmap context by calling the following method

- (CGContextRef)createCustomBitmapContextWithSize:(CGSize)size
{
    CGContextRef context = NULL ;
    
    int bitmapBytesPerRow = (size.width * 4) ;
    bitmapBytesPerRow += (16 - bitmapBytesPerRow%16)%16 ;
    
    size_t bitmapByteCount = (bitmapBytesPerRow * size.height) ;
    
    CGColorSpaceRef colorSpace = CGColorSpaceCreateDeviceRGB() ;
    
    void *bitmapData = malloc(bitmapByteCount) ;
    
    if (bitmapData == NULL)
    {
        fprintf (stderr, "Memory not allocated!") ;
        return NULL ;
    }
    
    context = CGBitmapContextCreate(bitmapData, size.width, size.height, 8, bitmapBytesPerRow, colorSpace, kCGImageAlphaPremultipliedLast) ;
    
    if (context == NULL)
    {
        free (bitmapData) ;
        bitmapData = NULL ;
        fprintf (stderr, "Context not created!") ;
        return NULL ;
    }
    
    CGColorSpaceRelease(colorSpace) ;
    
    return context ;
}

The drawing method is then given by the following

- (void)drawMandelbrot:(CGPoint)center andZoom:(CGFloat)zoom
{
    CGContextSetAllowsAntialiasing(bitmapContext, FALSE) ;
    
    CGContextSetRGBFillColor(bitmapContext, 0.0f, 0.0f, 0.0f, 1.0f) ;
    
    CGFloat re ;
    CGFloat im ;
    
    // mapping the bounding box to pixels
    
    /*
       zoom 1 has to be between -2 to 1 and -1 to 1
       any additional zoom divides these by the zoom
    */
    
    // loop through every pixel of the frame...
    for (int i = 0 ; i < 480 ; i++)
    {
        for (int j = 0 ; j < 320 ; j++)
        {
            re = (((CGFloat)i - 1.33f * center.x)/160) ;   // -2 to 1 -   screen width  = 480
            im = (((CGFloat)j - 1.00f * center.y)/160) ;   // -1 to 1 -   screen height = 320
            
            re /= zoom ;
            im /= zoom ;
            
            if (isInMandelbrotSet(re, im))
            {
                CGContextFillRect (bitmapContext, CGRectMake(i, j, 1.0f, 1.0f)) ;
            }
        }
    }
}

I did not have time (or interest..) for implementing various zoom level so we simply draw at the most basic zoom (in the bounding box -2 to 1 on the real axis and -1 to 1 on the imaginary axis).

The result is quite nice. Again, I did not have much time to implement different colors but it should be trivial to add this feature (the color basically depends on how many steps it takes for the magnitude of Z in the iteration to exceed 2).

By running the drawing code on my iPhone 4 with 50 Mandelbrot steps per pixel, I achieve the following timing (in seconds):

bitmap context creation duration = 0.105825
drawing Mandelbrot in bitmap duration = 0.684840
draw rect duration = 0.107269

This could obviously be improved but for the purpose of the experiment (fun!) I'm quite happy with it!

I have uploaded the project to GitHub so give it a go and have fun ;).

Getting the Interface Orientation in iOS

2011-01-27T00:00:00+00:00

One feature that annoys me while developing for the iPad is that no matter how much I take care of coding device orientation correctly, I know that eventually the client will use the device faced-up on his desk while in landscape and come back to me: "the orientation is messed up and displays in portrait while in landscape". (NB: this is also true while coding for the iPhone but you do not really focus that much on multiple orientations)

The reason is that while facing-up, UIDevice does not return the interface orientation but the actual device orientation, in this case UIDeviceOrientationFaceUp. So far so good, but problems arise when you need to switch view controller. Not every element in your view are autoresized and you will need to perform some repositioning based on the interface orientation. Since the device has actually not been rotating (you arrived to this view with the device already been rotating to landscape) the following methods will obviously not been called

- (BOOL)shouldAutorotateToInterfaceOrientation:(UIInterfaceOrientation)
interfaceOrientation ;
- (void)willRotateToInterfaceOrientation:(UIInterfaceOrientation)
toInterfaceOrientation duration:(NSTimeInterval)duration ;
- (void)didRotateFromInterfaceOrientation:(UIInterfaceOrientation)
fromInterfaceOrientation ;

The last option you have is to manually check the device orientation by calling

[[UIDevice currentDevice] orientation]

And here comes the problem, if the user actually holds the device to a valid orientation, you will be able to map the interface orientation to the device orientation given that

typedef enum {
    UIInterfaceOrientationPortrait           = UIDeviceOrientationPortrait,
    UIInterfaceOrientationPortraitUpsideDown = UIDeviceOrientationPortraitUpsideDown,
    UIInterfaceOrientationLandscapeLeft      = UIDeviceOrientationLandscapeRight,
    UIInterfaceOrientationLandscapeRight     = UIDeviceOrientationLandscapeLeft
} UIInterfaceOrientation;

But in our case where the device is actually facing up on the desk, the device orientation will not map to any interface orientation and the only option we have is to make an arbitrary decision with 50% chance of being wrong. This is obviously unacceptable and there might be an easy solution to this very annoying drawback.

Well, my first thought was to check the application frame by checking

[[UIScreen mainScreen] applicationFrame]

but the frame is orientation independent and simply returns the frame in portrait mode.

The method that seems to actually do the job is to check the status bar orientation. Indeed, if you do not try to manually set its orientation, the status bar gently follows the orientation of the screen and thankfully its orientation is directly available by getting

[[UIApplication sharedApplication] statusBarOrientation]

This way, you can get the interface orientation at any time by simply checking this property. Note that it does not matter whether the status bar is hidden or not, the property will be updated no matter what.

Hope that helps! ;)

DDPageControl, a Custom UIPageControl

2011-01-15T00:00:00+00:00

UIPageControl, the sibling of any UIScrollView with paging enabled is a widely used control (Apple uses it in many of their apps, Weather, Safari, even to scroll between screens in iOS).

However, when building an app, designers are rarely happy with the standard UIPageControl and often prefer a slight variant of it (changing the color of the indicators, their size, etc..). Unfortunately, UIPageControl is not customizable at all and you have to stick with the 4px-diameter indicators, 12px-spacing, white-on and gray-off if you want to use it.

Building your own page control is however not hard and that's what I decided to do: here comes DDPageControl! My first requirement was to replicate exactly the features of UIPageControl and add some additional properties for its customization. This way, you can easily replace any existent UIPageControl with a DDPageControl and it will work out of the box without any change. Obviously, if you do not set any additional properties, you will have the same look and feel as the original UIPageControl. However, DDPageControl adds the following properties:

@property (nonatomic,retain) UIColor *onColor ;
@property (nonatomic,retain) UIColor *offColor ;

@property (nonatomic) CGFloat indicatorDiameter ;
@property (nonatomic) CGFloat indicatorSpace ;

@property (nonatomic) DDPageControlType type ;

This way, you can easily customize the color of the indicators by setting the properties onColor and offColor. onColor is the color of a single dot representing the current page and offColor are all other dots. You can obviously also pass an alpha channel in your UIColor giving the opportunity to achieve a very nice look!

indicatorDiameter is a property you can set to define the size of any dot. indicatorSpace is the spacing between two dots.

Eventually, the type property can be any of the following defined in the enum:

typedef enum
{
    DDPageControlTypeOnFullOffFull       = 0,
    DDPageControlTypeOnFullOffEmpty      = 1,
    DDPageControlTypeOnEmptyOffFull      = 2,
    DDPageControlTypeOnEmptyOffEmpty = 3,
}
DDPageControlType ;

It defines the general look of on and off dots: full or empty.

The code can be found on GitHub in my repository: DDPageControl.

The DDPageControl class is the one you want to import in your project to use it. However, DDPageControlViewController can also be helpful since it gives an example of how to use the page control along with a classic UIScrollView, above all how to set the current page in your scrollViewDidScroll and scrollViewDidEndScrollingAnimation methods. In particular, using defersCurrentPageDisplay set to YES and calling updateCurrentPageDisplay once the animation is terminated is an optimal way to obtain a smooth transition of the page control when animated the UIScrollView. This not only apply to DDPageControl but more generally to any UIPageControl.

Following are some example of what you can obtain by setting the properties as stated.

Screen D was obtained with the following code:

[pageControl setType: DDPageControlTypeOnFullOffEmpty] ;
[pageControl setOnColor: [UIColor colorWithWhite: 0.9f alpha: 1.0f]] ;
[pageControl setOffColor: [UIColor colorWithWhite: 0.7f alpha: 1.0f]] ;
[pageControl setIndicatorDiameter: 15.0f] ;
[pageControl setIndicatorSpace: 15.0f] ;

Screen E was obtained with the following code:

[pageControl setType: DDPageControlTypeOnEmptyOffFull] ;
[pageControl setOnColor: [UIColor colorWithWhite: 1.0f alpha: 1.0f]] ;
[pageControl setOffColor: [UIColor colorWithWhite: 0.7f alpha: 0.5f]] ;
[pageControl setIndicatorDiameter: 10.0f] ;
[pageControl setIndicatorSpace: 15.0f] ;

Screen F was obtained with the following code:

[pageControl setType: DDPageControlTypeOnFullOffFull] ;
[pageControl setOnColor: [UIColor colorWithWhite: 1.0f alpha: 1.0f]] ;
[pageControl setOffColor: [UIColor colorWithWhite: 1.0f alpha: 0.5f]] ;
[pageControl setIndicatorDiameter: 13.0f] ;
[pageControl setIndicatorSpace: 10.0f] ;

iOS Devices Capability Detection

2011-01-13T00:00:00+00:00

I have written a small class that will make your life easier if you need to deploy iOS apps across different versions of the OS and multiple device generations.

You might have already written some code like that to check if the device is running iOS 4.0 and has thus multitasking:

if (kCFCoreFoundationVersionNumber >= kCFCoreFoundationVersionNumber_iOS_4_0)
    return YES ;
else
    return NO ;

While this is valid, it might just be annoying to have to rewrite it every time you need to check it! DDDeviceDetection defines simple class method such as isRunningiOS4 that you can easily call anywhere through your code, assuming you first import the header in your class.

#import "DDDeviceDetection.h"

if ([DDDeviceDetection isRunningiOS4])
    // do something that only runs on iOS4

There are many methods checking various hardware and software capabilities such as the OS version, device type, camera, compass, gyroscope, geo-location, audio and video.

You can find the code in my GitHub repository here.

Version Control with Git

2010-12-29T00:00:00+00:00

I have been reading the book "Version control with Git" by Jon Loeliger during the last two days. I have to admit it is excellent. Git is a joy to work with (even more if one has had experience with another revision control system such as Subversion) and reading this book will unveil so many secrets and tips about Git that will make your developer life much easier. Also, the author really knows his stuff and keep the reader focused and interested. I managed to read the book cover to cover in less than two days which is, given the 'dryness' of the topic, quite remarkable!

The book is available on Amazon and I also wrote a comment about it that you can find here.

LibraryThing iOS Developers Group

2010-12-28T00:00:00+00:00

I love books. Actually, I love textbooks. There is nothing like the feeling of studying through the pages of a good textbook. But, as a real nerd, I also love computers. Here comes the dilemma: I like paper books too much to envisaging keeping my library as Kindles (or iBooks). However, while on the go, I like to be able to browse and contemplate my library without having to bring ten boxes of books!

For all book lovers, there is an amazing website that allows you to do just that: LibraryThing. LibraryThing allows you to keep a virtual collection of all your books, classified by category, tags (and many more things like a forum where you can discuss your beloved novels with other users, groups where user with similar taste can exchange tips, review books, etc...).

I have created a group for iOS and Mac OS X developers. I have also inserted a first topic: "Best iOS development books". The URL to the group is the following: http://www.librarything.com/groups/iosandmacosxdevelope (yes, there is no 'r' in developer, the URL has been generated by LibraryThing like that, ugly I know...)

You can also find my profile on LibraryThing at: http://www.librarything.com/profile/dd2284

UIColor with Pattern Image

2010-12-27T00:00:00+00:00

A very handy method but not often referenced method in UIColor is

+ (UIColor *)colorWithPatternImage:(UIImage *)image

Very often, you find yourself having to add a background element to your UIViews. Such background are almost always a plain image with repetitive elements (such as a chess board for example). Having to insert a plain 640x960 (or more if using a scroll view) image to you view and project can be a complete waste of memory. In these cases, you might consider using a UIColor and simply instantiate it with a pattern image through colorWithPatternImage.

Assume you want to achieve the following effect in your UIView:

Instead of using a plain 640x960 UIImage, consider using the following (small!) image and line of code:

- (void)viewDidLoad
{
    [super viewDidLoad] ;

    UIColor *pattern = [UIColor colorWithPatternImage: [UIImage imageNamed: @"background.png"]] ;
    [self.view setBackgroundColor: pattern] ;
}

This way, you only need to load in memory the small pattern image and the UIColor will do the job of extending it to fill the background for you. Also, you do not have to worry about positioning and resizing the background UIImageView to fit your view.

A small tip to bear in mind (from Apple documentation):

By default, the phase of the returned color is 0, which causes the top-left corner of the image to be aligned with the drawing origin. To change the phase, make the color the current color and then use the CGContextSetPatternPhase function to change the phase.

Lua Tables Under the Hood

2010-11-28T00:00:00+00:00

I have been playing with Lua lately and I have to say that I'm pretty amazed by the simplicity and efficiency of the language! I am particularly amazed by the way they define data structures for example by treating everything as HashTables (tables in Lua). Until Lua 5.0, every data structures was literally a strict HashTable. Since 5.0, they introduced the new "hybrid" table with every table containing a hash part and an array part. The reason for that is in case you want to store a pair with an integer key, you do not really need the overload of the hashing process when an array would do the job and allow you to store and retrieve the value with a single lookup. However, for avoiding waste of memory, a pair with an integer key n is inserted to the array part of the tables only if at least half the slots between 1 and n are occupied. In that way, a table would not have to create a 1,000,000 empty slots array in case the first key that I am trying to insert is 1,000,000. It would be added to the hash part of the table and moved to the array part if needed later on since the size and structure of the table is recomputed every time the table needs to grow. This is obviously a low-level implementation completely transparent to the user (and even to the virtual machine). The only thing you actually see when using Lua are tables.

A summary of the features and implementation in Lua 5.0 can be found in this paper by the authors of the language.

Bitshift Operator and Bit Counting

2010-10-30T00:00:00+01:00

One subject I've always found a bit tricky (in particular during interviews, since it seems to be a very common question) is bit representation and bit counting. This is a rather simple stuff, even if, as we will see, it can be quite tricky if we want to go beyond the naive method.

To get into the subject, let's assume I am interviewing you and that I ask you to write a function that returns the number of pairs of set bits 1 in a given 32-bit integer. Ok, so now you're thinking: well, I have a function that takes an integer argument, easy, I simply need to loop through the bits, determine if the previous bit for any 1 was also 1 and increment my counter by one, that's it! But wait, how will I get this bit representation of my integer??

Here comes the bitshift operator to the rescue. The bitshift operators >> and << are defined in almost every programming language and basically ... shift the bits! Let's assume you have the following bit pattern: 0100110. By applying << 1 to this number will shift the bits one position to the left and lead to 1001100. Similarly, applying >> 1 would give us 0010011. Got it? (Before going on, it's important to note that the bitshift operator does not actually modify the given number. If you want to modify the number, you should use >>= and <<= instead. It is the same distinction as applying + and += to a number).

So, you can actually multiply an int by 2 by simply bit shifting once to the left. Obviously, the number has to be smaller than $2^{31}$ if we want to be able to shift bits once to the left. In case there is a 1 as the leftmost bit of the binary representation, it will simply be discarded. Similarly, the first number from the right will be filled with a 0. This pattern can change in case we are dealing with signed numbers but for the sake of simplicity, we will assume that we are dealing with unsigned integers here.

So, bit shifting the following 32-bit integer $2^{31}$
10000000000000000000000000000000
will result in
00000000000000000000000000000000
which is simply 0.

The reason is that the largest number that one can represent with a 32-bit integer is $2^{32}-1$ or 4294967295 in case 10. By shifting bits to the left by one position for $2^{31}$, we actually multiply the integer by 2 and obtain $2^{32}$ which is to large to be represented with a 32-bit integer.

Alright, so first of all, let's introduce the naive method for bit counting.

// function that counts the number of 1 in a given integer
int numberOfOnes(unsigned int num)
{
    int counter = 0 ;
    while(num)
    {
        counter += num & 0x1 ;
        num >>= 1 ;
    }
    return counter ;
}

This method will indeed return the number of set bits in a given integer. However, it has to loop n times, n being the position of the left-most set bit in the integer. So, in the worst-case scenario, $2^{31}$, we will have to loop 32 times in order to reach the only bit set in this integer! Let's analyze what is happening in this for loop. We first check whether the rightmost bit is 1 by bitwise comparing the integer with 0x1 (hexadecimal representation of 1). This returns another integer where each bit is set to 1 only if the corresponding bit in both number is 1.

For example, assuming we input the number 13:
001101 --> 13 in base 10
000001 --> 1 in base 10
gives
000001 --> 1 in base 10

but inputing 14:
001110 --> 14 in base 10
000001 --> 1 in base 10
gives
000000 --> 0 in base 10

So basically, "num & 0x1" returns 1 if num has a 1 on the rightmost bit and 0 if it has a 0. By incrementing the counter variable by this value, we simply add 1 every time we come across a 1 in the integer and simply add 0 otherwise. So far, we understood how to detect whether the rightmost bit is 1 or 0 but we have to loop through every bit in that integer. We could easily compare the integer with all powers of two until $2^{31}$ but we do not really want to have to loop 32 times every time, even if the number to check is 1 or 2. We would rather loop through the integer we input until we reach the leftmost bit that is set. To do that, we use the fact that we can easily right shift all bits in the integer and we keep doing that until no 1 is left in the integer (resulting in an integer of value 0 in base 10). Hence, we keep right shifting the integer by one position until it results in 0.

Similarly, we can count the number of pairs of 1 in a given integer by using the following function.

int numberOfOnePairs(unsigned int num)
{
    int counter = 0 ;
    bool lastWasOne = false ;
    while (num)
    {
        if ((num & 0x1))
        {
            if (lastWasOne)
                counter++ ;
            lastWasOne = true ;
        }
        else
            lastWasOne = false ;
        num >>= 1 ;
    }
    return counter ;
}

A handy tool in order to understand better what's happening here is another function that simply prints the binary representation of any unsigned integer.

void printBitRepresentation(unsigned int num)
{
    // sizeof returns bytes, so need to multiply by 8 to get bits
    int size = sizeof(num)*8 ;
    char bits[size+1] ;
    for (int i = 0 ; i < size ; i++)
    {
        if (num & (1 << i))
            bits[size-1-i] = '1' ;
        else
            bits[size-1-i] = '0' ;
    }
    bits[size] = '\0' ;
    printf("%s\n", bits) ;
}

In another post, I'll talk about methods that go beyond the naive method and do not require to loop through every bit.

Sorting Algorithms Comparison

2010-10-24T00:00:00+01:00

I have been working on sorting algorithms during the last week and I thought it would be worth writing a small article about it. Trying to sort an array "brute-force" in any programming language would almost always take ages and could lead to memory overflows. Fortunately, many efficient sorting algorithms have been designed. However, not every algorithm is as efficient and each algorithm performs better or worse in some given situations. As a starting point, let's first illustrate the complexity of five famous algorithms (I am not a big fan of Bubble Sort but it's also worth to show bad examples in order to fully illustrate a topic):

Furthermore, in order to illustrate better the overall complexity of each algorithm, let's look at the running time of each algorithm for various array sizes in three very different situations: - when the array is already sorted (which leads to best case scenario for some algorithms but as we will see, not all of them). - when the array is already sorted but in reverse order (leads to worst case scenario for simple algorithms). - when the array is randomly ordered.

Sorted array:

Reverse sorted array:

Randomly sorted array:

We randomly sorted the array by generating its elements with the following routine:

int arraySize = 10000 ;
int array[arraySize] ;
srandom(time(NULL)) ;
for (int i = 0 ; i < size ; i++)
    array[i] = random() % size ;

(Note that '-' simply means that I did not have the patience to wait for the algorithm to return... You get the idea anyway).

The first comment we can make out of this data is that Merge Sort performs indeed quite well on average and does not give bad results even in the worst case. However, for each situation it is outperformed by another algorithm, Bubble and Insertion Sorts when the array is already sorted and Quick Sort when the array is randomly sorted. The reason is that when the array is already sorted, simple algorithms such as Bubble Sort and Insertion Sort reach their best case scenario (but reaching their worst case scenario if the array is sorted in reverse order). Furthermore, even if Quick Sort and Merge Sort have same complexity on average and in best case scenario, the constants (hidden by the big-O notation) are much smaller in Quick Sort leading to a smaller running time on average. However, the pitfall is that Quick Sort performs bad in the worst case scenario so it can be quite of a risky alternative.

So, even if we can consider Merge Sort a "safe alternative" that guarantee good results in any case, it is very often simply not the best option. The reason is mainly that the worst-case scenario is after all really rare and believe it or not, half of the time you try to sort an array, it is actually already sorted. In that case, Merge Sort will still perform in $\mathcal{O}(n\log{n})$ while Insertion Sort for instance will perform in $\mathcal{O}(n)$.

So my piece of advice is:

analyse the problem carefully before deciding the sorting algorithm.
often, for small arrays or arrays that are already (or almost) sorted, Insertion Sorting will do the job and even perform better than a more complex algorithm.
if you care about memory, avoid Merge Sort since it basically uses loads of temporary arrays that will easily overflow your memory.
even if Quick Sort has a $\mathcal{O}(n^{2})$ worst case, remember that worst case is often rare and Quick Sort will perform much better that Merge Sort on average since its constants (hidden by the big-O notation) are actually much smaller.

Following is a C implementation of the five algorithms.

BUBBLE SORT

void bubbleSort(int array[], int min, int max)
{
    // loop through every item in the array
    for (int i = min ; i <= max ; i++)
    {
        // loop a second time from the back of the array
        for (int j = max ; j > i ; j--)
        {
            // swap the elements if necessary
            if (array[j-1] > array[j])
            {
                int copy = array[j-1] ;
                array[j-1] = array[j] ;
                array[j] = copy ;
            }
        }
    }
}

INSERTION SORT

void insertionSort(int array[], int min, int max)
{
    int key ;
    // we loop through all elements in the original array from the second element
    for (int j = 1 ; j <= max ; j++)
    {
        // store the current element as the key
        key = array[j] ;
        // get the element just before the current element
        int i = j - 1 ;
        // loop through all elements from the key to the start
        // check if the current element is smaller than the key
        while (i >= 0 && array[i] > key)
        {
            // we move the current element backward
            array[i+1] = array[i] ;
            i-- ;
        }
        // we finally move the key
        array[i+1] = key ;
    }
}

MERGE SORT

void mergeSort(int array[], int min, int max)
{
    // prerequisite
    if (min < max)
    {
        // get the middle point
        int mid = (int)floor((max+min)/2) ;
        
        // apply merge sort to both parts of this
        mergeSort(array, min, mid) ;
        mergeSort(array, mid+1, max) ;
        
        // and finally merge all that sorted stuff
        merge(array, min, max, mid) ;
    }
}

void merge(int array[], int min, int max, int mid)
{
    int firstIndex = min ;
    int secondIndex = mid + 1 ;
    int index = min ;
    int tempArray[max] ;
    
    // if there are still objects in both arrays
    while ((firstIndex <= mid) && (secondIndex <= max))
    {
        if (array[firstIndex] < array[secondIndex])
        {
            tempArray[index] = array[firstIndex] ;
            index++ ;
            firstIndex++ ;
        }
        else
        {
            tempArray[index] = array[secondIndex] ;
            index++ ;
            secondIndex++ ;
        }
    }
    
    // terminates the object of the lower array
    while (firstIndex <= mid)
    {
        tempArray[index] = array[firstIndex] ;
        index++ ;
        firstIndex++ ;
    }
    
    // terminates the object of the upper array
    while (secondIndex <= max)
    {
        tempArray[index] = array[secondIndex] ;
        index++ ;
        secondIndex++ ;
    }
    
    // transfer to the initial array
    for (int i = min ; i < index ; i++)
        array[i] = tempArray[i] ;
}

HEAP SORT

// returns the left node (by doubling the current node)
int leftNode(int node)
{
    return node << 1 ;    // this actually does 2*node
}

// returns the right node (by doubline the current node and adding 1)
int rightNode(int node)
{
    return (node << 1) + 1 ; // this actually does 2*node+1
}

// return the parent node (by taking the half of the
// current node and returning its floor)
int parentNode(int node)
{
    return (int)floor(node/2) ;
}

// restore the heap property
void maxHeapify(int array[], int i, int heapSize)
{
    // get the two children nodes
    int left = leftNode(i) ;
    int right = rightNode(i) ;
    
    // assume that the largest is originally the current node
    int largest = i ;
    
    // check if the left node is the largest
    if (left <= heapSize && array[left] > array[i])
        largest = left ;
    
    // check if the right node is the largest
    if (right <= heapSize && array[right] > array[largest])
        largest = right ;
    
    // in case the left or right node was larger than the parent
    if (largest != i)
    {
        // we switch the parent with the largest child
        int temp = array[i] ;
        array[i] = array[largest] ;
        array[largest] = temp ;
        
        // and apply maxHeapify recursively to the subtree
        maxHeapify(array, largest, heapSize) ;
    }
}

// build the heap by looping through the array
void buildMaxHeap(int array[], int heapSize)
{
    for (int i = (int)floor(heapSize/2) ; i >= 0 ; i--)
        maxHeapify(array, i, heapSize) ;
}

void heapSort(int array[], int arraySize)
{
    // determine the heap size
    int heapSize = arraySize ;
    
    // build the heap
    buildMaxHeap(array, heapSize) ;
    
    // loop through the heap
    for (int i = heapSize ; i > 0 ; i--)
    {
        // swap the root of the heap with the last element of the heap
        int temp = array[0] ;
        array[0] = array[i] ;
        array[i] = temp ;
        
        // decrease the size of the heap by one so that the previous
        // max value will stay in its proper placement
        heapSize-- ;
        
        // put the heap back in max-heap order
        maxHeapify(array, 0, heapSize) ;
    }
}

QUICKSORT

int partition(int array[], int min, int max)
{
    // define a pivot as the max item of the (sub)array
    int pivot = array[max] ;
    int i = min - 1 ;
    // loop through the elements of the (sub)array
    for (int j = min ; j < max ; j++)
    {
        // in case the element has a smaller value that the pivot
        // bring it in front of it (larger elements will come after it)
        if (array[j] <= pivot)
        {
            i++ ;
            int temp = array[i] ;
            array[i] = array[j] ;
            array[j] = temp ;
        }
    }
    // bring the pivot to its correct position
    int temp = array[i+1] ;
    array[i+1] = array[max] ;
    array[max] = temp ;
    
    return i+1 ;
}

void quickSort(int array[], int min, int max)
{
    if (min < max)
    {
        // partition the array in two parts
        int q = partition(array, min, max) ;
        // apply QuickSort recursively to both parts
        quickSort(array, min, q-1) ;
        quickSort(array, q+1, max) ;
    }
}

The Fate of Languages in Academics

2010-10-21T00:00:00+01:00

I came across this very good article about the fate of languages in universities from the UCL Vice Provost Michael Worton on the Times Higher Education website.

I am really happy to see that universities (and in particular UCL considering it is the university I studied in) are actually trying to make steps forward in this area. My idea is that even if the access to languages is definitely much easier for students nowadays, through all sort of academic exchanges (Erasmus, Socrates, you name it), there is no reason why proper academic teaching/research should be put away. Nowadays, almost every student has spent at least an academic year abroad, at least in Europe. I studied in four countries and I would do the same exact thing if I had to do it again. Throughout, I've always considered the learning of the language a huge part of my discovering and integration to the country I was living in. The process of learning a language is maybe the best gate I could imagine of in trying to understand a culture and its people. For this reason, I never did and will never agree that treating English as a de facto standard, giving it such a predominance in teaching versus any other language, will make ourselves global citizens. International English is a great tool that makes communications among people easier "at first sight" but from my experience, it will never be a substitute to properly learning the language of the person you are communicating with... And this is only possible if universities keep doing their great job in teaching millions of students languages and studying every single details about languages and discovering all these little tricks and weirdnesses, sentiment of déjà-vu or complete "lost in translation" feeling, that make the study of a language such a fantastic journey!

iPhone Retina Extensions

2010-10-20T00:00:00+01:00

I started to write a couple of Cocoa applications to play with file extensions and image sizes.

The reason for that is that, often, designers only give you the larger version (the one used for devices with a retina display) of an image and don't add the @2x extension to the file name. I very often found myself renaming a whole bunch of files, opening each of them with Preview, resizing them and changing the name back. This is a tedious process that unfortunately takes a developer off his main task and well, let's face it, wastes his time!

The first application is a command-line application that simply add the @2x extension to all the images (.png .jpg and .jpeg) contained in a folder and copy them in another folder (this one can of course be the same as the original one).

The project is named DDRetinaExtension and you can find the source code on GitHub.

Simply build the project, cd to the folder where the project has been built and run the following command:

$ cd /folder/where/the/built/resides
$ ./RetinaExtension --from /origin/path/ --to /destination/path/

And that's basically it! This will rename all images located in the origin path, add the @2x extension and copy them to the destination path.

I am currently working on a proper Cocoa application that will also integrate the resizing and make this process a bit more friendly!