Well, in the simplest cases, when there are only a few messages, and only a few listeners, and few objects that wake up to look at the userInfo to see if it is interesting, one might opt for the simpler programming / inheritance model and have very little code, reused via inheritance that does all the work. E.G. all objects inheriting from BaseObject listen for message “foo” and then inherit the code for:

-(void)fooNotification:(NSNotification *)notif {
  if ([self.id isEqual:[notif.userInfo objectForKey:@"id"]]) {
    [self handleFoo:userInfo]; // do something
  }
}

The BaseObject class has the id filter notification handler (above), a no-op handleFoo:, which sub-classes can override, and the sender always sends out the same “foo” notification, with the differentiator tucked away in the userInfo for the recipient.

Sounds good, no? Lots of inheritance, code reuse, simplicity. The “leaf-node” classes just implement handleFoo: if they need to. All works great. But where does this break down?

Say you had a thousand BaseObject subclass instances. When they are created, they ask a Loader for some resource and listen for loaderDone Notifications. Loader finishes each request, sends a notification, moves on to the next. (You are using an NSOperationsQueue to manage your Loader pool, right?) Instances get pinged after operations complete and one says “Hey! That’s me!” and does something significant, like update a bit of UI, while the others pass. The rub? One thousand objects wake up and run a few lines of code for each one that does anything. Code is simple, easy to test. Low message dispatch cost. Probably insignificant overhead on your spiffy new PowerMac. Zero problem in testing with a few objects. But on the iPhone / iPad this is 9,999 objects too many involved in handling the event.

What do you do?

First is just good practice: if you don’t care, don’t listen. Don’t register to observe a notification until you are sure you care, then if you no longer need to listen, unregister. For our pseudo-code, only listen between “I need a foo” and “I got a foo” – outside that take yourself out of the loop. That can only help.

The real trick, when you see this pattern, is to find a way from our default case above, where response time depends on number of potentially interested objects, to a response time dependent on just number of actual interested objects. In the base case, where we have N potentially interested objects and just 1 interested object, we are going from a fluctuating case, based on set size N, to a stable linear case. This in turn leads to more predictable and scale-free (or close to it) response times.

(In our initial example above, response time is equal to “([number of objects] * ([filter time per object] + [message time per object])) + ([number of interested objects] * [handle time per object])”. What we want is to only message the interested objects, so we can be “[number of interested objects] * ([message time per object] + [handle time per object])”.)

So what is the simple trick to do this? Have the listening objects listen for a NSNotification with a name like:

  NSString *notifName = [NSString stringWithFormat:@"foo-%@-notification", self.id];

and have the Loaders post matching notifications. The observer lookup table will be a bit larger, with more messages registered, but the observer count will be the same. The lookup will mostly be a hashed lookup based on the memory location of the notification name’s unique string, and on ObjC / Foundation, that kind of lookup is FAST for the set size we are looking at. And even for large sets, we are so much better off paying the price to look up a single observer, than to have to run 4 lines of code in a very large number of objects.

Things that can make the bad case worse?

1. Side-effect cost: You never know what the cost is of asking an object you haven’t written yet a simple question. (“My id? Sure, that’s stored in my NIB file. Which needs to be (re)loaded sometimes. Which instantiates other objects. Which do stuff.”)
2. Threads: An even worse cost is the per-object code that does something that launches or spans thread boundaries. (“My id? Let me fetch that in a new thread. Or in the main thread, which could block stuff.”) Opportunity for thread overload or lock-ups with contention for resources.

Linear response is your friend. Do a little extra work. Easier to debug. Easier to optimize. Happier users.

Remember – your iPhone is like a 100mhz Pentium. CPU cycles are your most precious resource. And less executing code in less objects usually means less less memory, which is our second most precious resource. Less work, less memory, app runs faster, users happier. Everyone wins.

NOTE: For everyone going to WWDC this year, CodeFab will be hosting several iPad/iPhone related events at the SF iPhone Mansion again. On the Saturday and Sunday before WWDC we will be hosting a Mini iPad/iPhone DevCamp (Register Here) in conjunction with our LA iPhone DevCamp/Developer Meetup partners. We will also be hosting a fabulous iPhone Party on (tentative) Tuesday Night. (Hope you remember last year’s blast!)

On the MacPro (where I am sitting now) the Mixes are:

• Electric Blues Mix – Based on: T-Bone Walker, B.B. King, Lightnin’ Hopkins with Sonny Terry, Brownie McGhee, and Big Joe Williams & others.
• Electronica Mainstream Mix – Based on: Fatboy Slim, DJ Shadow, Chemical Brothers, & others.
• Classic R&B Mix – Based on: James Brown, Parliament, Bootsy Collins, & others.
• Adult Alternative Mix – Based on: Ani Difranco, Tom Waits, Poi Dog Pondering, & others.
• Brit Pop Mix – Based on: U2, R.E.M., Radiohead, & others.
• Punk Mix – Based on: Nirvana, Mojo Nixon, Alice In Chains, & others.
• Jazz Mix – Based on: Bill Evans, Ella Fitzgerald, Charlie Parker, & others.
• Old School Rap Mix – Based on: Public Enemy, Digital Underground, Beastie Boys, & others.
• New Wave Mix – Based on: Blondie, Talking Heads, The B-52′s, & others. (Playing)
• Indie Rock Mix – Based on: Pixies, Breeders, They Might Be Giants, & others.
• Classic Rock Mix – Based on: Family, The Rolling Stones, Eric Clapton, & others.
• Alternative Pop/Rock Mix – Based on: White Stripes, Porno for Pyros, Jane’s Addiction, & others.

OK, not unreasonable, but some things pop out. I have huge amounts of Blues, but at least half is acoustic – why Electronic Blues? I have lots of Electronica thanks to a mid-90′s fondness for Techno and lots suggestions from friend Bill Bumgarner, but the bulk is definitely NOT “Mainstream”. Adult Alternative? Shoot me now. At least it isn’t “Adult Contemporary”! While I definitely have the required Brit Pop and lots of Indie and Alternative Pop/Rock, you could roll all three together, add the New Wave and Punk and still have less songs than are in my Jazz collection. Why are they broken out like that while Jazz and Blues just get one Mix each?

Looking at the big media server (more than twice the content) the categories are oddly similar, but still oddly distributed: Jazz Mix, Classic R&B Mix, Electric Blues Mix, Classic Rock Mix, Indie Rock Mix, New Age Mix, Electronica Mainstream Mix, Classical Mix, Grunge Mix, Brit Pop Mix, Hip Hop/Rap Mix, Art & Experimental Rock Mix. OK, Classical mostly lives here, so makes sense it gets a Mix, but there was plenty on my MacPro dev box. I like the label of “Art & Experimental Rock” but I cannot think of much that is on the main server that isn’t also on my other systems. And if Alice In Chains and Nirvana fall under “Punk”, what is in Grunge?

There are some interesting quirks in the rest of the iTunes 9 Genius Mix implementation. It seems odd that I cannot see into a Genius Mix to see what music matches, nor can I change from Grid to List view. List view might have made capturing these lists less frustrating – Mix names and “based on” info only shows up as mouse-overs or for the currently playing Mix. Why the magic twelve Mixes? If I must be limited to twelve, I’d love to see a bigger list of possible MIxes and choose the twelve myself. In List view we could even have more than 12 to choose from! After some investigation, it seems the list of Mixes only changes after significant changes to the library and after “Genius Updates”. I’d love to have a “Refresh” button to request twelve new lists chosen by my friend DJ Genius…

What’s in YOUR Genius Mix list?

Greg had a rich and varied life, producing theater, radio and television, as well as the cabaret at the Rainbow Room at Rockefeller Center in New York. He was also the creative force and founding partner for the trend setting New York cabaret and restaurant The Ballroom in the 1980′s.

Greg was an artist and sculptor his whole life, with a prodigious and amazingly varied output. He achieved a cult status in the 80′s and 90′s with elaborate tableaux of tiny sculpted wax and clay figurines, many depicting the wild side of New York night life of the era. His recent work has been a joyful explosion of constructivist abstract sculpture and paintings which can be viewed at his website DaWsoNWoRK.