TweetFollow Us on Twitter

The Road to Code: One for the Archives

Volume Number: 24 (2008)
Issue Number: 07
Column Tag: The Road to Code

The Road to Code: One for the Archives

Archiving objects and document—based applications

by Dave Dribin

One Year Later

This is the thirteenth article in the Road to Code column: happy one—year anniversary! We've covered a lot of ground in the last year, but we've still got the pedal to the metal. There's plenty of pavement left to cover!

In last month's article, I said that we'd talk more about NSTableView in this article, but I've decided to put that topic off for a bit. This month we're going to cover document—based applications, which includes how to save and open – or load – custom file types.

Document—based applications are a class of Mac OS X applications that allow the user to create, save, and open documents. Since this is a common type of application, Cocoa provides a lot of the common architecture, or plumbing, to minimize the amount of code the developer has to write.

Archiving

Before we talk about the user interface help that Cocoa provides for document—based applications, we're going to start from the back—end and talk about saving and loading objects. The Foundation framework provides a mechanism for converting a collection of objects to a sequence of bytes called archiving. Once we have the objects as a sequence of bytes, these bytes can be stored on disk or even sent across the network. To recreate the collection of objects from the sequence of bytes, you can use a mechanism called unarchiving. In Java, this conversion of objects to and from bytes is called serialization.

Before we get into the nitty—gritty, we need to cover some more terminology. A collection of objects has a fancy name called object graph. An object graph is a collection of objects, along with the relationship between the objects. An object graph can be represented as a diagram showing each object, with arrows indicating relationships. For example, if we have an NSMutableArray object that contains three Rectangle objects, the object graph would look like Figure 1. The arrows point from the array to the rectangles because the array maintains a reference to each of its members. Often, an object graph contains one object that is at the top of the graph called the root object. In this case, the array is the root object.


Figure 1: Simple object graph

Recall from the article about inheritance, You Have Your Mother's Eyes, that Objective—C has a concept called a protocol. As a quick refresher, protocols are just like class interface declarations, except that there are no instance variables. Protocols also have no implementation. Other classes may implement protocols, and these classes must provide implementations to all required methods. Protocols are used to ensure a class implements a set of methods.

Encoding

Foundation's archiving and unarchiving works on object graphs. Not all objects may be archived, however. Only objects that implement the NSCoding protocol may be archived and unarchived. The NSCoding protocol is shown in Listing 1.

Listing 1: NSCoding protocol

@protocol NSCoding
— (void)encodeWithCoder:(NSCoder *)coder;
— (id)initWithCoder:(NSCoder *)decoder;
@end

The encodeWithCoder: method is used for archiving while initWithCoder: is used for unarchiving. You'll notice that both of these methods use a class called NSCoder. NSCoder and its subclasses are responsible for the actual transformation to and from bytes. An example will help clear this up. Let's modify our Rectangle class to work with archiving. The most recent interface for Rectangle from the last article is shown in Listing 2.

Listing 2: Rectangle interface, without NSCoding support

#import <Foundation/Foundation.h>
@interface Rectangle : NSObject
{
    float _leftX;
    float _bottomY;
    float _width;
    float _height;
}
@property float leftX;
@property float bottomY;
@property float width;
@property float height;
@property (readonly) float area;
@property (readonly) float perimeter;
— (id)    initWithLeftX: (float) leftX
                bottomY: (float) bottomY
                 rightX: (float) rightX
                   topY: (float) topY;
@end

Since Rectangle's superclass, NSObject, does not implement the NSCoding protocol, the first step is to tell the compiler that we want to implement the NSCoding by changing the @interface declaration:

@interface Rectangle : NSObject <NSCoding>

The rest of the header file stays the same. We must now implement encodeWithCoder: and initWithCoder: or else the compiler will warn us about an incomplete implementation. This warning is very helpful and one of the benefits of statically typed languages. Okay, so how do we implement these methods? Let's start with archiving and encodeWithCoder:.

When encodeWithCoder: is called on your object, you need to save all your vital instance variables by encoding their values in the coder. Vital instance variables are all instance variables that cannot be calculated in any way. For our Rectangle class, all four instance variables are vital, and we must encode them all. Our implementation would be:

— (void) encodeWithCoder: (NSCoder *) coder
{
    [coder encodeFloat: _leftX forKey: @"leftX"];
    [coder encodeFloat: _bottomY forKey: @"bottomY"];
    [coder encodeFloat: _width forKey: @"width"];
    [coder encodeFloat: _height forKey: @"height"];
}

We encode each of our instance variables, one by one, using the encodeFloat:forKey: method of NSCoder. We are using a variant of encoding called keyed encoding. Keyed encoding associates each value with a string key, or name, similar to how NSDictionary maps keys and values. All keys in an inheritance chain must be unique. This means your key must not only be unique to all your encoded values, but also to any of your superclasses' encoded values. The simplest way to ensure this is to use the name of the instance variable. I tend to leave off the underscore prefix, but that's just old habit. Separate inheritance chains can reuse keys. For example a Bitmap class that inherits from NSObject could also encode values using the width and height keys without conflict from Rectangle.

There are encoding methods for all primitive types and for other objects that implement the NSCoding protocol. Many of the classes in the Foundation framework such as strings, arrays, and dictionaries implement NSCoding so you should be able to easily encode all of your instance variables. Don't forget that if your superclass implements NSCoding, you must call encodeWithCoder: on the superclass before you encode your instance variables to make sure that all of its instance variables are encoded, as well:

— (void) encodeWithCoder: (NSCoder *) coder
{
    [super encodeWithCoder: coder];
    //...
}

As a side note, NSCoder does allow encoding values without keys, called non—keyed encoding, however this method is no longer recommended. Keyed encoding was introduced in Mac OS X 10.2 and non—keyed encoding should only be used for legacy applications that either need to run on or interoperate with old versions of software. Since we are writing an application for Mac OS X 10.5, we only use keyed encoding.

To use this method, we need an NSCoder instance. NSCoder is an abstract class, meaning that you cannot create instances of it directly; rather, you should use one of its concrete subclasses. The main subclass for encoding is NSKeyedArchiver, and typically, you use one of its class methods that do all the hard work for you:

    Rectangle * rectangle = ...;
    NSData * data =
        [NSKeyedArchiver archivedDataWithRootObject: rectangle];

The NSData class is part of the Foundation framework and it holds a sequence of bytes. Once you have the rectangle represented as an NSData instance, you can write it to disk or send it over a network.

Decoding

Now that we've covered archiving objects by encoding objects with an NSCoder instance, we need to go the other way around. Unarchiving objects takes a sequence of bytes and creates new instances of the encoded objects. To support unarchiving, our class must implement the initWithCoder: method. For our Rectangle class, there are no real surprises. We must decode each instance variable using the same key we used for encoding:

— (id) initWithCoder: (NSCoder *) decoder
{ 
    self = [super init];
    if (self == nil)
        return nil;
    
    _leftX = [decoder decodeFloatForKey: @"leftX"];
    _bottomY = [decoder decodeFloatForKey: @"bottomY"];
    _width = [decoder decodeFloatForKey: @"width"];
    _height = [decoder decodeFloatForKey: @"height"];
    
    return self;
}

Note that this is a constructor method and thus creates a new instance of our object. Since our superclass is NSObject and it does not implement NSCoding, we just call init. However, if your superclass also supports NSCoding, be sure to call initWithCoder: instead:

— (id) initWithCoder: (NSCoder *) decoder
{ 
    self = [super initWithCoder: decoder];
    //...
}

While you can decode the keys in any order, it's imperative that the keys match up between your encoding and decoding. Also, if you decode any objects, you must remember to retain them if you keep strong references to them as the decodeObjectForKey: returns autoreleased objects. Of course, if you are using garbage collection, you don't have to worry about the retains.

To unarchive objects from a sequence bytes created with NSKeyedArchiver, you should use the NSKeyedUnarchiver, which is also a concrete subclass of NSCoder. It has a convenient class method to unarchive an object directly from an NSData instance:

    NSData * data = ...;
    Rectangle * rectangle =
        [NSKeyedUnarchiver unarchiveObjectWithData: data];

Now that our Rectangle class fully implements the NSCoding protocol, we can convert instances of our class to a sequence of bytes and back again.

Archiving objects has many uses. For example, Interface Builder nib files are really just archived objects. The object graph for your entire GUI is created by Interface Builder and saved as a nib file. When your application runs, the objects are unarchived and ready to use. We will also be using this new ability to create custom rectangle documents using a document—based application.

You may be wondering what happens if we add or remove instance variables to our rectangle class? And what if the newer rectangle class needs to read archives saved by the older rectangle class? The way to handle this is with a technique called versioning. Versioning is a bit advanced to cover in full here, but I just wanted to let you know that it is possible to handle this situation. Read Apple's developer documentation for full details.

Document—Based Applications

As I mentioned above, many applications allow the user to create and edit documents, and then save them to and open them from disk. Since this is such a common type of application, Cocoa provides an architecture to help with the common tasks of managing documents. Applications that utilize this architecture are called document—based applications. The three classes that make up this architecture are NSDocument, NSWindowController, and NSDocumentController and are found in the Application Kit framework, along with all the GUI classes such as NSView and NSControl.

For simple cases, you generally don't have to interact with NSWindowController or NSDocumentController. However, you must always subclass NSDocument to implement saving and loading. We're going to walk through a simple document—based application that allows a user to save and load rectangle data.

Xcode has a project template for document—based applications, so we're going create a fresh project from this template. Select File > New ProjectÉ from Xcode and choose a Cocoa Document—based Application from the New Project assistant, as shown in Figure 2. Click Next, and create a project named Rectangles in the directory of your choice. Finally, enable garbage collection by modifying the project's build settings.


Figure 2: Creating a document—based application

If you take a look at the Groups & Files list for this project, you'll notice that it is slightly different than the non—document—based applications we've created so far, as shown in Figure 3. First, it creates a subclass of NSDocument called MyDocument for us in the Classes group. Second, it creates two nib files in the Resources group: MainMenu.nib and MyDocument.nib.


Figure 3: Generated files

We've previously only used a single nib file that contained both the main menu and the single application window. Because we can have multiple document windows open, we use a separate nib file for document windows. Remember that nib files are archived windows, views, and controls, so every time a new document window is created, Cocoa's document architecture unarchives MyDocument.nib to create a new window. The MainMenu.nib file only gets loaded once at application startup and contains only the menu bar items.

You can already run the application as—is, but it's quite limited. First, the window contains a nice message that you are supposed to add your own controls to it. Also, saving and loading are not implemented, and you get an error if you try and save. You can, however, create new documents using File > New or Command—N.

Creating the User Interface

We're going to start by making the document window look just like the window of our Hello World application. Figure 4 shows the final result. Open MyDocument.nib with Interface Builder and layout the controls and formatters like we did before. Also setup the proper resizing springs and struts. (See last month's article if you need a reminder of how to do this.)


Figure 4: MyDocument.nib window

The MyDocument class takes the place of HelloWorldController from the previous articles. It contains all the outlets and actions for the window. Add outlets for the four text fields, a calculate action, and an instance variable for a single rectangle, as shown in Listing 3:

Listing 3: MyDocument.h

#import <Cocoa/Cocoa.h>
@class Rectangle;
@interface MyDocument : NSDocument
{
    IBOutlet NSTextField * _widthField;
    IBOutlet NSTextField * _heightField;
    IBOutlet NSTextField * _areaLabel;
    IBOutlet NSTextField * _perimiterLabel;
    
    Rectangle * _rectangle;
}
— (IBAction)calculate:(id)sender;
@end

Now save MyDocument.h, and go back to Interface Builder. Connect up the outlets and actions to the appropriate controls. The File's Owner is setup to be our document class, MyDocument, so use this when connecting the outlets and actions.

Now, add the Rectangle class that we modified to support NSCoding protocol above to this project. In MyDocument, change the init method, and add the calculate: and updateAreaAndPerimeter methods to match this:

— (id)init
{
    self = [super init];
    if (self == nil)
        return nil;
    
    _rectangle = [[Rectangle alloc]    initWithLeftX: 0
                                             bottomY: 0
                                              rightX: 5
                                                topY: 10];
    
    return self;
}
— (void)updateAreaAndPerimeter
{
    [_areaLabel setFloatValue: _rectangle.area];
    [_perimiterLabel setFloatValue: _rectangle.perimeter];
}
— (IBAction)calculate:(id)sender
{
    _rectangle.width = [_widthField floatValue];
    _rectangle.height = [_heightField floatValue];
    [self updateAreaAndPerimeter];
}

This creates a new rectangle instance in the constructor and also implements the calculate: action. Remember, though, that we needed to implement the awakeFromNib to ensure the text fields and labels were correct on application launch. For NSDocument subclasses, you override the windowControllerDidLoadNib: instead of awakeFromNib. Their purpose is very similar, though, and allows you to execute code after the outlets and actions from the nib have been connected. Modify the supplied stub implementation to match this:

— (void)windowControllerDidLoadNib:(NSWindowController *) aController
{
    [super windowControllerDidLoadNib:aController];
    [_widthField setFloatValue: _rectangle.width];
    [_heightField setFloatValue: _rectangle.height];
    [self updateAreaAndPerimeter];
}

Now build and run the application. You should see a window similar to Figure 5. The initial width should be five and height should be ten. If you change the width or height and press the Calculate button, the area and perimeter should update accordingly.


Figure 5: Running document window

This works like our first Hello World application. However, you can now create new windows with the File > New menu. We now want to implement saving and loading of documents.

Registering File Extensions

In order to identify our new file types, we need to come up with a new file extension. Since our document contains a single rectangle, let's use ".rectangle" as our file extension. We need to tell the operating system that our application can load and save files with this extension. This is done by editing the properties of our application. Open up the Targets group in the Groups & Files section of the project. Double click on the Rectangles target to bring up the Info panel for our application. Change to the Properties tab of the Info panel.

There are a couple of important properties we need to change. First, we need to change the identifier. Identifiers must be unique for every application released on Mac OS X. The recommended way to do this uses so—called reverse DNS notation. DNS is how websites are named. For example, my personal website is at www.dribin.org. The technical name for this website address is the DNS name. DNS names are unique, i.e. there is one and only one dribin.org out there. Reverse DNS takes advantage of the uniqueness of website names. It's called reverse DNS because you list the components in the opposite order that you use them for websites. The default value is com.yourcompany.Rectangles, which may be fine for testing, but you should really change it to a properly unique name.

Let's change it to org.dribin.dave.mactech.jul08.rectangles.

Next, we need to change the document types for our application. The Document Types list should already have one document type in it. Edit it so that the name is Rectangle File and that the extension is rectangle (do not include the period). The final result should look similar to Figure 6.


Figure 6: Application properties

These application properties are stored in a file called Info.plist. You can see this file in the Resources group. This file gets included along with your built application. How this works is beyond the scope of this article, but suffice it to say that applications on Mac OS X are really directories with a special structure called bundles. We will talk more about bundles in a later article.

One word of warning: I find that whenever I change the application's properties or Info.plist file, I need to force Xcode to rebuild the whole application. You do this by using the Build > Clean All Targets menu item. Cleaning removes all files generated during the build process. By cleaning the target, you force the next build to rebuild everything. Be sure to clean your project before proceeding.

Saving and Loading

With our file extension in place, we can now proceed to implement saving and loading of rectangle files. The MyDocument class already contains stub methods for saving and loading that we need to fill in. Saving is handled by the dataOfType:error: method. You are supposed to return an NSData representation of your document, and the document architecture will take care of writing it to a file. The default implementation returns nil and sets an error.

The only data we need to save is our _rectangle instance variable. Since the Rectangle class now implements the NSCoding protocol, we can use an NSKeyedArchiver to convert our instance variable into NSData:

— (NSData *)dataOfType:(NSString *)typeName
                 error:(NSError **)outError
{
    NSData * rectangleData =
        [NSKeyedArchiver archivedDataWithRootObject:_rectangle];
    return rectangleData;
}

In order to load rectangle files, we need to implement the readFromData:ofType:error: method. We can use NSKeyedArchiver to convert the supplied NSData to an NSRectangle and store it in our instance variable:

— (BOOL)readFromData:(NSData *)data
              ofType:(NSString *)typeName
               error:(NSError **)outError
{
    _rectangle = [NSKeyedUnarchiver unarchiveObjectWithData:data];
    return YES;
}

If you are not using garbage collection, be sure to release the old rectangle and retain the new one.

With these two methods implemented, you should be able to save and open rectangle files. Give it a shot. The files should have the ".rectangle" extension we setup, too. You can even double click on saved rectangle files in the Finder, and it should automatically launch our application. As always, the completed project may be downloaded from the MacTech website.

Well, that's pretty much all there is to a document—based application. Due to the document architecture, there's really not that much extra code to write compared to non—document—based applications. Our MyDocument class is very similar to the HelloWorldController we wrote earlier. We just needed to add methods to save and load files, and that's really easy if the classes to be saved can be archived.

Given that we only had to implement two extra methods, we get a lot of functionality "for free" from the Cocoa document architecture:

A file open sheet is created when the user chooses File > OpenÉ

A file save sheet is created when the user choose File > Save or Save AsÉ

Saving and loading to and from disk is handled automatically

The window title changes to the name of the document

The document—based architecture really shows how Cocoa helps the developer write applications faster with less code. You can also get undo support easily, but that will have to wait for a future article.


Dave Dribin has been writing professional software for over eleven years. After five years programming embedded C in the telecom industry and a brief stint riding the Internet bubble, he decided to venture out on his own. Since 2001, he has been providing independent consulting services, and in 2006, he founded Bit Maki, Inc. Find out more at http://www.bitmaki.com/ and http://www.dribin.org/dave/.

 

Community Search:
MacTech Search:

Software Updates via MacUpdate

pwSafe 4.1 - Secure password management...
pwSafe provides simple and secure password management across devices and computers. pwSafe uses iCloud to keep your password databases backed-up and synced between Macs and iOS devices. It is... Read more
Kodi 15.0.rc1 - Powerful media center to...
Kodi (was XBMC) is an award-winning free and open-source (GPL) software media player and entertainment hub that can be installed on Linux, OS X, Windows, iOS, and Android, featuring a 10-foot user... Read more
Coda 2.5.11 - One-window Web development...
Coda is a powerful Web editor that puts everything in one place. An editor. Terminal. CSS. Files. With Coda 2, we went beyond expectations. With loads of new, much-requested features, a few surprises... Read more
Bookends 12.5.7 - Reference management a...
Bookends is a full-featured bibliography/reference and information-management system for students and professionals. Access the power of Bookends directly from Mellel, Nisus Writer Pro, or MS Word (... Read more
Maya 2016 - Professional 3D modeling and...
Maya is an award-winning software and powerful, integrated 3D modeling, animation, visual effects, and rendering solution. Because Maya is based on an open architecture, all your work can be scripted... Read more
RapidWeaver 6.2.3 - Create template-base...
RapidWeaver is a next-generation Web design application to help you easily create professional-looking Web sites in minutes. No knowledge of complex code is required, RapidWeaver will take care of... Read more
MacFamilyTree 7.5.2 - Create and explore...
MacFamilyTree gives genealogy a facelift: it's modern, interactive, incredibly fast, and easy to use. We're convinced that generations of chroniclers would have loved to trade in their genealogy... Read more
Paragraphs 1.0.1 - Writing tool just for...
Paragraphs is an app just for writers. It was built for one thing and one thing only: writing. It gives you everything you need to create brilliant prose and does away with the rest. Everything in... Read more
BlueStacks App Player 0.9.21 - Run Andro...
BlueStacks App Player lets you run your Android apps fast and fullscreen on your Mac. Version 0.9.21: Note: Now requires OS X 10.8 or later running on a 64-bit Intel processor. Initial stable... Read more
Tweetbot 2.0.2 - Popular Twitter client....
Tweetbot is a full-featured OS X Twitter client with a lot of personality. Whether it's the meticulously-crafted interface, sounds and animation, or features like multiple timelines and column views... Read more

Rage of Bahamut is Giving Almost All of...
The App Store isn't what it used to be back in 2012, so it's not unexpected to see some games changing their structures with the times. Now we can add Rage of Bahamut to that list with the recent announcement that the game is severely cutting back... | Read more »
Adventures of Pip (Games)
Adventures of Pip 1.0 Device: iOS iPhone Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: ** ONE WEEK ONLY — 66% OFF! *** “Adventures of Pip is a delightful little platformer full of charm, challenge and impeccable... | Read more »
Divide By Sheep - Tips, Tricks, and Stre...
Who would have thought splitting up sheep could be so involved? Anyone who’s played Divide by Sheep, that’s who! While we’re not about to give you complete solutions to everything (because that’s just cheating), we will happily give you some... | Read more »
NaturalMotion and Zynga Have Started Tea...
An official sequel to 2012's CSR Racing is officially on the way, with Zynga and NaturalMotion releasing a short teaser trailer to get everyone excited. Well, as excited as one can get from a trailer with no gameplay footage, anyway. [Read more] | Read more »
Grab a Friend and Pick up Overkill 3, Be...
Overkill 3 is a pretty enjoyable third-person shooter that was sort of begging for some online multiplayer. Fortunately the begging can stop, because its newest update has added an online co-op mode. [Read more] | Read more »
Scanner Pro's Newest Update Adds Au...
Scanner Pro is one of the most popular document scanning apps on iOS, thanks in no small part to its near-constant updates, I'm sure. Now we're up to update number six, and it adds some pretty handy new features. [Read more] | Read more »
Heroki (Games)
Heroki 1.0 Device: iOS Universal Category: Games Price: $7.99, Version: 1.0 (iTunes) Description: CLEAR THE SKIES FOR A NEW HERO!The peaceful sky village of Levantia is in danger! The dastardly Dr. N. Forchin and his accomplice,... | Read more »
Wars of the Roses (Games)
Wars of the Roses 1.0 Device: iOS Universal Category: Games Price: $4.99, Version: 1.0 (iTunes) Description: | Read more »
TapMon Battle (Games)
TapMon Battle 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: It's time to battle!Tap! Tap! Tap! Try tap a egg to hatch a Tapmon!Do a battle with another tapmons using your hatched tapmons! *... | Read more »
Alchemic Dungeons (Games)
Alchemic Dungeons 1.0 Device: iOS Universal Category: Games Price: $.99, Version: 1.0 (iTunes) Description: ### Release Event! ### 2.99$->0.99$ for limited time! ### Roguelike Role Playing Game! ### Alchemic Dungeons is roguelike... | Read more »

Price Scanner via MacPrices.net

Canon PIXMA MG3620 Wireless Inkjet All-in-One...
Canon U.S.A., Inc. has announced the PIXMA MG3620 Wireless (1) Inkjet All-in-One (AIO) printer for high-quality photo and document printing. Built with convenience in mind for the everyday home user... Read more
July 4th Holiday Weekend 13-inch MacBook Pro...
Save up to $150 on the purchase of a new 2015 13″ Retina MacBook Pro at the following resellers this weekend. Shipping is free with each model: 2.7GHz/128GB MSRP $1299 2.7GHz/... Read more
27-inch 3.5GHz 5K iMac on sale for $2149, sav...
Best Buy has the 27″ 3.5GHz 5K iMac on sale for $2149.99. Choose free shipping or free local store pickup (if available). Sale price for online orders only, in-store prices may vary. Their price is $... Read more
Apple now offering refurbished 2015 11-inch...
The Apple Store is now offering Apple Certified Refurbished 2015 11″ MacBook Airs as well as 13″ MacBook Airs (the latest models), available for up to $180 off the cost of new models. An Apple one-... Read more
15-inch 2.5GHz Retina MacBook Pro on sale for...
Amazon.com has the 15″ 2.5GHz Retina MacBook Pro on sale for $2274 including free shipping. Their price is $225 off MSRP, and it’s the lowest price available for this model. Read more
Finally Safe To Upgrade To Yosemite’?
The reason I’ve held back from upgrading my MacBook Air from OS X 10.9 Mavericks to 10.10 Yosemite for nearly a year isn’t just procrastination. Among other bugs reported, there have been persistent... Read more
Logo Pop Free Vector Logo Design App For OS X...
128bit Technologies has released of Logo Pop Free 1.2 for Mac OS X, a vector based, full-fledged, logo design app available exclusively on the Mac App Store for the agreeable price of absolutely free... Read more
21-inch 1.4GHz iMac on sale for $999, save $1...
B&H Photo has new 21″ 1.4GHz iMac on sale for $999 including free shipping plus NY sales tax only. Their price is $100 off MSRP. Best Buy has the 21″ 1.4GHz iMac on sale for $999.99 on their... Read more
16GB iPad mini 3 on sale for $339, save $60
B&H Photo has the 16GB iPad mini 3 WiFi on sale for $339 including free shipping plus NY tax only. Their price is $60 off MSRP. Read more
Save up to $40 on iPad Air 2, NY tax only, fr...
B&H Photo has iPad Air 2s on sale for up to $40 off MSRP including free shipping plus NY sales tax only: - 16GB iPad Air 2 WiFi: $489 $10 off - 64GB iPad Air 2 WiFi: $559 $40 off - 128GB iPad Air... Read more

Jobs Board

*Apple* Solutions Consultant - Retail Sales...
**Job Summary** As an Apple Solutions Consultant (ASC) you are the link between our customers and our products. Your role is to drive the Apple business in a retail Read more
Program Manger, WW *Apple* Direct Fulfillme...
**Job Summary** We are seeking a business analyst to work within our Worldwide Apple Direct Fulfillment Operations team. This role will work closely with related program Read more
Project Manager, *Apple* Retail New Store O...
**Job Summary** An Apple Retail New Store Openings & Remodels Project Manager is responsible for successfully managing the openings, remodels, and small works of Read more
Technical Project Manager - *Apple* Pay - A...
**Job Summary** Apple Pay is seeking an experienced technical PM to…manage the on boarding of new merchants for the Apple Pay platform in the US Within this role you Read more
*Apple* Pay- Automation Test Engineer - Appl...
**Job Summary** At Apple , great ideas have a way of becoming great products, services, and customer experiences very quickly. Bring passion and dedication to your job Read more
All contents are Copyright 1984-2011 by Xplain Corporation. All rights reserved. Theme designed by Icreon.