Bet you didn’t know that Option-Control-Space bar toggles through all enabled input sources. Whatever those are. Good thing there’s a keyboard shortcut for this. Because I do this all day long. Everyday.

Here’s the list from Apple.

For example, Emma’s Imagination’s cover of Change by the Deftones gave me chills. 

To get the most out of this post you should understand objective-c blocks, and objective-c categories.

Ok, warp factor one. Engage.

This is a useful pattern I’ve discovered after playing with it in various incarnations since iOS 4 came out. I’ve landed on a design which is super simple, and really easy to use. The example’s here are silly and contrived, but the pattern works at scale with large shipping code.

I’m a big fan of objective-c blocks. I first learned about them when using Javascript closures at Microsoft and they blew my mind back then. Now, not so much with the mind blowing, but they’re very useful and I was super excited when they came to objective-c. They have their dangers and drawbacks (which I’ll explore in another post), but for this, they’re perfect because you can use them inline with your normal code – you don’t have to declare extra functions or methods or whatever for fancy or complex initializaton.

Let me explain.

Here’s the situation. You need to build a list of objects that do something, or represent something. For example, this might be a list of addresses, or a queue of tasks to perform, or whatever. We do this all the time. For this, we need to configure a bunch of ducks. Funky ducks.

Let’s start with an example.

I need to create 3 GtFunkyDuck objects and add them to a NSMutableArray.

(Note that GtFunkyDuck isn’t a real object, and the properties and method names will just be silliness to illustrate my point. Also, my company is GreenTongue Software, so all my objects are prefixed with “Gt”. You know, it stands for Goober Tooth or Grand Teton or Got Tamatoes…).

Here’s the normal way to initialize some ducks. Hmm, did I really just write that?

NSMutableArray* myArray = [NSMutableArray array];

GtFunkyDuck* myDuck1 = [[[GtFunkyDuck alloc] init] autorelease];
myDuck1.feetAreWebbed = YES;
myDuck1.billColor = [UIColor redColor];
myDuck1.quackVolume = 6;
[myDuck1 getReadyToSwimInPond:myPond];
[myArray addObject:myDuck1];

GtFunkyDuck* myDuck2 = [[[GtFunkyDuck alloc] init] autorelease];
myDuck2.feetAreWebbed = NO;
myDuck2.billColor = [UIColor greenColor];
myDuck2.quackVolume = 1;
[myDuck1 getReadyToSwimInBathtub:aBathtub];
[myArray addObject:myDuck2];

GtFunkyDuck* myDuck3 = [[[GtFunkyDuck alloc] init] autorelease];
myDuck1.feetAreWebbed = NO;
myDuck3.billColor = [UIColor blueColor];
myDuck3.quackVolume = 2;
[myDuck1 getReadyToChaseAToddler:aToddler];
[myArray addObject:myDuck1];

This code illustrates what I’m talking about very well. Look closely. There are a couple of bugs here. Why? Because I’m lazy and I copied and pasted myDuck1 to reuse the code for myDuck2 and myDuck3. I want this code written, now, I can’t be bothered retyping GtFunkyDuck seventy-hundred times. So copy-paste here I come, and then I got distracted by twitter and screwed up myDuck3. This could cause weirdass bugs that are hard to track down. myDuck1 was added twice to the array, myDuck3 was never added, and myDuck1 doesn’t have webbedFeet like it’s supposed to. Well, you get the idea. It’s far easier to screw up the code here than to get it right, in my experience. Copy and paste. Deliciously dangerous.

One solution is to add an initWithWebbedFeet method and have a bunch of parameters for building the object. But what if the object has twentysix options? Or complex configuration methods? What if the default initializer puts the object into a state that’s just fine? If so, there’s no point in passing in all the parameters, or creating six quadrillion different init methods, and in fact that will make the code very difficult to maintain and debug

GtFunkyDuck* myDuck1 = [[[GtFunkyDuck alloc] initWithWebbedFeet:YES
                                                      billColor:[UIColor redColor]
                                                    quackVolume:4
                                                 swimsInCircles:NO
                                               likesBreadCrusts:YES
                                                  hatesChickens:YES
                                            chasesSmallChildren:NO
                                        willBeATastyMealSomeday:YES] autorelease];

This is just damn painful. In my experience, if there are more than two or three parameters, you’re in for some hurt. Big fat painful hurt, deep in the debugger, complete with dog kicking cursing and heavy drinking. Well, maybe not that bad. And for the record, I never kicked my dog. (Or your dog).

So there are two problems here:

1. We have to create a bunch of local variables to hold temporary references to the objects we’re creating, e.g. myDuck1, myDuck2, and myDuck3. This gets painful and buggy, after, well, one, because everyone copies and pastes and we forget or miss changing the names in the newly pasted code in our hurry to implement our new duck related feature.
2. We have complex objects with a bunch of optional parameters. These damn ducks are high maintainence. They have a lot of options.

Here’s my simple solution:

typedef void (^GtConfigureObjectBlock)(id object);
@interface NSMutableArray (GtArrayAdditions) 
- (void) addObject:(id) object configureObject:(GtConfigureObjectBlock) block; 
@end 

@implementation NSMutableArray (GtArrayAdditions) 
- (void) addObject:(id) object configureObject:(GtConfigureObjectBlock) block { 
	if(block) { 
		block(object); 
	} 
	[self addObject:object]; 
} 
@end 

What we’re doing here is passing in a object in a default state, and then modifying that default state with your block callback. This elimates all the local variables and nearly all the opportunity for cut and paste errors, which can be traced back to having to reference the objects through their local variables. So our new fancy code for initializing our ducks looks like this now:

 
NSMutableArray* myArray = [NSMutableArray array];
 
[myArray addObject:[[[GtFunkyDuck alloc] init] autorelease] configureObject:^(id duck) { 
	[duck setFeetAreWebbed:YES]; 
	[duck setBillColor:[UIColor redColor]]; 
	[duck setQuackVolume:6]; 
	[duck getReadyToSwimInPond:myPond]; 
}]; 
 
[myArray addObject:[[[GtFunkyDuck alloc] init] autorelease] configureObject:^(id duck) { 
	[duck setFeetAreWebbed:NO]; 
	[duck setBillColor:[UIColor greenColor]]; 
	[duck setQuackVolume:1]; 
	[duck getReadyToSwimInBathtub:aBathtub]; 
}]; 
 
[myArray addObject:[[[GtFunkyDuck alloc] init] autorelease] configureObject:^(id duck) { 
	[duck setFeetAreWebbed:NO]; 
	[duck setBillColor:[UIColor blueColor]]; 
	[duck setQuackVolume:2]; 
	[duck getReadyToChaseAToddler:aToddler]; 
}]; 
 

The only draw back is that you loose the ability to use the properties. You can’t do this:

 
[myArray addObject:[[[GtFunkyDuck alloc] init] autorelease] configureObject:^(id duck) { 
	duck.feetAreWebbed = NO; 
}]; 

You also can’t do this (unfortunately):

 
[myArray addObject:[[[GtFunkyDuck alloc] init] autorelease] configureObject:^(GtFunkyDuck* duck) { 
	duck.feetAreWebbed = NO; 
}]; 

However, I view the inability here to use the properties as merely cosmetic. The trade off in better code and less bugs is worth it.

This may look a little weird, but once you wrap your head around it, it become second nature and very powerful.

Let me know what you think, or if you have any questions.

I am leaning bent,
a heavy wall pushing me upright
in a flowing crowd.
I drink from a cup as big and white
as stacked toilet paper.
My eyes fill with wine,
lids floating shut.

The charred and chipped
building holding me
sways
threatening to fall with me into the square.

It is soiled with moist shrapnel
from a dirt bomb,
splotches of brown merging
and dripping down the walls
into the hair of the partygoers.

The crowd flows like a wine river
around a tall fountain
pointed blunt like a beer bottle.
People swirl past me,
laughing like vapor,
all teeth and rapid blur.

Wet from Champagne and urine,
cobblestones float under my feet.
I trap them down,
the wall holding me
and I holding the stones.

Attention
is turned from faces
to the fountain.
The wine river flows faster.
Now back on itself
as if from sudden tide.

A man stands alone,
conqueror of the fountain,
above the crowd.
His arms perpendicular like a cross
he seems to meditate.
Suddenly he is flying.
The river shakes,
boiling with tension.
The man makes no splash;
he is inhaled gracefully.

Crawling unsteady
another climbs
like a spindly insect
to the top.
A momentary victor
waving like a pond weed.
But its as if a firm hand
pushes him,
he topples
wrongly
softly and slow,
grinning
down into cement.

My cobblestones energize
and escape
in a sudden throb;
my wall softens
tilts
releasing me
to hold the soft cobblestones
with my face,
my cup drifting away.

I see the river suddenly dry
into grains of standing people
as white hat men take the dead away.

District 9 is a fantastic movie but you might not enjoy it. You should see it anyway. I think this is an important movie.

Now, those of you that know me know that I’m a big science fiction fan. I’ve read countless books and stories and watched everything. I’m a hard sell. I think this is one of those movies that truly transcends the genre. The thing about great sci-fi is that it is always about much more than is on the surface, it challenges you, it makes you think. But it’s not always fun.

District 9 is a hard movie to watch because it really touches on significant and painful social issues. I think it hits a nerve. Or three. I understand why you may not enjoy it, but you can’t say isn’t a fantastic movie. Well, you could, but you’d be wrong.

I think that District 9 isn’t an enjoyable movie in the same way most enjoyable movies are enjoyable. It’s not really escapist entertainment. District 9 stabs you right in the eye with sharp scissors right out of the gate. The way it’s shot, with the flat colors, in hand-held documentary style, definitely didn’t produce a lot of eye candy. In fact, I was a bit off-put by this. At first.

Right away it ripped me out of my comfort zone. It’s not pretty or glamorous. It’s not an idealized version of Hollywood reality. It says something about us, our fears, our flaws, our culture. It makes a painful point about who we are.

This could really happen.

That said (the part about it being harder to enjoy than a normal movie I mean) – I enjoyed the hell out of it. I enjoy a well crafted story. Great dialog. Great plot. I actually was surprised a few times by what happened (which, sadly for me, hardly ever happens). There was a couple of times I wanted to stand up and shout, did you see that? Did you? There’s actually a character arc in this movie, the main character learns, and changes, and surprises. He transforms. Don’t see that too often. The character even has a specific moment of epiphany. And I was loving it.

The attention to detail was staggering. I wanted to rewind and watch some parts again. The special effects may be the best I’ve every seen. I forgot about them and just enjoyed the movie. I forgot that the aliens and spaceship were computer generated. Normally, in other movies where there are virtual characters, I never quite forget they’re computer generated. I did in this movie. Probably the only other time that’s happened for me is Gollum in Lord of the Rings.

I’m still thinking about the movie. That never happens to me. (Nearly) ever.

There’s my thoughts on it. So there.