I’m talking about a new addition to the language being created by Apple which adds anonymous functions to the language.

The uses and implications of this weren’t immediately apparent to me, but my interest was piqued as I continued reading the article.  Mike is quick to point out that anonymous functions would allow developers to innovate and essentially add features to the language.  Fast iteration was added to ObjC 2.0 in Leopard, allowing us to avoid NSEnumerator and go straight to a for( .. in .. ) statement. 

Blocks wouldn’t exactly have the same syntax, but you could easily implement this in your own code to get the feature.  There are several other examples, some notes that Blocks have access to local variables, and then the following point which is amazing:

Another place where blocks will make things much nicer is when dealing with callbacks. If you’ve ever written much Cocoa code you’ve probably had to write a sheet callback, and it’s a pain in the ass. If you need to pass variables through to the other side then it gets really frustrating with code like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

 - (void)method {
        int foo;
        NSString *bar;
 
       /* do some work with those variables */
        NSDictionary *ctx = [[NSDictionary alloc] 
            initWithObjectsAndKeys:
                [NSNumber numberWithInt:foo], @"foo",
                bar, @"bar",
                nil];
        [NSApp beginSheet:sheet
            modalForWindow:window
            modalDelegate:self
            didEndSelector:@selector(methodSheetDidEnd:
             returnCode:contextInfo:)
            contextInfo:ctx];
    }
 
    - (void)methodSheetDidEnd:(NSWindow *)sheet 
            returnCode:(int)code 
            contextInfo:(void *)ctx {
        NSDictionary *ctxDict = ctx;
        [ctxDict autorelease];
 
        int foo = [[ctxDict objectforKey:@"foo"] intValue];
        NSString *bar = [ctxDict objectForKey:@"bar"];
        /* do some more stuff with those variables
    }

Wow! What a pain that is. Since I removed all the stuff that does work, nearly everything that remains is just boilerplate. Horrible boilerplate whose only purpose is to tell the sheet who to call, and to pack up local information in a way that the sheet can give it back to you later on. Now let’s imagine we were redoing this API using blocks and see how it would look:

1
2
3
4
5
6
7
8
9
10
11

- (void)method {
        int foo;
        NSString *bar;
        /* do some work with those variables */
        [sheet beginSheetModalForWindow:window 
            didEndBlock:^(int code){
            /* do stuff with foo */
            /* do stuff with bar */
            /* do stuff with code, or sheet, or window, etc */
        }];
    }

There are several other examples on the page and I think Cocoa developers will be very excited to see this addition to the language, presumably with Snow Leopard in 2009.

Read the article here.

Theory

From Wikipedia:

A genetic algorithm (GA) is a search technique used in computing to find exact or approximate solutions to optimization and search problems. Genetic algorithms are categorized as global search heuristics. Genetic algorithms are a particular class of evolutionary algorithms (also known as evolutionary computation) that use techniques inspired by evolutionary biology such as inheritance, mutation, selection, and crossover (also called recombination).

I even took the liberty of including my paper on my findings with this project, just because there are so many parameters to test and creating the graphs can be rather time consuming. So take a look at the paper if you would like to read up on the relationships between the number of chromosomes and the average fitness of the population at any given generation, for example.

More uses of NSOperation and NSOperationQueue for multithreading in this project.

Download

Xcode Project (3.1 or later) | Leopard Only

Genetic Algorithm | Leopard Only

Biologically Inspired Computation Series

Theory

Essentially, we are running a network that we can train to recognize data, or solve a problem. We do this by giving the network sample data, and for each set of sample data, running the network through one time. We calculate the error of this run, adjust the weight of the connections between all the neurons in the entire network, and repeat. After running through all the sample data we have adjusted the weights to ‘recognize’ the data. Then, given another set of data, the network is trained to perform the same operation, such as classification (maybe determining forged vs authentic bank notes) or just solving a mathematical equation, such as we do in this particular example.

Code

This simulator is written in Cocoa, requires Xcode 3.1 or later, and is Leopard only. Subclasses NSOperation for multithreading, and have two subclassed NSViews for a ‘Safari Downloads’ style window, just showing the progress of each running experiment, with a cancel button beside it.

Download

Xcode Project (3.1 or later) | Leopard Only

Neural Net | Leopard Only

Biologically Inspired Computation Series

Back Propagation on Wikipedia

Activation/Inhibition Cellular Automaton

This is a simulator written in Cocoa for running a series of experiments and creating Excel files with the results.  Activation/Inhibition CAs are similar to how a cell on a zebra determines if it should be white or black.  There is no overall governing authority, yet patterns arise naturally.  Intermediate example of using Cocoa classes such as open/save panels, notifications and the file manager.  Excellent for examining how to code complex mathematical formulas and summations in C code.

Hopfield Network

This is a simulator written in Cocoa to test the relationship between the number of stored patterns in a Hopfield Network and the accuracy with which they are remembered.  A very interesting exercise making use of NSOperation and NSOperationQueue for simple multithreading and general Cocoa design patterns such as using a delegate.

Back Propagation Neural Network

Another Cocoa simulator written to investigate the relationship between parameters for a network.  Given a set of data, can train the network to recognize that data.  Then from there, the network can ‘solve’ a problem.  In this simulation, there are two mathematical equations that are solved with this network.  Illustrates custom views, multithreading, and more.

Genetic Algorithms

The last Cocoa simulator in the series, written to investigate the relationship between input parameters for a given population of organisms over several generations.  Parameters include the probability of mutation in the offspring’s chromosomes, number of chromosomes per individual, how much sharing of chromosomes occurs when two individuals mate, and creating your own fitness function to quantify the ‘best fit’ individual based upon the DNA.  Multithreading and general Cocoa design patterns.

Going Further

I find this general area of computer science very interesting and would love to spend time researching and learning more about neural networks and genetic algorithms.  If you have any suggestions or comments about the code or projects in general, I’d love to hear from you, so drop me an email.

Theory

From Wikipedia:

  A Hopfield net is a form of recurrent artificial neural network invented by John Hopfield. Hopfield nets serve as content-addressable memory systems with binary threshold units. They are guaranteed to converge to a local minimum, but convergence to one of the stored patterns is not guaranteed.

Basically, you can fine tune the weights (connections between neurons) in the network so as to ‘store’ data in the network. Imagine a square area, not necessarily flat, with a few deep potholes in it. Now, we start the network anywhere on this grid, and as the network progresses, it moves towards the nearest pothole. At the bottom of this pothole is a stored pattern, which is ‘remembered’ by the network. So given a corrupt image, the network can ‘remember’ the real image as it works its way to the sinkhole.

This simulation investigates how many patterns a network can hold versus the accuracy with which the network can recall. For example, a network with only 5 neurons simply cannot accurately recall many patterns, and this simulator allows you to investigate this relationship.

There are two PDFs included with the Xcode project, a theoretical overview and a detailed implementation guide. The simulator produces comma separated value (CSV) files, which can be opened in Numbers or Excel for graphing.

Get Started Now

Of interest to Cocoa programmers, this project makes use of NSOperation and NSOperation queue for quick and efficient multithreading.

Xcode Project (3.1 or later) | Leopard Only

Hopfield Network | Leopard Only

Hopfield Network on Wikipedia

Biologically Inspired Computation Series

The fact that I have had so many approach me, with almost the identical question raises a very valid point. Just where does one find the best documentation and sample code to get started in Cocoa development? With so many developers making the switch to iPhone and then the Mac (and hopefully Cappuccino for web), I think this post will only gain value as time goes on.

So I have compiled a list of extremely useful resources. If you spent enough time googling, you would certainly run across these sites yourself. However, I’m saving you something very precious: time. These vary in range of beginner programmer to advanced genius, so there is a little something for everyone. Keep in mind that as of writing this, official publications on Objective-C 2.0 are just barely in print, and anything for iPhone is still in the works, as the NDA keeping publishers from releasing books was just lifted a week ago.

• THE doc on the Cocoa language, from Apple, HTML or PDF
• http://developer.apple.com – Great place to start for tutorials, etc in general
• http://cocoablogs.com/ – List of all the top Cocoa developers blogs
• http://www.cocoadev.com/index.pl – THE Cocoa message boards
• http://forums.cocoaforge.com/index.php – Another great Cocoa forum, more advanced
• http://inexdo.com/CocoaNav – Wonderful little piece of software for viewing Cocoa headers (information on classes and heirachy)

The finale comes with “Cocoa Programming Mac OS X 3rd Edition“. It assumes very little programming knowledge and yet contains a good 80% of what you need to know when designing a full Cocoa programming. Key design concepts are explained in great detail and it is a wonderful resource.

If you have anything to add to this list, please leave a comment on this post or send me an email!

Theory

Imagine a single skin cell on a zebra. How does the cell know whether it should be white or black? Simply puts, the cell takes into account the value of the surrounding cells. If it’s surrounded by several black cells, then more than likely it should be black, right? Over time the cell keep looking at the cells around it, and the system changes. Eventually, the system will reach a pattern where it doesn’t change anymore. When this happens, the system has converged. Overall this is the basic theory behind pattern formation, on which the Activation/Inhibition Cellular Automaton is based.

This project is designed to investigate how varying parameters in the mathematical equation affects the pattern formation. For example, there is a parameter that influences how many cells away actually influence the current cell’s decision to be white or black. A larger number means that cells farther away are considered, while a smaller number means the converse. By varying a total of six parameters in the experiment, one can see the effect that these parameters have on the system.

Purpose

The Xcode project, aica, is written to perform a few different tasks. First off, you can quickly run a set of sample experiments that will produce some interesting converged systems. By interesting, I mean that the images representing the patterns are visually intriguing, as well as mathematically. AICA also allows a user to quickly run one experiment with a set of parameters, or run a larger set of experiments with different parameters from file.

In designing this application for my Biologically Inspired Computation course, I needed quantitative measurements describing what is happening in the system. These measurements are calculated once the system has converged and are not very pretty equations, involving lots of summations, logarithms and probability. I’m not going to delve into the mechanics and descriptions of these calculations, even though that was part of my report.

Design

I needed this to perform the basic tasks outlined above. In addition, I also wanted to have better statistics, so for each set of parameters ran (an experiment), I might want to run this several times and take the average of the calculated values describing the system. I classified each of these as a “trial”. So, the application structure is beginning to look something like this:

• Controller code for interacting with the interface and managing the experiments to be ran
• An experiment, which will run several trials and average the results, creating an Excel file with data
• A trial, which runs until convergence, writing image files for each step in the simulation

Feel free to look through project. There are two PDF files accompanying, containing the original project description and theory behind the simulation as well as a more technical document providing hints for writing the summations and mathematical equations as C code. This also contains some specific Cocoa programming techniques of interest to newbies, including using a NSProgressIndicator, Objective-C properties, NSNotifications, sheet programming, using NSSavePanel and NSOpenPanel, as well as creating directories and files using NSFileManager.

Get Started Now

Overall, if you have any comments or questions about the project, I’d love to hear from you. Even if you aren’t specifically interested, you should download the Application itself and give it a quick test run. Universal build, Leopard only. I also included some more sample files for systematically varying the parameters as I used in my project and used to draw conclusions about the behavior.

AICA Simulator (Leopard Only)

Source Code and Project Files

Biologically Inspired Computation Series

1
2
3

for ( int i = 0, NSPoint p = [self updatingCell]; i < maxIterations && p.x > 0; i++, p = [self updatingCell] ) {
// Do something interesting with this NSPoint
}

I’ve used the above approach several times, letting me compact code when in loops. However, the next trick presented by Parmanoir, developer of CocoaNav, is one I never thought of and the article gives a wonderful explanation of the comma operator in C and family.

1
2

// Log and return
if (error) return NSLog(@"MyFunction failed with error: %@", error), NO;

Still in beta, v1.5 introduces several new features including:

• Support for .pkg files
• Support for receiving demographic information from users
• Can update bundles, not restricted to just .app applications
• Minimum system version checking for users
• Garbage Collection
• Better version comparison algorithm
• DSA instead of less secure MD5
• Won’t update if app is running from a disk image

Andy has also taken the time to dramatically simplify the Sparkle site itself, and move the project over to Launchpad for easier development. Be sure to check out this new version to incorporate into your apps to gain the new features.

Sparkle Page

Sparkle on LaunchPad

The community has been hard at work and before now the most notable project being developed was by the Shiira web browser team, called BlkAppKit.

Tim Davis from Binary Method has been hard at work creating an awesome framework of HUD controls. Unlike the few other kits already out there, BGHUD AppKit does not use images to create the controls. None at all. These controls are beautiful and ready for Resolution Independence. Also worth noting is the shear number of controls already available, the speed with which the developer is creating new ones and the community that is using it, including RealMac Software, developers of RapidWeaver.

Another unique feature to the BGHUD AppKit is theming. Tim has taken an interesting approach to theming the controls to better match your application, if you need something different than the default HUD style. Place your controls on the windows and set the custom class, as you would with any other custom control in Interface Builder. Building and Running the application at this time will show no difference. However, if you initiate an object controller, of either “BGThemeManager” or “BGGradientTheme” and connect the outlet of every control to this object, your controls are now updated. Using the “BGGradientTheme” gives you the default appearance, while using the theme manager lets you customize the controls.

This seems a little tedious upfront, especially if you want to just use the default appearance. However, if you needed to change the overall appearance of your application, instead of subclassing all of these controls, you can simply subclass and use the update theme manager. Therefore, it does pay off in that respect.

My personal recommendation: If I don’t set the outlet on my control to a theme manager, then use the default HUD behavior. That way I don’t even have to worry with it. But, the work put into this framework is phenomenal and it seems that Tim isn’t sleeping until he implements every last single available control perfectly. If you need HUD controls in your project, I strongly believe this is the best framework available. The work is beautiful, it’s under heavy and active development, the developer is responsive to requests, it’s easily theme-able, and all the controls are already Resolution Independent.

Update: Tim has already read the post and really liked my recommendation for simplifying the ThemeManager behavior. Even better, he’s already implemented the change into the framework, so checking out subsequent version from SVN are now more friendly. Check out his blog for more details and to get your copy.

BGHUD AppKit Home

Shiira BlkAppKit

RealMac Software

My previous post on HUD controls in Leopard

From the Versions website:

Whether you’re a designer, developer, editor or project manager, chances are you already have plenty on your mind. Versions saves you the hassle and makes working with Subversion easy for your entire team. Thanks to Versions’ clear-cut approach to Subversion, novices and power users alike will enjoy using it. And if you haven’t moved to Subversion yet, now is the time.

You can easily create a UITextField to handle text input. The interesting part comes into play because there is a keyboard associated with the UITextField, obviously for providing input. That keyboard can be specified what action to do when the return button is pressed, giving a way to process the text. The cool part is, it’s extremely easy for developers to use the many different types of keyboards present on the iPhone. For example, there is a numeric keyboard, the default keyboard, one for entering URLs, one for entering email addresses, and so on. Below is a quick code block, adapted from the “Hello World” example.

aTextField.borderStyle = UITextFieldBorderStyleRounded;
aTextField.contentVerticalAlignment = UIControlContentVerticalAlignmentCenter;
aTextField.placeholder = @”Your name”;
aTextField.keyboardType = UIKeyboardTypeEmailAddress;

Some other examples of keyboard types:

• UIKeyboardTypeDefault
• UIKeyboardTypeNamePhonePad
• UIKeyboardTypeNumberPad
• UIKeyboardTypeNumbersAndPunctuation
• UIKeyboardTypePhonePad
• UIKeyboardTypeURL

Cocoa is My Girlfriend

On the Big Nerd Ranch website, the release is marked simply as “Spring 2008″. However, the publishing date on Amazon is marked as June 2, 2008. Pre-ordering through Amazon will guarantee you receive your copy as soon as it’s available.

Found via | Ranchero.com

Fast Enumeration

Cocoa now implements a foreach() type of loop, which cleans up code tremendously. Iterating over an array or dictionary is pretty common stuff and being able to condense code from:

NSEnumerator *e = [myArray objectEnumerator];
id item;
while ( item = [e nextObject] ) {
NSLog(@"%@", [item printSomething]);
}

to a more elegant:

id item;
for ( item in myArray ) {
NSlog(@"%@", [item printSomething]);
}

Properties

Properties are a wonderful addition to Cocoa and essentially eliminate writing basic accessor methods for your objects (setters and getters).

@interface Song : NSObject { 
NSString* title; 
Artist* artist; 
NSDate* dateAdded; 
} 
@property(readwrite, copy)NSString* title; 
@property(readwrite, copy)Artist* artist; 
@property(readwrite, copy)NSDate* dateAdded; 
@implementation Song @synthesize title, artist, dateAdded;

The ObjC 2.0 compiler gives you extreme flexibility with properties, beyond just the basic use of accessors here. You can specify a property to be readonly instead of readwrite, or to retain or assign instead of copy.

@dynamic title; -(NSString* )title { }

The above would require you to implement the method yourself, letting the compiler know you are handling that.

NSTreeNode

Not a feature of the ObjC language, but certainly a nice addition to help using NSTreeController. NSTreeNode is a wrapper object which aids in creating trees. Just create a NSTreeNode and add other NSTreeNode objects to the -mutableChildNodes array and you are on your way to a tree. Binding this tree to a NSTreeController is relatively simple as well. Of note, remember that if you are using NSOutlineView delegate methods, you receive a NSTreeNode object now, so you must use -representedObject on “id item”.

A further note, when using the “selection” controller key on a NSTreeController, the controller returns an array of NSTreeControllerProxyObjects. Either call -self on the NSTreeControllerProxyObject or when using bindings (binding a second NSTreeController to the “selection” of the first one) remember to use “selection” with model key path of “self”. I don’t believe this is documented anywhere, but using “self” clears up a whole world of heartache and gives you the actual NSTreeNode instead of the NSTreeControllerProxyObject.

Interface Builder

It took some getting used to, but recall that you have to drop a NSObject (blue cube) from the IB Library and set the custom class to initiate an object in IB 3. The old method of “Initiate Class” or whatever from the menu isn’t available. Also remember that IB Palettes don’t work with IB 3, you will need to find (or create) IB Plugins.

Core Animation

Recall that the -orderIn and -orderOut options in IB are for adding and removing subviews to the selected view in IB (-setWantsLayer:YES). So NSTabView will not magically transition views in and out unless you are programatically creating new tabs and such.

That was just a quick list of the headache I endured over the last few weeks adjusting to Leopard and mainly spending lots of time with trees in Cocoa.

I’d love to hear your thoughts about ObjC 2.0 additions, whether it’s garbage collection or something more minute!

HUD (Heads Up Display) are those gorgeous black windows that have started popping up all over Mac applications. Especially in iPhoto and Aperture, as well as Pages and more, these beautiful windows serve a specific purpose. Apple went so far as to finally include a HUD window in Interface Builder, so that developers don’t have to use a hacked together version (Interface Designers like uniformity, so it is better when everyone is using the same thing vs 15 different versions of the same window, which is the case now). So, I naturally assumed that Apple also provided HUD versions of buttons, lists, and more, to match this window.

I was wrong.

I can create this nice window with no effort now, but as soon as I place something on it, it looks stupid. The simple screenshots above illustrates the effect. (Also notice the differences in the window itself. See how big of a difference there is just on the lines at the bottom right of the window where you resize? Now imagine that every time I had to write an application, I had to make this from scratch. With all the Mac developers out there, you can imagine that there are lots of variations). I sure hope that Apple fixes this soon and doesn’t wait until 10.6 and a new window style to add this for developers.

What is interesting here is the little gem I found on the website in some sample code and open-source frameworks. The Bruji team released a framework allowing Cocoa developers to grab barcodes from an internal or external iSight or other firewire camera.

Download the source here.

Multicore Support

This is a major improvement for all Intel Mac users. Even first generation Macbook users and all the early Intel adopters should see performance gains in Leopard. Tiger was designed to run on one-core processors, which was fine at the time. However, all Intel Macs have at least 2 cores, with the high-end Mac Pro having 8 all together. Can you see the reasoning here? With Leopard optimized to make the best use of all those cores, and new ways for developers to further improve their programs (read more about NSOperation and NSOperationQueue ), Leopard should see a significant performance improvement.

Safari 3 for Windows

I’m not sure if Safari 3 for Windows is a secret feature of Leopard or not. I’m actually using the beta on Windows right now to write this article and so far it has behaved itself rather nicely. The attention to detail in making Safari for Windows just like Safari on Mac is incredible. Even the contextual menu (right-click) gives you the same options, such as "Save Image to Desktop". I mean, that’s just crazy.

Boot Camp

Most were hoping for Jobs to announce some amazing virtualization technology built right in to Leopard. I’m rather glad that this approach wasn’t taken for a few reasons. First, there are already two options on the market today: Parallels and VMWare. Parallels has proven they are dedicated to providing new features and constantly improving the software. I love Apple, but if they incorporated virtualization into Leopard, the updates would be few and far between when compared to Parallels. Just check out Parallels new 3.0 release to get what I mean.

What Jobs did tell us is that Boot Camp will allow you to switch between Windows and Leopard faster. Quick example: If you’re in Leopard and need to switch to Windows, be sure to use the Restart in Windows option from the Apple Menu. This will place Leopard into a hibernating state and, if you’ve previously used Windows, should start Windows from where you left off. This will make the process much more relatable to Suspending a virtual machine in Parallels.

New Desktop

The redesigned Desktop is touted as the number one feature for Leopard. However, I don’t see anything revolutionary or amazing about it.

• The Menu Bar has a new look. It’s very comparable to the trashy-translucent taskbar in Vista. I’m not excited, but I’ll put my concerns aside until I see it in person.
• The Dock has seen a facelift. Your icons now sit on a silver background that reflects any window behind it, making it look 3D. Might look cool, but is that really a feature?
• No blue background. I’m very sad. For me, the Mac experience has always included a new, cool Aqua background with every major release. Jobs explicitly stated that no one ever uses these and it’s a waste of time. I like them Steve!
• Anyone else notice that the hard drive icon wasn’t on the Desktop. Very minimalist look.
• Stacks. I’m actually fairly excited about this new feature. Basically, it’s a way to organize your files and preview the contents in a cool new way, without opening a Finder window. This was originally rumored to be included in Panther, then in Tiger, and now in Leopard. Nice to see it finally made it in. All the demos show the stacks being used in the Dock. I wonder if we’ll be able to use them other places. I love the concept, but won’t use it that much if I have to use them only in the Dock.

EA Games

Not really a feature of Leopard itself, but an important announcement for the Mac anyway. Traditionally, game titles were released for console and PC and then ported over to Mac several months later, if at all. EA announced during the keynote that they are committed to delivering new titles to the Mac alongside the console and PC releases. As time progresses, the Mac should shun its reputation as the “non-gaming” platform.

Core Animation

Remember when I said we would are going to see some awesome applications that are built as Leopard-only? The main reason for that is this technology right here. Core Animation let’s developers create very fluid, interactive, and attractive interfaces with ease. There were several demos of the technology at WWDC last year and I’m sure it’s a main focus this year as well. A quick example was given in Monday’s keynote. If you’ve ever seen the AppleTV intro movie, you’re on the right track. Very cool applications will follow.

Improved Developer Tools

The mac is only as strong as its developers and Apple realizes this. So with Leopard, developers get a XCode 3, sporting tons of new features including refactoring (even in nib files) and function collapsing, XRay for seeing exactly what your app is doing at any time, DTrace, Dashcode for creating widgets, and Interface Builder 3. All of those mentioned are huge updates and improvements, and XRay and Dashcode are new applications all together. XRay will make performance tuning your applications so much easier. I love you Apple!

Back to my Mac

Dot Mac didn’t see any other improvements besides this one feature as far as I can tell. Basically, you enable a setting on all your Macs and those computers talk with the dot Mac service. Then, if you’re on the road with your laptop and realize that you need something off any of your other computers, you fire up the Finder and they appear in the sidebar for you. Works just like you’re on your home network. Details haven’t been released about the service working with firewalls or routers. I’d imagine an Airport Base Station update might introduce this functionality at a later time.

New Finder

I think everyone was hoping for a new Finder. I personally feel disappointed however. The Finder does have a new interface, but then again, it’s not new. It’s just iTunes for your files. Coverflow in the Finder looks remotely useful, but I’m not sure just how much I’ll use it. The overall appearance seems a little drab, especially if you’re already not a fan of the iTunes 7 look. That look will be everywhere in Leopard. No hiding. It will find you. Also of note is a report that the new Finder is the first one to be scrapped and written in Cocoa. And because of the multitude of updates to Cocoa, including multicore and 64-bit support, performance is drastically improved. At least that part is welcome.

Spaces

Spaces is just Apple’s incarnation of a virtual desktop manager. Granted it’s a very nice one, but still nothing that wasn’t available before Leopard (see Virtue). Spaces will allow you to group application windows in “spaces” so you can better organize screen clutter. It’s a natural extension to Expose and should be very useful.

Quick Look

This new technology is everywhere in Leopard. If you are in the new Finder and want to quickly preview a Word, Excel, PDF, or some other common file, just tap the spacebar and a black translucent window pops up letting you scroll through the document with ease. It will even let you preview pictures and movies in full screen mode. Which raises the question: Will full-screen mode be enabled without Quicktime Pro in Leopard?

Quick Look is a plug-in architecture so developers can easily add support for their applications, just like Spotlight plugins were everywhere after Tiger’s release. This will also allow these documents to work with the Finder’s Cover Flow view. Therefore if OminGroup releases a Quick Look plugin for OmniOutliner, you will be able to quickly preview the file without opening OmniOutlier from right within the Finder and also be able to scroll through the document in Cover Flow view. Pretty cool stuff.

Time Machine

If you haven’t heard of Time Machine by now, you’ve lived in a hole my friend. Basically, this is Apple’s very pretty way of dealing with backup software. You attach an external disc, Leopard asks if you want to enable Time Machine, and from there you’re all set. If you’re ever missing a file, start Time Machine and you get this spacial 3D view of your files and once you locate the old file, you just “recover” it to the present. Very easy representation and should be accessible to more users as well.

Front Row and DVD Player

These weren’t talked about in the keynote, but are mentioned on the Apple website. Front Row is now like the AppleTV interface. I’m not quite as excited because I find the current Front Row interface to be superior to the one in the AppleTV, but that’s the update. DVD player also sports more HUD style windows and several new features for bookmarking playback and more.

Parental Controls

Parental controls have been beefed up in Leopard as well. Now Leopard can filter out websites based on content and parents can set time limits on the computer. The time limits can be based on usage, say a one hour limit, and also for times the child can use the computer. Useful for setting bedtimes and such. I’m not sure if Vista has anything like this or not.

Photo Booth

If you read the fine print, Photo Booth has seen some updates as well. There are more effects to use on your pictures, backdrops, “burst” pictures, and Photo Booth now does video too. The “burst” pictures are a quick series of 4 pictures in succession which can be made into an animation. And the fact that Photo Booth does video is just cool. Applying all those effects to your video in a snap will be even more fun at parties!

iChat

iChat has seen some major updates, many of those mentioned above in Photo Booth. Backdrops, like sitting in front of a green-screen, are a touted feature. Photo Booth effects are now supported in iChat as well as tabbed chats to clean up window clutter. iChat Theater is a new technology that lets you share photos, presentations and more in a video chat, just like if you were giving a Keynote presentation in person. Also of note is the following text from the Apple website: “Chat works with AIM, the largest instant messaging community in the U.S. You and your buddies can be either AIM or .Mac users. Text, audio, and video chat whether your buddies use a Mac or PC. Sign in with your AIM account and all your buddies appear in your iChat buddy list”. Does the Tiger version of iChat support video and audio chats with PC users? I’m pretty sure it doesn’t and this is a very welcome feature!

Conclusion

There are several other features that I didn’t discuss, such as the new Mail and iCal. You can read more on all the features in Leopard here. The Apple website has finally seen a facelift and looks fairly impressive, so check that out as well. If you’re interested, the WWDC keynote is available online and there are several videos and images showing the new applications and features available in Leopard.

Let me know your impressions about Leopard. With only a few months until the release, we are in the final stretch.

I have a class called MBHand that contains a NSMutableArray as one of the key objects. So, on init, I need to set that array up to use. I thought I had that setup right. The error crept in with the following message:

-[NSCFArray addObject:]: mutating method sent to immutable object

Got to thinking and that leads back to my init method. I looked at my code and I had used the rather normal way of

1
2
3
4
5
6

- (void)setArray:(NSMutableArray *)newArray {
	if ( array != newArray ) {
		[array release];
		array = [newArray copy];
	}
}

This method looked good, but I used array = [[NSMubableArray array] retain]; and it works fine. Therefore, it was in the setter method above. Yep, after looking at that, it hit me. I wasn’t making a mutable copy of the array passed it. Needs to have “array = [newArray mutableCopy]; ” and it works like a charm!

1
2
3
4
5
6

- (void)setArray:(NSMutableArray *)newArray {
	if ( array != newArray ) {
		[array release];
		array = [newArray mutableCopy];
	}
}

Just a tip for all those newbies out there like me!

A lot has happened with the Mac community in the last month or so, I don’t have the time or memory to accurately recall everything that has transpired. Of note, however, is that the AppleTVs have shipped and Leopard should be ready for a release within the next few months. Something worth getting excited over!

School and just life in general has been pretty insane these last few weeks. Everything is starting to die down a bit, but I’m trying to take some more personal time to just enjoy life than I have in the past, and that tends to be very time consuming in itself. I have had some time to tie up a lot of loose ends and get started in a few other areas, and I’d like to share that.

Photos
I’m working through a basic photography book and looking to book a class this summer on photography. I have also been using Aperture for several months now and it has been in the queue for a review. Since it will still be several weeks before I get around to reviewing it, I just thought I would say that it is an incredible piece of software and I especially love the vaults feature. More to come on that topic later. I have posted a gallery of my favorite pictures from my trip to Charleston, SC as well as some other general photos I like online. You can view those here. Paul, I’d especially like any comments as you have a photography blog of your own.

Software
Let me just start out by saying that my current computer class has been a real challenge. Computer Organization is the name of the game and the class focuses on digital logic, processor performance and pipelining, memory management, and the ARM assembly language. Just to say up front, I despise writing in assembly. Read in between the lines. HATE it. However, I have learned a lot and the class has been a real challenge.

Also of note here is that I have stopped development on Viewer and removed it from the site. I put a lot of work into the project, but in the end it was very sloppy and poorly written. Without the time or motivation to rework my previous work and with a lack of general interest, I’ve put it on the back burner and left it to die. On a rainy day with time on my hands and an interest in revising and revisiting past projects, I might take it up again, but I doubt it.

So the good news here, I’ve started a new project! I’ve worked through the general game-play logic and written my base code or a Phase 10-like game. I love the card game and just went through and realized that I could create almost everything needed on my own, except for the interface. So, in a few weeks I should have basic Terminal-based game play down and then I will embark on an adventure of learning all about custom drawing in Cocoa!

Late Night Cocoa has just released its third episode detailing the use of web services with Cocoa. Overall this is an awesome podcast so far, getting support from major developers in the community as they guest on the show to talk about a specific subject that they are really knowledgeable about.

I apologize for being very rude and not backing up my comment with more reasoning. I had listened to a show or two almost a year ago and didn’t care for it. I have since listened to a few more episodes to make better judgement. While I still don’t care for the show as much, that should not stop anyone from listening on their own account. CocoaRadio has very pertinent information.

This app has been in “beta” testing for the last few months to some people that I know online. They have used it and provided useful feedback and expressed an interest in it. Now that the list of users has grown somewhat, I have taken up the courage to release it to the public. Let me start off by saying that this is a controversial piece of software if there ever was one. It will surely offend several of you for various moral reasons and because of that I don’t wish to discuss it anymore on the main page. If your interest is intrigued, and you are not easily offended or won’t take me hostage and call me dirty names, you can read more about the application, the license agreement, and download a copy with source at the link below.

Read more about Viewer here.

Read on to see some snippets of code with an explanation and download a sample project.

In this first bit, we are filtering out only keys pressed that are part of the numeric keypad.
Arrow keys fall into this category. The string is a string of keys pressed.

Now we have a char that represents the key pressed, an arrow key still

The above deals with the user hitting the up arrow key and the below deals with user hitting the down arrow key

Essentially, I set a NSTextField’s custom class to my StepperTextField. Then I set the outlet from the text field to a NSStepper I already have configured in the interface, correct with maxValue and minValue set for the NSStepper in IB. Of note, I use the keyUp: method because the keyDown: method is being captured by the field editor inside the NSTextField, so I never catch those events. This seemed like the simplest approach to me. Now when the user hits a down arrow, the number will decrement by one. An up arrow increments it by one. If the value will be over the maxValue, it gets set to 1. If it will be less than 1, it gets set to the maxValue.

Download a sample project with plenty of comments here.

The thing is I needed to bind a NSTextField to some values from an array controller. Not that big of a deal setting them up in code, but then I decided that to simplify my life, I would need to bind them with the “displayPatternValueX” option, instead of just binding to :@”value”. So, without further ado, here is a snippet of code that produces a single textfield on the window bound to my controller with a sorta label before the actual bound value. It’s almost magic!

1
2
3
4
5
6
7
8
9
10
11
12
13

/* Rating */
NSTextField *ratingField = [[NSTextField alloc] initWithFrame:NSMakeRect(10+20, y_position – 20 – 50, windowSize.width-(2*(10+20)), textHeight+5)];
 
[[window contentView] addSubview:ratingField];
[ratingField setEditable:NO];
[ratingField setSelectable:NO];
[ratingField setFont:[NSFont systemFontOfSize:textHeight]];
[ratingField setTextColor:[NSColor whiteColor]];
 
[ratingField setDrawsBackground:NO];
[ratingField setBordered:NO];
[ratingField setStringValue:@"%{value}@ Bookmarks"];
[ratingField bind:@"displayPatternValue1" toObject: [parent BookmarksController] withKeyPath:@”selection.rating” options:[NSDictionary dictionaryWithObject: [NSString stringWithString:@"Rating: %{value1}@ "] forKey:@”NSDisplayPattern”]];

Just need to keep in mind that the magic code does what you can easily do in IB. Just to clarify, this is in a separate NIB and I’m essentially using File’s Owner as my binding object, except I used [parent BookmarksController] to access this. In IB I would have bound to File’s Owner with a modelKeyPath of @”BookmarksController.selection.bookmarkName” to get the same result. Tricky part was getting the NSDictionary setup using the constant @”NSDisplayPattern” to get the pattern to work.

1

[ratingField bind:@"displayPatternValue1" toObject: [parent BookmarksController] withKeyPath:@"selection.rating" options:[NSDictionary dictionaryWithObject: [NSString stringWithString:@"Rating: %{value1}@ "] forKey:@"NSDisplayPattern"]];

Hope that all helps someone since I can’t find any documentation on the subject online. There’s plenty to explain it for IB, but there aren’t any examples of doing it by hand. Thought I would throw that out there.

Conceptually, the user will enter a search string in the search box, something like “Jo”. Now, you will need to find every object in your table that has “jo” in it. You get to choose the amount of control, as a programmer, you put into this. If you want to be very kind, you can add a drop-down menu that the user clicks to search for “Jo” just in the name field, for example. However, I feel that most people are comfortable enough with just filtering (ie, not full-scale searching), we will simply search every item in our object to find matches. Still with me?

For example (‘Por Exemplo’ comes to mind..) :

Imagine we are creating an address book-like app (hint-hint) and each person in our address book has four pieces of data each. Each person has a name, a screen name, an url, and an image associated with them. We certainly can’t filter the images, but we would like to search through the names, screen names, and urls. So, let’s figure out what we’re going to do.

First, you’re going to setup your interface in IB. I’m not going to take the time to go through all of this, but you drop a NSSearchField onto your window and hook up the bindings with the “predicate” option farther down the Inspector window. I have an array controller of “Person” objects, so I want to set my bindings as “PeopleController” as my source (same as the data source for my tableview), filterPredicate, and the model key as “personName” (the string that holds the name in a Person object, doesn’t really matter, but you must fill in a valid KVC value here).

I have also subclassed out the standard NSArrayController to provide filtering support. I connect my “search” IBAction to my NSSearchField, to actually implement the searching. I also like the instant filtering style, so I select the “Sends Search String Immediately” attribute in IB for my NSSearchField.

That ties up the interface stuff, now we need to actually figure out how we are going so sort. The concept behind this is we go through every object in the original array (that supplies the table) and see if it matches our search criteria. If it does match, we’ll throw it into a new array. When we’ve searched everything, we’ll return this array to the table so it can display it as the search results. When the user is done searching, we release that array and return the table back to the original array that holds all of our data. Let’s start searching!

Code for the filtering Array Controller

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

- (void)search:(id)sender {
	[self setSearchString:[sender stringValue]];
	[self rearrangeObjects];
}
 
- (NSArray *)arrangeObjects:(NSArray *)objects {
 
	if ( searchString == nil || [searchString isEqualToString:@""] ) {
		newObject = nil;
		return [super arrangeObjects:objects];
	}
 
	/*
		Create array of objects that match search string.
		Also add any newly-created object unconditionally:
		(a) You’ll get an error if a newly-added object isn’t added to arrangedObjects.
		(b) The user will see newly-added objects even if they don’t match the search term.
	*/
 
	NSMutableArray* matchedObjects = [NSMutableArray arrayWithCapacity:[objects count]];
 
	// case-insensitive search
	NSString *lowerSearch = [searchString lowercaseString];
 
	NSEnumerator *oEnum = [objects objectEnumerator];
	id item;
 
	while (item = [oEnum nextObject]) {
 
		// if the item has just been created, add it unconditionally
		if (item == newObject) {
			[matchedObjects addObject:item];
			newObject = nil;
		} else {
 
			NSString *lowerName = [[item valueForKeyPath:@"personName"] lowercaseString];
			NSString *lowerScreenName = [[item valueForKeyPath:@"personScreenName"] lowercaseString];
			NSString *lowerUrl = [[item valueForKeyPath:@"personUrl"] lowercaseString];
 
			if ( lowerName != NULL && [lowerName rangeOfString:lowerSearch].location != NSNotFound) {
				[matchedObjects addObject:item];
			} else if ( lowerScreenName != NULL && [lowerScreenName rangeOfString:lowerSearch].location != NSNotFound ) {
				[matchedObjects addObject:item];
			} else if ( lowerUrl != NULL && [lowerUrl rangeOfString:lowerSearch].location != NSNotFound ) {
				[matchedObjects addObject:item];
			}
		}
	}
	return [super arrangeObjects:matchedObjects];
}

The code above goes through each object in the array and pulls out a string for the name, url, and screen name. It compares the entered search string to each of those strings, and if it matches, adds it to the array we return that has the matchedObjects. Of note here is that we check for a NULL string from the object because if we don’t, the object will show up in the results even though it shouldn’t.

I think that was enough of an intro to searching. Let me know if you would like to hear more about implementing the ‘Recent Search Items’ list, or searching by category. Comments are welcome. If you’re interested in a working XCode project with the code, let me know and I might throw one together and post it online.

UPDATE: I didn’t originally provide enough information about this controller, so here are a few links and documentation. Apple has documentation on this subject with almost the identical sample code that is published by mmalc below. You can read the documentation here.

Download mmalc’s source (pretty much what is in the documenation) here.  This is a sample project, so it’s nice to look at as well.  Of note, if you want the iTunes, Spotlight-like behavior of instant results (a true “filtering” action, vs searching), go into Interface Builder, select the NSSearchField and for it’s attributes, check the box with “Sends search string immediately”.  A nice example. Check out his website with lots of other good bindings related examples is here.

I’m sure there are some seasoned Cocoa programmers out there wondering about my confusion over this class, but it was kinda scary. I’m very comfortable writing plain C and feel very powerful because I know what is going on and if I get a little stumped, I can always hack something homemade together. That’s not really the way it is a lot of times with Cocoa, there is so much already available you don’t have to hack it together and it would be better if you didn’t. So back to NSNumbers.

Just to get your brains working this morning, here was a preview if() statement I had in my code, just checking to see if the number that the user entered in an NSTextField was of appropriate range.

1
2
3

if ( [startingValue intValue] >= 300 || startingValueInt <= 0) {
	// Do something
}

This doesn’t seem too bad at all to me. I need the value to be between 1 and 300. However, I decided to get a bit more specific with my code and created an NSArray of NSNumbers holding the upper limits to check against in each specific case. This was used to add that in the Category object itself and then you come up with the following if statement, if you will:

1
2
3
4

// This was just a very lengthy way of using NSNumbers to make sure that the entered value was in proper range
if ( [[NSNumber numberWithInt:startingValueInt] compare: [[categories objectAtIndex: [CategoriesController selectionIndex]] categoryMaxValue]] == NSOrderedDescending || startingValueInt <= 0) {
	// Do something
}

Now granted, you could still use a regular “>=” operator here by calling the “- intValue” method on the NSNumbers I’m using. However, I thought that I would go all out and even use an NSComparisonResult as well. Just goes to show you that you can look smart and your code do nothing at all. Another snippet of code is below for those that wondered about getting all of my NSNumbers into my Category array.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

// Setup another array with just the ranges for each category — This is the max array, all mins are zero
// Note that I have setup similar arrays holding the names and urls that I’m sticking into each Category ‘c’
 
NSArray* maxes = [NSArray arrayWithObjects:[NSNumber numberWithInt:445], [NSNumber numberWithInt: 265],
	[NSNumber numberWithInt:221], [NSNumber numberWithInt:106], [NSNumber numberWithInt:69],
	[NSNumber numberWithInt:21], [NSNumber numberWithInt:229], [NSNumber numberWithInt:69],
	[NSNumber numberWithInt:322], [NSNumber numberWithInt:266], [NSNumber numberWithInt:138],
	[NSNumber numberWithInt:320], [NSNumber numberWithInt:107], [NSNumber numberWithInt:99],
	[NSNumber numberWithInt:313], nil];
 
// Now need to create the categories, using each piece to make one, and insert it into the categories array
for (NSInteger i = 0; i < [names count]; i++) {
	c = [Category new];
	[c setCategoryUrl: [urls objectAtIndex:i]];
	[c setCategoryName:[names objectAtIndex:i]];
	[c setCategoryMaxValue:[maxes objectAtIndex:i]];
	[categories insertObject: c atIndex: i];
}

More Reading | Cocoa Dev Central