Any time someone uses AR for the first time, regardless of what they’ve been told, how many videos they’ve seen, or how well they think they understand the concept, they leave the experience as a fan, and want more.  It is for this reason that the all-star developers at Gravity Jack are constantly working to keep up with all the new, innovative uses for augmented reality. (When your industry niche is being the hands-down best, it’s something that is mandatory.)

The video showcases one of our office printers. What makes this short video (about a printer, nonetheless) exciting is the sheer possibility that pours from this kind of production, in the future. Go ahead and have a look at the short video, before we explain how you’ll, without a doubt, have this stuff in your house sooner than you think.

According to Shawn Poindexter, Director of Development here at Gravity Jack, uses for augmented reality that have been considered (by other studios) to be futuristic, are closer than you think.

“Augmented reality is often known by its ‘wow’ factor,” admits Poindexter, “but, a place where (augmented reality) will be getting into, very soon, is guide development and demos.”

In the future, Gravity Jack looks to use our patented AR technology to make information, regarding product development, guides, demos, and quality control much more efficient.
As for how it works, we’ll explain:

First, the app is looking to see if it recognizes anything that we have programmed it to. Once it recognizes the marker, it can tell, based on the size and location of the marker, where the printer is in the view. The app is programmed to already know the internal dimensions and parts, so at this point, it is able to overlay the 3-dimensional parts, created by our developers, on top of what you’re seeing. Now, they can be animated, moved, and used to display anything you could do, with the actual printer, without consequence.

The concept makes sense, but its implication for the future does not stop with our printer.

“In the future, augmented reality could reduce error,” Poindexter continues, “and in the event an error occurs, correct them before causing future mistakes.”

Take, for example, a tutorial on how to change the air filter in your car:

Anyone, using AR, could be led, step by step, through the simple process, in a matter of minutes.  The demo could highlight the part to be moved, and recognize when it had been done, then directing the user with the next, correct step.

Are you starting to get the picture? The ramifications for the future are widespread and have the opportunity to affect every aspect, of every industry.

We’re just stoked we’re the ones bringing it to you.

HTML5 is just a catch phrase for Dynamic HTML (DHTML), which is just a combination of HTML, JavaScript, and CSS. The DHTML coding modal has been around for years, and all HTML5 brings to the table is more DOM tags to manipulate, and a few new JavaScript methods. One of the major issues with the modal is that the user has no control over the client side computer. In other words, there is no communication possible between the app and the viewing computer, beyond the scope of web browsing. So, why code in such a limited language set?

“Because…Steve Jobs said so.”  Buwahaha, No.

It’s because of the portability of the app. The great thing with DHTML is that it will run on any browser that supports the DOM that you are using. This makes interpolation an almost painless process.

So, you want a super badass HTML5 site, and you want to build it in a way that runs on all the devices known to man. This is quite easy—as long as you don’t care about audio effects, loading times, code security, or any of the sensors/hardware on the given device. I have found that most of the mobile browsers on the market today are extremely limited. On Android (API Level 8 and below), and also on iPhone (all versions), the webkit browsers have only one audio channel, user dialog (that can take up valuable screen space), and an incessant need to run everything its own way.  How do we overcome these problems? There are many options out there to make a so-called “webapp” (like PhoneGap, and XNA). These frameworks are a beautiful start to making a library, which is a plug and play solution, to gain access to system resources, from a web page. I have often found that what our clients need, exceed the scope of what they can do— and these systems are far to bloated for what we need.

So, we are left with one option; we make our own native app, which can create a web browser in a symbiotic relationship. We have a native device app that can spin up an instance of webkit, and only use the pieces we need for our given project to work. In the coding world, this is known as a “webUIView”, which can be utilized on all of the popular, full web enabled devices. With this web view, we have a system that can expose the hardware layer to our webapp. So, how are we going to communicate, back and forth, between the device and the webapp? In a nut shell, we have JavaScript injection, in order to inject some code in the DOM and run it, access to the DOM headers and control of the URL to run GET and POST procedures, access to the JavaScript console for debugging, and finally, the power to override the JavaScript dialog system for an events model, to be used from the DOM.

JavaScript injection is a process to create a string of DHTML, and push it to the DOM before the “onLoad” events are fired. This works like any other server side system, (i.e. PHP, ASP.NET, etc.) in that they have the ability to execute code before we hand it off to the browser. Having this, gives us the ability to pass information (and code) to the webapp for its own use (i.e., geo-location). This can also offer some security to your site by making the webapp worthless, unless executed from your native app.

Having access to the URL allows us to focus the user’s browser where we want them to go, and nowhere else. We can also place URL parameters in a load.url statement, forcing a POST action to happen. Lastly, this means that we can execute callback function, to run anything within our web app.

This is great. We have everything we need to push information to the webapp to enrich the user’s experience, but what about when we need the webapp to fire an event, inside the native code? Well, we can use the JavaScript console to pass serialized data to the native app, or we can use a JavaScript alert. In practice, I use the JavaScript Console for debugging, and the JavaScript alert system for events, mostly because I never use the JavaScript alert system at all (not cool enough). This benefits me, by keeping the debug system and events (JavaScript alert) system apart.

So, now I’ve come full circle, and have the ability create robust applications that will run on any platform (the way I want them to), without eating up resources, better utilized elsewhere. As time passes, technology will become better and these new standards will be finalized. When this happens, it will (without a doubt) be the way to develop on mobile platforms.

- Jack

It’s a lesson that everyone learns, and is one that Gravity Jack has experienced first-hand since we started with 5 employees, two years ago.  Now, sporting 38 (all-star) employees, with plenty more growth on hand, the time has come for Jack to take action.  Grab your cardboard boxes and packing tape, folks, because two years after we started, Gravity Jack is proud to say, “What recession?”

We’re moving up, moving out, and moving in to a new pad.

Gravity Jack will soon be cutting the ribbon to our brand-spankin’ new office on Appleway Avenue and, while we may only be moving just far enough to work up a pre-jog sweat, we’re psyched. The new office (pictured in its current state, below) will be the epicenter of shock waves, sending augmented reality in to the future. Boom.

It’s big, and it’s got the size Gravity Jack needs to keep all hands on deck, moving forward with what we do best. The new location will house the entire development floor, the administrative offices and a conference room, keeping all aspects of our business working close together.  The best part, of course, is that we’re staying right here in Liberty Lake, where we’ve always called home.

We can’t wait to show you the finished digs, but we’re more excited about what it means for our future. We’ll be sure to keep you in the loop by posting photos, as the new place comes together!

iCloud Storage APIs

The iCloud storage APIs let your application write user documents and data to a central location and access those items from all of a user’s computers and iOS devices. Making a user’s documents ubiquitous using iCloud means that a user can view or edit those documents from any device without having to sync or transfer files explicitly. Storing documents in a user’s iCloud account also provides a layer of security for that user. Even if a user loses a device, the documents on that device are not lost if they are in iCloud storage.

There are two ways that applications can take advantage of iCloud storage, each of which has a different intended usage:

• iCloud document storage—Use this feature to store user documents and data in the user’s iCloud account.
• iCloud key-value data storage—Use this feature to share small amounts of data among instances of your application.

Most applications will use iCloud document storage to share documents from a user’s iCloud account. This is the feature that users think of when they think of iCloud storage. A user cares about whether documents are shared across devices and can see and manage those documents from a given device. In contrast, the iCloud key-value data store is not something a user would see. It is a way for your application to share very small amounts of data (tens of kilobytes) with other instances of itself. Applications can use this feature to store important state information. A magazine application might save the issue and page that the user read last, while a stocks application might store the stock symbols the user is tracking.

The summary for using the iCloud storage APIs in your application is as follows:

1. Use the iOS Provisioning Portal to enable iCloud storage for your iOS application.Enabling this feature requires that you have an updated provisioning profile on your development systems. Xcode 4 handles this step for you automatically.
2. Add an Entitlements file to your application and use it to configure the iCloud features your application uses
3. Implement iCloud document storage as follows:
   • Use the UIDocument class to read and write the contents of your user documents; alternatively, incorporate support for file presenters and file coordinators into the custom classes that you use to manage user documents. The iCloud service uses the file coordination mechanism to notify your application when a document changes. (The UIDocument class implements support for file presenters and file coordinators for you and is recommended.)
   • Use the NSFileManager class to move the appropriate documents to the user’s iCloud storage. It is recommended that you give users the option to move documents to iCloud
   • Use the NSMetadataQuery interfaces to search for documents in a user’s iCloud storage;
   • Be prepared to handle version conflicts that might arise when two devices try to update a document at the same time;
4. To implement iCloud key-value data storage, use the NSUbiquitousKeyValueStore class to read and write keys and values.

The sections that follow provide more details about how to implement different aspects of iCloud storage for your application. For additional information about using specific classes and interfaces, see the corresponding reference documentation.

Storing and Using Documents in iCloud

Documents in iCloud provide the central location from which updates can be delivered to a user’s computers and iOS devices. All documents must be created in your application’s sandbox initially and moved to a user’s iCloud account later. A document targeted for iCloud storage is not moved to iCloud immediately, though. First, it is moved out of your application sandbox and into a local system-managed directory where it can be monitored by the iCloud service. After that transfer, the file is transfered to iCloud and to the user’s other devices as soon as possible.

While in iCloud storage, changes made on one device are stored locally and then pushed to iCloud using a local daemon, as shown in Figure 1. To prevent large numbers of conflicting changes from occurring at the same time, applications are expected to use file coordinator objects to perform all changes. File coordinators mediate changes between your application and the daemon that facilitates the transfer of the document to and from iCloud. In this way, the file coordinator acts like a locking mechanism for the document, preventing your application and the daemon from modifying the document simultaneously.

Figure 1 Pushing document changes to iCloud

From an implementation perspective, the easiest way to manage documents in iCloud is to use the UIDocument class. This class does most of the heavy lifting required to read and write files that are stored in iCloud. Specifically, the UIDocument class handles the creation and use of file coordinators to modify the document. This class also seamlessly integrates document changes coming from other devices. The class even helps handle the potential conflicts that can arise when two devices do manage to update the same file in conflicting ways. You are not required to use the UIDocument class to manage your application’s documents, but using it requires less effort on your part.

Important: Applications that store documents to iCloud must specify one or more containers in which to store those documents. You specify which containers your application supports using the com.apple.developer.ubiquity-container-identifiers entitlement.

The sections that follow discuss the basic mechanics of how you move documents to iCloud and manage them (with and without the help of theUIDocument class).

Moving a Document to iCloud Storage

To move a document to iCloud storage:

1. Create and save the file locally in your application sandbox.
2. If you are not using the UIDocument class to manage your file, create a file presenter to be responsible for it.
3. Create an NSURL object that specifies the destination of the file in a user’s iCloud storage.You must put files in one of the container directories associated with your application. Call the URLForUbiquityContainerIdentifier:method of NSFileManager to get the root URL for the directory, and then append any additional directory and filenames to that URL. (Applications may put documents in any container directory for which they have the appropriate entitlement.
4. Call the setUbiquitous:itemAtURL:destinationURL:error: method of NSFileManager to move the file to the specified destination in iCloud.

When moving documents to iCloud, you can create additional subdirectories inside the container directory to manage your files. It is strongly recommended that you create a Documents subdirectory and use that directory for storing user documents. In iCloud, the contents of theDocuments directory are made visible to the user so that individual documents can be deleted. Everything outside of the Documents directory is grouped together and treated as a single entity that a user can keep or delete. You create subdirectories in a user’s iCloud storage using the methods of the NSFileManager class just as you would any directory.

After you move a document to iCloud, it is not necessary to save a URL to the document’s location persistently. If you manage a document using a UIDocument object, that object automatically updates its local data structures with the document’s new URL. However, it does not save that URL to disk, and neither should your custom file presenters. Instead, because documents can move while in a user’s iCloud storage, you should use an NSMetadataQuery object to search for documents. Searching guarantees that your application has the correct URL for accessing the document.

Searching for Documents in iCloud

To locate documents in iCloud storage, your application must search using an NSMetadataQuery object. Searching is a guaranteed way to locate documents both in a user’s iCloud storage and in your application sandbox. You should always use query objects instead of saving URLs persistently because the user can delete files from iCloud storage when your application is not running. Using a query to search is the only way to ensure an accurate list of documents.

In iOS 5.0, the NSMetadataQuery class supports the following search scopes for your documents:

• Use the NSMetadataQueryUbiquitousDocumentsScope constant to search for documents in iCloud that reside somewhere inside aDocuments directory. (For any given container directory, put documents that the user is allowed to access inside a Documents subdirectory.)
• Use the NSMetadataQueryUbiquitousDataScope constant to search for documents in iCloud that reside anywhere other than in aDocuments directory. (For any given container directory, use this scope to store user-related data files that your application needs to share but that are not files you want the user to manipulate directly.)
• Use the NSMetadataQueryLocalDocumentsScope constant to search the Documents directory in your application’s sandbox.

To use a metadata query object to search for documents, create a new NSMetadataQuery object and do the following:

1. Set the search scope of the query to an appropriate value (or values).
2. Add a predicate to narrow the search results. To search for all files, specify a predicate with the format NSMetadataItemFSNameKey == *.
3. Register for the query notifications and configure any other query parameters you care about, such as sort descriptors, notification intervals, and so on.The NSMetadataQuery object uses notifications to deliver query results. At a minimum, you should register for theNSMetadataQueryDidUpdateNotification notification, but you might want to register for others in order to detect the beginning and end of the results-gathering process.
4. Call the startQuery method of the query object.
5. Run the current run loop so that the query object can generate the results.If you started the query on your application’s main thread, simply return and let the main thread continue processing events. If you started the query on a secondary thread, you must configure and execute a run loop explicitly.
6. Process the results in your notification-handler methods.When processing results, always disable updates first. Doing so prevents the query object from modifying the result list while you are using it. When you are done processing the results, reenable updates again to allow new updates to arrive.
7. When you are ready to stop the search, call the stopQuery method of the query object.

Working with Documents in iCloud

When your application needs to read or write a document in iCloud, it must do so in a coordinated manner. Your application might not be the only application trying to manipulate the local file at any given moment. The daemon that transfers the document to and from iCloud also needs to manipulate it periodically. To prevent your application from interfering with the daemon (and vice versa), iOS provides a coordinated locking mechanism that works with the files and directories you target for iCloud storage.

At the heart of the iCloud locking mechanism are file coordinators and file presenters. Whenever you need to read and write a file, you do so using a file coordinator, which is an instance of the NSFileCoordinator class. The job of a file coordinator is to coordinate the reads and writes performed by your application and the sync daemon on the same document. For example, your application and the daemon may both read the document at the same time but only one may write to the file at any single time. Also, if one process is reading the document, the other process is prevented from writing to the document until the reader is finished.

In addition to coordinating operations, file coordinators also work with file presenters to notify applications when changes are about to occur. Afile presenter is any object that conforms to the NSFilePresenter protocol and takes responsibility for managing a specific file (or directory of files) in an application. The job of a file presenter is to protect the integrity of its own data structures. It does this by listening for messages from other file coordinators and using those messages to update its internal data structures. In most cases, a file presenter may not have to do anything. However, if a file coordinator declares that it is about to move a file to a new URL, the file presenter would need to replace its old URL with the new one provided to it by the file coordinator. The UIDocument class is an example of a file presenter that tracks changes to its underlying file or file package.

Here is a checklist of the things your application must do to work with documents in iCloud:

• Manage each document in iCloud using a file presenter. The recommended way to do this is to use the UIDocument class, but you may define custom file presenters if you prefer. You can use a single file presenter to manage a file package or a directory of files.
• After creating a file presenter, register it by calling the addFilePresenter: class method of NSFileCoordinator. Registration is essential. The system can notify only registered presenter objects.
• Before deleting a file presenter, unregister it by calling the removeFilePresenter: method of NSFileCoordinator.

All file-related operations must be performed through a file coordinator object. To read or write a document, or move or delete it, follow these steps:

1. Create an instance of the NSFileCoordinator class and initialize it with the file presenter object that is about to perform the file operation.
2. Use the methods of the NSFileCoordinatorobject to read or write the file:
   • To read all or part of a single file, use the coordinateReadingItemAtURL:options:error:byAccessor: method
   • To write to a file or delete it, call the coordinateWritingItemAtURL:options:error:byAccessor: method.
   • To perform a sequence of read or write operations, use thecoordinateReadingItemAtURL:options:writingItemAtURL:options:error:byAccessor: method.
   • To write to multiple files, or to move a file to a new location, use thecoordinateWritingItemAtURL:options:writingItemAtURL:options:error:byAccessor: method.

   You perform the actual file-related operations in the block that you pass to these methods. You should perform operations as quickly as possible to avoid blocking other applications that might be trying to access the file at the same time.

3. When you are done with the operations, release the file coordinator object.

Handling File-Version Conflicts

When multiple instances of your application (running on different computers or iOS devices) try to modify the same document in iCloud, a conflict can occur. For example, if the devices are not connected to the network and the user makes changes on both, both devices try to push their changes to iCloud when they are reconnected to the network. At this point, iCloud has two different versions of the same file and has to decide what to do with them. Its solution is to make the most recently modified file the current file and to mark any other versions of the file as conflict versions.

Your application is notified of conflict versions through its file presenter objects. It is the job of the file presenter to decide how best to resolve any conflicts that arise. Applications are encouraged to resolve conflicts quietly whenever possible, either by merging the file contents or by discarding the older version if the older data is no longer relevant. However, if discarding or merging the file contents is impractical or might result in data loss, your application might need to prompt the user for help in choosing an appropriate course of action. For example, you might let the user choose which version of the file to keep, or you might offer to save the older version under a new name.

Applications should always attempt to resolve conflict versions as soon as possible. When conflict versions exist, all of the versions remain in a user’s iCloud storage (and locally on any computers and iOS devices) until your application resolves them. The current version of the file and any conflict versions are reported to your application using instances of the NSFileVersion class.

To resolve conflicts:

1. Get the current file version using the currentVersionOfItemAtURL: class method of NSFileVersion.
2. Get an array of conflict versions using the unresolvedConflictVersionsOfItemAtURL: class method of NSFileVersion.
3. For each conflict version object, perform whatever actions are needed to resolve the conflict. Options include:
   • Merging the conflict versions with the current file automatically, if it is practical to do so.
   • Ignoring the conflict versions, if doing so does not result in any data loss.
   • Prompting the user to select which version (current or conflict) to keep. This should always be your last option.
4. Update the current file as needed.
   • If the current file version remains the winner, you do not need to update the current file.
   • If a conflict version is chosen as the winner, use a coordinated write operation to overwrite the contents of the current file with the contents of the conflict version.
   • If the user chooses to save the conflict version under a different name, create the new file with the contents of the conflict version.
5. Set the resolved property of the conflict version objects to YES.Setting this property to YES causes the conflict version objects (and their corresponding files) to be removed from the user’s iCloud storage.

Storing Key-Value Data in iCloud

An application can use the NSUbiquitousKeyValueStore class to share small amounts of data with other instances of itself running on other computers and iOS devices. This class provides a similar service as the NSUserDefaults class in that it allows you to save simple data types (numbers, strings, dates, arrays, and so on) persistently and retrieve that data later. The main difference is that theNSUbiquitousKeyValueStore class writes that data to the user’s iCloud storage so that it can be retrieved by the application running on different iOS devices or computers.

The amount of available space in a single key-value store is limited to 64 KB and the data for a single key cannot exceed 4 KB. Thus, you can use this storage to record small details about your application but should not use it to store user documents or other large data archives. Instead, you should use the information in the key-value store to improve the user experience for your application. For example, a magazine application might store the current issue and page number that the user is reading. That way, if the user opens the application on another device, the version of your application on that device can open to the same issue and page as the previous device.

The NSUbiquitousKeyValueStore class should not be used as a replacement or supplement for the NSUserDefaults class. An application should always write all of its configuration data to disk using the NSUserDefaults class. It should then write the data it intends to share to the key-value data store using the NSUbiquitousKeyValueStore class. This guarantees that your application always has a valid copy of the data available locally.

Requesting Entitlements for iCloud Storage

To protect the data each application creates, applications must request specific entitlements at build time in order to use iCloud storage. These entitlements are tied to the application’s provisioning profile and are used to differentiate your application’s documents and data from that of other applications.

There are two entitlements an application can request, depending on which iCloud features it uses:

• To use iCloud document storage, request the com.apple.developer.ubiquity-container-identifiers entitlement. The value of this key is an array of container identifier strings. (The first string in the array must not contain any wildcard characters.)
• To use the iCloud key-value data store, request the com.apple.developer.ubiquity-kvstore-identifier entitlement. The value of this key is a single container identifier string.

A container identifier string must be of the form <TEAM_ID>.<CUSTOM_STRING>, where <TEAM_ID> is the unique ten-character identifier associated with your developer account. The contents of <CUSTOM_STRING> are at your discretion, but it is recommended that you use a reverse-DNS string similar to your application’s bundle identifier. In practice, the string can be anything that makes sense to your development team. You can even use the same container identifier string for multiple applications if you want them to share the same storage space.

Applications using iCloud document storage can specify multiple containers for storing documents and data. The value of thecom.apple.developer.ubiquity-container-identifiers key is an array of strings. The first string in this array must be the main container identifier to associate with your application. If your company develops multiple applications, though, you can include additional container identifiers for your other applications. An application that supports multiple containers may read and write the documents and data in all of those containers, and searches always return a merged set of results.

Listing 1 shows the XML from an entitlements file that requests the keys for an iPad application. In this example, the iPad application can read and write its own documents (which it stores in the container directory identified using the A1B2C3D4E5.com.example.MyApp.ipad) and it can read and write files from the iPhone version of the same application (which may or may not use a different file format).

Listing 1 iCloud keys in the entitlements.plist file

<key>com.apple.developer.ubiquity-container-identifiers</key>

<array>

   <string>A1B2C3D4E5.com.example.MyApp.ipad</string>

   <string>A1B2C3D4E5.com.example.MyApp.iphone</string>

</array>

<key>com.apple.developer.ubiquity-kvstore-identifier</key>

<string>A1B2C3D4E5.com.example.MyApp.ipad</string>

Using iCloud Storage Responsibly

Applications that take advantage of iCloud storage features should act responsibly when storing data in there. The space available in each user’s account is limited and is shared by all applications. In addition, users can see how much space is consumed by a given application and choose to delete documents and data associated with your application. For these reasons, it is in your application’s interest to be responsible about what files you store. Here are some tips to help you manage documents appropriately:

• Rather than storing all documents, let a user choose which documents to store in an iCloud account. If a user creates a large number of documents, storing all of those documents in iCloud could overwhelm that user’s available space. Providing a way for a user to designate which documents to store in iCloud gives that user more flexibility in deciding how best to use the available space.
• Remember that deleting a document removes it from a user’s iCloud account and from all of that user’s computers and devices. Make sure that users are aware of this fact and confirm any delete operations. For your application to refresh the local copy of a document, use theevictUbiquitousItemAtURL:error: method of NSFileManager.
• When storing documents in iCloud, place them in a Documents directory whenever possible. Documents inside a Documents directory can be deleted individually by the user to free up space. However, everything outside that directory is treated as data and must be deleted all at once.
• Never store caches or other files that are private to your application in a user’s iCloud storage. A user’s iCloud account should be used only for storing user data and content that cannot be re-created by your application.

iCloud Backup

Users can now opt to have their applications and application data backed up directly to their iCloud account, making it easier to restore applications to their most recent state. Having data backed up in iCloud makes it easy for a user to reinstall that data to a new or existing iOS device. However, because the amount of space in a user’s iCloud account is limited, applications should be even more selective about where they store files.

The placement of files in your application’s home directory determines what gets backed up and what does not. Anything that would be backed up to a user’s computer is also backed up wirelessly to iCloud. Thus, everything in the Documents directory and most (but not all) of your application’s Library directory. To minimize the amount of data stored in the user’s iCloud account, developers are encouraged to put more files in the Library/Caches directory, especially if those files can be easily re-created or obtained in another way.

Automatic Reference Counting

Automatic Reference Counting (ARC) is a compiler-level feature that simplifies the process of managing the lifetimes of Objective-C objects. Instead of you having to remember when to retain or release an object, ARC evaluates the lifetime requirements of your objects and automatically inserts the appropriate method calls at compile time.

To be able to deliver these features, ARC imposes some restrictions—primarily enforcing some best practices and disallowing some other practices:

• Do not call the retain, release, autorelease, or dealloc methods in your code.In addition, you cannot implement custom retain or release methods.Because you do not call the release method, there is often no need to implement a custom dealloc method—the compiler synthesizes all that is required to relinquish ownership of instance variables. You can provide a custom implementation of dealloc if you need to manage other resources.
• Do not store object pointers in C structures.Store object pointers in other objects instead of in structures.
• Do not directly cast between object and nonobject types (for example, between id and void*).You must use special functions or casts that tell the compiler about an object’s lifetime. You use these to cast between Objective-C objects and Core Foundation objects.
• You cannot use NSAutoreleasePool objects.Instead, you must use a new @autoreleasepool keyword to mark the start of an autorelease block, and the @end keyword to mark the end of it.

ARC encourages you to think in terms of object graphs, and the relationships between objects, rather than in terms of retain and release. For this reason, ARC introduces new lifetime qualifiers for objects, including zeroing weak references. The value of a zeroing weak reference is automatically set to nil if the object to which it points is deallocated. There are qualifiers for variables, and new weak and strong declared property attributes, as illustrated in the following examples:

// The following declaration is a synonym for: @property(retain) MyClass *myObject;

@property(strong) MyClass *myObject;

// The following declaration is similar to "@property(assign) MyOtherClass *delegate;"

// except that if the MyOtherClass instance is deallocated,

// the property value is set to nil instead of remaining as a dangling pointer

@property(weak) MyOtherClass *delegate;

Xcode provides migration tools to help convert existing projects to use ARC.

Storyboards

Storyboards are the new way to define your application’s user interface. In the past, you used nib files to define your user interface one view controller at a time. A storyboard file captures your entire user interface in one place and lets you define both the individual view controllers and the transitions between those view controllers. As a result, storyboards capture the flow of your overall user interface in addition to the content you present.

If you are creating new applications, the Xcode templates come preconfigured to use storyboards. For other applications, the process for using storyboards is as follows:

1. Configure your application’s Info.plistfile to use storyboards:
   • Add the UIMainStoryboardFile key and set its value to the name of your storyboard file.
   • Remove the existing NSMainNibFile key. (Storyboards replace the main nib file.)
2. Create and configure the storyboard file in Xcode; see “Creating Storyboard Files.”
3. Update your view controllers to handle storyboard transitions; see “Preparing to Transition to a New View Controller.”
4. If you ever need to present a view controller manually (perhaps to support motion-related events), use the storyboard classes to retrieve and present the appropriate view controller; see “Presenting Storyboard View Controllers Programmatically.”

Applications can use a single storyboard file to store all of their view controllers and views. At build time, Interface Builder takes the contents of the storyboard file and divides it up into discrete pieces that can be loaded individually for better performance. Your application never needs to manipulate these pieces directly, though. All you must do is declare the main storyboard in your application’s Info.plist file. UIKit handles the rest.

Creating Storyboard Files

You use Interface Builder to create storyboard files for your application. Most applications need only one storyboard file, but you can create multiple storyboard files if you want. Every storyboard file has a view controller known as the initial view controller. This view controller represents the entry point into the storyboard. For example, in your application’s main storyboard file, the initial view controller would be the first view controller presented by your application.

Each view controller in a storyboard file manages a single scene. For iPhone applications, a scene manages one screen’s worth of content, but for iPad applications the content from multiple scenes can be on screen simultaneously. To add new scenes to your storyboard file, drag a view controller from the library to the storyboard canvas. You can then add controls and views to the view controller’s view just as you would for a nib file. And as before, you can configure outlets and actions between your view controller and its views.

When you want to transition from one view controller to another, Control-click a button, table view cell, or other trigger object in one view controller, and drag to the view controller for a different scene. Dragging between view controllers creates a segue, which appears in Interface Builder as a configurable object. Segues support all of the same types of transitions available in UIKit, such as modal transitions and navigation transitions. You can also define custom transitions and transitions that replace one view controller with another.

Preparing to Transition to a New View Controller

Whenever a user triggers a segue in the current scene, the storyboard runtime calls the prepareForSegue:sender: method of the current view controller. This method gives the current view controller an opportunity to pass any needed data to the view controller that is about to be displayed. When implementing your view controller classes, you should override this method and use it to handle these transitions.

Presenting Storyboard View Controllers Programmatically

Although the storyboard runtime usually handles transitions between view controllers, you can also trigger segues programmatically from your code. You might do so when setting up the segue in Interface Builder is not possible, such as when using accelerometer events to trigger the transition. There are several options for transitioning to a new view controller:

• If a storyboard file contains an existing segue between the current view controller and the destination view controller (perhaps triggered by some other control in the view controller), you can trigger that segue programmatically using the performSegueWithIdentifier:sender:method of UIViewController.
• If there is no segue between the view controllers but the destination view controller is defined in the storyboard file, first load the view controller programmatically using the instantiateViewControllerWithIdentifier: method of UIStoryboard. Then present the view controller using any of the existing programmatic means, such as by pushing it on a navigation stack.
• If the destination view controller is not in the storyboard file, create it programmatically and present it as described in View Controller Programming Guide for iOS.

Newsstand Support

Newsstand provides a central place for users to read magazines and newspapers. Publishers who want to deliver their magazine and newspaper content through Newsstand can create their own iOS applications using the Newsstand Kit framework (NewsstandKit.framework), although doing so is not required. A big advantage of the Newsstand Kit framework, however, is that you can use it to initiate background downloads of new magazine and newspaper issues. After you start a download, the system handles the download operation and notifies your application when the new content is available.

Unlike other iOS applications, Newsstand applications appears only in Newsstand itself, not in a user’s Home screen. And instead of displaying an application icon, the application typically displays the cover of their most recent issue, with some additional adornments provided by Newsstand. When the user taps that cover art, your application launches normally to present the current issue or any back issues that were downloaded and are still available.

Creating an application that uses Newsstand Kit requires some interplay between the actual application and the content servers that you manage. Your servers are responsible for notifying the application when new content is available, typically using a push notification. If your Newsstand application includes the UIBackgroundModes key with the newsstand-content value in its Info.plist file, your Newsstand application is launched in the background so that it can start downloading the latest issue. The download process itself is managed by the system, which notifies your application when the content is fully downloaded and available.

When your server is alerting your application of a new issue, that server should include the content-available property (with a value of 1) in the JSON payload. This property tells the system that it should launch your application so that it can begin downloading the new issue. Applications are launched and alerted to new issues once in a 24-hour period at most, although if your application is running when the notification arrives, it can begin downloading the content immediately.

In addition to your server providing content for each new issue, it should also provide cover art to present in Newsstand when that issue is available. This cover art is displayed in place of the application’s default icon, which is specified by the Newsstand-specific icons in theCFBundleIcons key of your application’s Info.plist file. Cover art gives users a more visual cue that a new issue is available. Your application can also add a badge to new issues.

AirPlay Improvements

AirPlay lets users stream audio and video from an iOS-based device to AirPlay–enabled devices such as televisions and audio systems. In iOS 5, developers can now use AirPlay to present application content on a nearby Apple TV 2. Users can now mirror the content of an iPad 2 to an Apple TV using AirPlay for any application. And developers who want to display different content (instead of mirroring) can assign a new window object to any UIScreen objects connected to an iPad 2 via AirPlay.

In addition, you can now take advantage of AirPlay in the following ways:

• Applications that use AV Foundation can now use the AVPlayer class to stream audio and video content over AirPlay; see AV Foundation Framework Reference.
• The Media Player framework includes support for displaying “Now Playing” information in several locations, including as part of the content delivered over AirPlay; see MPNowPlayingInfoCenter Class Reference.
• The UIWebView class now supports the presentation of multimedia content over AirPlay. This support is enabled by default, but you can opt out of it if you want to.

New Frameworks

In iOS 5.0, there are several new frameworks you should investigate.

GLKit Framework

The GLKit framework (GLKit.framework) contains a set of Objective-C based utility classes that simplify the effort required to create an OpenGL ES 2.0 application. GLKit provides support for four key areas of application development:

• The GLKView and GLKViewController classes provide a standard implementation of an OpenGL ES–enabled view and associated rendering loop. The view manages the underlying framebuffer object on behalf of the application; your application just draws to it.
• The GLKTextureLoader class provides image conversion and loading routines to your application, allowing it to automatically load texture images into your context. It can load textures synchronously or asynchronously. When loading textures asynchronously, your application provides a completion handler block to be called when the texture is loaded into your context.
• The GLKit framework provides implementations of vector, matrix, and quaternions as well as a matrix stack operation to provides the same functionality found in OpenGL ES 1.1.
• The GLKBaseEffect, GLKSkyboxEffect, and GLKReflectionMapEffect classes provide precreated, configurable graphics shaders that implement commonly used graphics operations. In particular, the GLKBaseEffect class implements the lighting and material model found in the OpenGL ES 1.1 specification, simplifying the effort required to migrate an application from OpenGL ES 1.1 to OpenGL ES 2.0.

Core Image Framework

The Core Image framework (CoreImage.framework) provides a powerful set of built-in filters for manipulating video and still images. You can use the built-in filters for everything from simple operations (like touching up and correcting photos) to more advanced operations (like face and feature detection). The advantage of using these filters is that they operate in a nondestructive manner so that your original images are never changed directly. In addition, Core Image takes advantage of the available CPU and GPU processing power to ensure that operations are fast and efficient.

The CIImage class provides access to a standard set of filters that you can use to improve the quality of a photograph. To create other types of filters, you can create and configure a CIFilter object for the appropriate filter type.

Twitter Framework

The Twitter framework (Twitter.framework) provides support for sending Twitter requests on behalf of the user and for composing and sending tweets. For requests, the framework handles the user authentication part of the request for you and provides a template for creating the HTTP portion of the request. (Refer to the Twitter API for populating the content of the request.) The composition of tweets is accomplished using the TWTweetComposeViewController class, which is a view controller that you post with your proposed tweet content. This class gives the user a chance to edit or modify the tweet before sending it.

Users control whether an application is allowed to communicate with Twitter on their behalf using Settings. The Twitter framework also works in conjunction with the Accounts framework (Accounts.framework) to access the user’s account.

Accounts Framework

The Accounts framework (Accounts.framework) provides a single sign-on model for certain user accounts. Single sign-on improves the user experience, because applications no longer need to prompt a user separately for login information related to an account. It also simplifies the development model for you by managing the account authorization process for your application. In iOS 5.0, applications can use this framework in conjunction with the Twitter framework to access a user’s Twitter account.

Generic Security Services Framework

The Generic Security Services framework (GSS.framework) provides a standard set of security-related services to iOS applications. The basic interfaces of this framework are specified in IETF RFC 2743 and RFC 4401. In addition to offering the standard interfaces, iOS includes some additions for managing credentials that are not specified by the standard but that are required by many applications.

Application Design-Level Improvements

The following sections describe new capabilities that you can incorporate into the model, view, and controller layers of your application.

Document Support

Cocoa Touch now includes a UIDocument class for managing the data associated with user documents. If you are implementing a document-based application, this class reduces the amount of work you must do to manage your document data. In addition to providing a container for all of your document-related data, the UIDocument class provides built-in support for a number of features:

• Asynchronous reading and writing of data on a background queue, allowing your application to remain responsive to users while reading and writing operations occur.
• Support for coordinated reading and writing of documents, which is required for documents in iCloud storage.
• Safe saving of document data by writing data first to a temporary file and then replacing the current document file with it.
• Support for resolving conflicts between different versions of your document if a conflict occurs.
• Automatic saving of document data at opportune moments.
• Support for flat file and package file representations on disk.
• For applications that use Core Data to manage their content, there is also a UIManagedDocument subclass to manage interactions with documents in the database.

If you are implementing an application that supports iCloud storage, the use of document objects makes the job of storing files in iCloud much easier. Document objects are file presenters and handle many of iCloud-related notifications that you might otherwise have to handle yourself.

Data Protection Improvements

Introduced in iOS 4.0, data protection lets you store application and user data files on disk in an encrypted format so that they can be accessed only when a user’s device is unlocked. In iOS 5.0, you now have more flexibility regarding when your application can access protected files.

• Using the NSFileProtectionCompleteUnlessOpen option, your application can access a file while the device is unlocked and, if you keep the file open, continue to access that file after the user locks the device.
• Using the NSFileProtectionCompleteUntilFirstUserAuthentication option, your application cannot access the file while the device is booting or until the user unlocks the device. After the user unlocks the device for the first time, you can access the file even if the user subsequently locks the device again.

You should protect files as soon as possible after creating them.

Custom Appearance for UIKit Controls

You can now customize the appearance of many UIKit views and controls to give your application a unique look and feel. For example, you might use these customizations to make the standard system controls match the branding for the rest of your application.

UIKit supports the following customizations:

• You can set the tint color, background image, and title position properties (among other) on a wide variety of objects, including toolbars, navigation bars, search bars, buttons, sliders, and some other controls.
• You can set attributes of some objects directly, or you can set the default attributes to use for a class using an appearance proxy.An appearance proxy is an object you use to modify the default appearance of visual objects such as views and bar items. Classes that adopt the UIAppearance protocol support the use of an appearance proxy. To modify the default appearance of such a class, retrieve its proxy object using the appearance class method and call the returned object’s methods to set new default values. A proxy object implements those methods and properties from its proxied class that are tagged with the UI_APPEARANCE_SELECTOR macro. For example, you can use a proxy object to change the default tint color (through the progressTintColor or trackTintColor properties) of the UIProgressViewclass.If you want to set a different default appearance based on how a given object is used in your application, you can do so using the proxy object returned by the appearanceWhenContainedIn:method instead. For example, you use this proxy object to set specific default values for a button only when it is contained inside a navigation bar.Any changes you make with a proxy object are applied, at view layout time, to all instances of the class that exist or that are subsequently created. However, you can still override the proxy defaults later using the methods and properties of a given instance.

Container View Controller Support

The UIViewController class now allows you to define your own custom container view controllers and present content in new and interesting ways. Examples of existing container view controllers include UINavigationController, UITabBarController, andUISplitViewController. These view controllers mix custom content with content provided by one or more separate view controller objects to create a unique presentation for application content. Container view controllers act as a parent for their contained view controllers, forwarding important messages about rotations and other relevant events to their children.

Settings

Applications that deliver custom preferences can now use a new radio group element. This element is similar to the multivalue element for selecting one item from a list of choices. The difference is that the radio group element displays its choices inline with your preferences instead of on a separate page.

Xcode Tools

The following sections describe the improvements to the Xcode tools and the support for developing iOS applications. For detailed information about the features available in Xcode 4.2, see Xcode New Features User Guide.

Xcode Improvements

Xcode 4.2 adds support for many features that are available in iOS 5.0.

• The LLVM compiler supports Automatic Reference Counting (ARC), and Xcode includes a menu item to convert targets to use ARC. (For more information about ARC and about how to use it in your applications, see “Automatic Reference Counting.”)
• The Interface Builder user interface provides support for creating storyboard files for your iOS applications. (For more information about using storyboards in your iOS applications, see “Storyboards.”)
• In iOS Simulator, you can now simulate different locations for applications using the Core Location framework.
• You can download your application data from an iOS device and automatically restore that data when debugging or testing in iOS simulator or on a device.

OpenGL ES Debugging

The debugging experience in Xcode has been updated to include a new workflow for debugging OpenGL ES applications. You can now use Xcode to do the following for your OpenGL ES applications:

• Introspect OpenGL ES state information and objects such as view textures, shaders, and so on.
• Set breakpoints on OpenGL ES errors, set conditional OpenGL ES entry point breakpoints, break on frame boundaries, and so on.

UI Automation Enhancements

The Automation instrument now includes a script editor and the ability to capture (record) actions into your script as you perform them on a device. There are also enhancements to the objects that you use in the Automation instrument to automate UI testing:

• The UIATarget object can now simulate rotate gestures and location changes.
• The UIAHost object supports executing a task from the Instruments application itself.
• The UIAElement object can now simulate a rotate gesture centered on the element.
• Several functions that were previously available only in UIAWindow and UIAPopover were moved to UIAElement because they are common to all element objects.
• The UIAKeyboard object now supports performing a sequence of keyboard taps to simulate the typing of a string.

Instruments

The Instruments application in Xcode 4.2 adds several new instruments for iOS developers:

• System Trace for iOS—Uses several instruments to profile aspects of Mac OS X or iOS that could be affecting application performance, such as system calls, thread scheduling, and VM operations.
• Network Connections instrument—Inspect how your application is using TCP/IP and UDP/IP connections. With this instrument it is possible to see how much data is flowing through each connection and for each application. You can also use it to display interesting statistics, such as round trip times and retransmission request information.
• Network Activity (located in Energy Diagnostics)—Helps bridge the gap between networking (cellular and WiFi) and energy usage. You use it to display device-wide data flow through each network interface alongside energy usage level data that is taken directly from the battery.

Additional Framework Enhancements

In addition to the items discussed in the preceding sections, the following frameworks have additional enhancements. For a complete list of new interfaces, see iOS 5.0 API Diffs.

UIKit

The UIKit framework includes the following enhancements:

• The UIViewController class can now be used to create custom container view controllers; see “Container View Controller Support.”
• The UIKit framework provides support for loading and using storyboards; see “Storyboards.”
• Bars and bar button items can now be tinted and customized for your application; see “Custom Appearance for UIKit Controls.”
• The UIPageViewController class is a new container view controller for creating page-turn transitions between view controllers.
• The UIReferenceLibraryViewController class adds support for presenting a custom dictionary service to the user.
• The UIImagePickerController class supports new options for specifying the quality of video recordings.
• The UIStepper class is a new control for incrementing a floating-point value value up or down within a configurable range.
• View-based animations now support cross-dissolve, flip-from-top, and flip-from-bottom animations; see UIView Class Reference.
• The UIApplication class now reports the language directionality of the running application.
• The exclusiveTouch property of the UIControl class now defaults to YES instead of NO.
• The UITableView class adds support for automatic row animations, moving rows and sections, multiselection, and copy and paste behaviors for cells.
• The UIScreen class lets you specify overscan compensation behaviors for video delivered over AirPlay or through an attached HDMI cable. You can also programmatically set a screen’s brightness.
• The UIScrollView class now exposes its gesture recognizers so that you can configure them more precisely for your application.
• The UISegmentedControl class now supports proportional segment widths.
• The UIAlertView class now supports password-style text entry and special configurations for entering text securely.
• The UIColor class includes support for Core Image and new methods to retrieve individual color values.
• The UIImage class includes support for Core Image, support for stretching an image by tiling part of its content, and support for looping animations.
• The UITextInputTraits protocol adds support for a Twitter-specific keyboard and separate spell-checking behavior.
• The UIAccessibility protocol includes new interfaces that define the activation point within an element and indicate whether an element is modal or contains hidden elements. There are also new notifications that inform you of changes in system-provided accessibility features, such as zoom, audio status, and closed captioning.
• The UIAccessibilityReadingContent protocol allows you to provide a continuous, page-turning reading experience to VoiceOver users.
• The UIAccessibilityIdentification protocol allows you to uniquely identify elements in your app so that you can refer to them in automation scripts.
• The UIWebView class automatically supports the presentation of multimedia content over AirPlay. You can opt out of this behavior by changing the value in the mediaPlaybackAllowsAirPlay property of the class. This class also exposes a scrollView property so that you can access the scrolling properties of your web interfaces.

OpenAL

The OpenAL framework has two significant extensions:

• You can get notifications about source state changes and changes regarding the number of audio buffers that have been processed.
• The Apple Spatial Audio extension in iOS 5.0 adds three audio effects that are especially useful for games: reverberation, obstruction effects, and occlusion effects.

Message UI

The Message UI framework adds a new notification for tracking changes to the device’s ability to send text messages.

Media Player

The Media Player framework includes the following enhancements:

• There is now support for displaying “Now Playing” information in the lock screen and multitasking controls. This information can also be displayed on an Apple TV and with content delivered via AirPlay.
• You can detect whether video is being streamed to an AirPlay device using the airPlayVideoActive property of theMPMoviePlayerController class.
• Applications can now use the framework to play content from iTunes University.

Map Kit

The Map Kit framework supports the ability to use heading data to rotate a map based on the user’s current orientation. As you can with the Maps application, you can configure your map view to scroll the map according to the user’s current location. For example, a walking tour application might use this to show the user their current location on the tour.

For information on the interfaces you use to implement map scrolling and rotation, see Map Kit Framework Reference.

iAd

The iAd framework provides new callback methods for developers who use multiple add networks and want to be notified when a new ad is available. The bannerViewWillLoadAd: method (defined in the ADBannerViewDelegate protocol) is called when a banner has confirmed that an ad is available but before the ad is fully downloaded and ready to be presented. The interstitialAdWillLoad: method (defined in theADInterstitialAdDelegate protocol) offers similar behavior for interstitial ads.

Game Kit

The Game Kit framework and Game Center now have the following features:

• The GKTurnBasedMatch class provides support for turn-based gaming, which allows games to create persistent matches whose state is stored in iCloud. Your game manages the state information for the match and determines which player must act to advance the state of the match.
• Your game can now adjust the default leaderboard (implemented by the GKLeaderboard class) shown to each player. If your game does not change the default leaderboard for a player, that player sees the leaderboard configured for your application in iTunes Connect.
• The GKNotificationBanner class implements a customizable banner similar to the banner shown to players when they log in to Game Center. Your game may use this banner to display messages to the player.
• When your game reports an achievement, it can automatically display a banner to the player using the GKAchievement class.
• A GKMatchmakerViewController object can now add players to an existing match in addition to creating a new match.
• The GKMatchDelegate protocol now includes a method to reconnect devices when a two-player match is disconnected.

Foundation

The Foundation framework includes the following enhancements:

• The NSFileManager class includes new methods for moving a file to a user’s iCloud storage.
• The new NSFileCoordinator class and NSFilePresenter protocol implement now locking support and notifications when manipulating documents in iCloud.
• The new NSFileVersion class reports and manages conflicts between different versions of a file in iCloud.
• The NSURL class includes new methods and constants to support syncing items to a user’s iCloud storage.
• The new NSMetadataQuery class supports attributes for items synced to a user’s iCloud storage. Several other metadata-related classes were also added, including NSMetadataItem, NSMetadataQueryResultGroup, and NSMetadataQueryAttributeValueTuple.
• The new NSJSONSerialization class is a new class that supports back-and-forth conversions between JSON data and Foundation types.
• The new NSLinguisticTagger class is a new class lets you break down a sentence into its grammatical components, allowing the determination of nouns, verbs, adverbs, and so on. This tagging works fully for English and the class also provides a method to find out what capabilities are available for other languages.
• This framework now includes the NSFileWrapper class for managing file packages—that is, files implemented as an opaque directory.
• The new NSOrderedSet collection class offers the semantics of sets, whereby each element occurs at most once in the collection, but where elements are in a specific order.
• Most delegate methods are now declared using formal protocols instead of as categories on NSObject.

Event Kit and Event Kit UI

The Event Kit framework includes the following enhancements:

• The class hierarchy has been restructured. There is now a common base class called EKObject and portions of the EKEvent class have been moved into a new base class called EKCalendarItem.
• With the EKEventStore class, you can now create and delete calendars programmatically, fetch calendars based on their identifier, save and remove events in batches, and trigger a programmatic refresh of calendar data.
• The new EKSource class represents the source for creating new calendars and events.
• The EKCalendar class now provides access to a calendar’s UUID, source, and other attributes.

The Event Kit UI framework now includes the EKCalendarChooser class, which provides a standard way for selecting from the user’s iCal calendars.

Core Motion

The Core Motion framework now supports reporting heading information and magnetometer data for devices that have the corresponding hardware.

Core Location

The Core Location framework (CoreLocation.framework) now includes support for both forward and reverse geocoding location data. This support allows you to convert back and forth between a set of map coordinates and information about the street, city, country (and so on) at that coordinate.

Core Graphics

The Core Graphics framework (CoreGraphics.framework) includes some new interfaces to support the creation of paths. Specifically, there are new interfaces for creating paths with an ellipse or rectangle and for adding arcs to existing paths.

Core Data

The Core Data framework includes the following enhancements:

• Core Data provides integration with the iOS document architecture and iCloud storage. The UIManagedDocument class is a concrete subclass of UIDocument that uses a Core Data persistent store for document data storage.
• For applications built for iOS 5.0 or later, persistent stores now store data by default in an encrypted format on disk. The default protection level prevents access to the data until after the user unlocks the device for the first time. You can change the protection level by assigning a custom value to the NSPersistentStoreFileProtectionKey key when configuring your persistent stores. For additional information about the data protection that are new in iOS 5.0, see “Data Protection Improvements.”
• Core Data formalizes the concurrency model for the NSManagedObjectContext class with new options. When you create a context, you can specify the concurrency pattern to use with it: thread confinement, a private dispatch queue, or the main dispatch queue. TheNSConfinementConcurrencyType option provides the same behavior that was present on versions of iOS prior to 5.0 and is the default. When sending messages to a context created with a queue association, you must use the performBlock: or performBlockAndWait:method if your code is not already executing on that queue (for the main queue type) or within the scope of a performBlock... invocation (for the private queue type). Within the blocks passed to those methods, you can use the methods of NSManagedObjectContext freely. TheperformBlockAndWait: method supports API reentrancy. The performBlock: method includes an autorelease pool and calls theprocessPendingChanges method upon completion.
• You can create nested managed object contexts, in which the parent object store of a context is another managed object context rather than the persistent store coordinator. This means that fetch and save operations are mediated by the parent context instead of by a coordinator. This pattern has a number of usage scenarios, including performing background operations on a second thread or queue and managing discardable edits, such as in an inspector window or viewNested contexts make it more important than ever that you adopt the “pass the baton” approach of accessing a context (by passing a context from one view controller to the next) rather than retrieving it directly from the application delegate.
• Managed objects support two significant new features: ordered relationships, and external storage for attribute values. If you specify that the value of a managed object attribute may be stored as an external record, Core Data heuristically decides on a per-value basis whether it should save the data directly in the database or store a URI to a separate file that it manages for you.
• There are two new classes, NSIncrementalStore and NSIncrementalStoreNode, that you can use to implement support for nonatomic persistent stores. The store does not have to be a relational database—for example, you could use a web service as the back end.

Core Audio

The Core Audio family of frameworks includes the following changes in iOS 5.0:

• Audio-session routing information is now specified using dictionary keys. There are also new modes for managing your application’s audio behavior:
  • Voice chat mode optimizes the system for two-way voice conversation.
  • Video recording mode configures the device for video capture.
  • Measurement mode disables automatic compression and limiting for audio input.
  • Default mode provides iOS 4.3.3 behavior.
• Core Audio adds seven new audio units for handling advanced audio processing features in your application, such as reverb, adjustable equalization, and time compression and stretching. The new Sampler unit lets you create music instruments, for which you can provide your own sounds. The new AUFilePlayer unit lets you play sound files and feed them directly to other audio units.
• The 3D Mixer audio unit is enhanced in iOS 5.0 to provide reverb and other effects useful in game audio.
• You can automate audio unit parameters in an audio processing graph, which lets you build a music mixer that remembers fader positions and changes.
• You can now use the advanced features of Apple Core Audio Format files in iOS. For example, you might create new voices for the Sampler audio unit.
• There is now programmatic support for adjusting the audio input gain.
• Core Audio now supports 32-bit floating-point audio data for applications that need to provide high quality audio.

AV Foundation

The AV Foundation framework includes the following enhancements:

• There is automatic support for playing audio and video content over AirPlay. Applications can opt out of transmitting video over AirPlay using the allowsAirPlayVideo property of the AVPlayer class.
• New properties on the AVPlayerItem class indicate whether the item supports fast-forwarding or rewinding of the content.

Assets Library

The Assets Library framework includes the following enhancements:

• Support for accessing photo streams
• Support for creating new albums in the user’s photo library
• Support for adding assets to albums
• The ability to get an aspect ratio thumbnail for an asset
• The ability to modify saved assets

Address Book

The Address Book framework adds support for importing and exporting vCard data. It also adds new keys to associate social network affiliations with a user record.

Security

The Security framework (Security.framework) now includes the Secure Transport interfaces, which are Apple’s implementation of the SSL/TLS protocols. You can use these interfaces to configure and manage SSL sessions, manage ciphers, and manage certificates.

With an explosion of online content there is consequently an explosion of content management systems (CMS) available to help you manage that content, with literally thousands of vendors to sift through. But most CMS’ still end up being too expensive, too difficult to maintain, and eventually inadequate. This is often the result of purchase decisions based on technology, and not business requirements.

So then, how are CMS solutions chosen? You will usually compare product features, ask friends and colleagues, and look to different analyst ratings. In theory, this should be an excellent way to pick the right solution and sometimes it is. But content management systems have been around for over two decades and the features and functionality for the most part are starting to become commoditized . The ‘bells and whistles’ that these solutions try to distinguish themselves with, ultimately have no bearing on your content-specific needs. And this is why most solutions you purchase will end up being junked after they fail to do what is asked of them.

To ensure successful implementation and adoption, the CMS solution must be implemented like any other large enterprise application, with clear objectives and systematic planning mechanisms. So let’s look at some best practices that should be on everyone’s checklist before deploying any CMS within your organization.

#1 Define CMS Goals

Before installing a CMS, it is extremely important to identify key business goals that must be achieved. Business goals can be defined around parameters like productivity, efficiency, quality, ROI, or branding. Without this clear vision of the business goals, CMS implementations are very likely to fail. It is not surprising to find that most CMS implementations often overshoot budgets and in the long run, consume far more time, energy and resources than ever expected–just to stay functional.

Think of this step like vacationing in an exotic locale. You can go two ways: hope that when you get there, everything you need and want to do will be waiting for you. Or like most of us you plan accordinly: where you’re going to stay, what sites you will visit, and find all the best deals in the process. Which makes more sense to you?

#2 Evaluate the Content Information Landscape

The next step is to start gathering details of your content information landscape. Rather than looking only at technology, you should look at how processes, business rules, and the content are defined.

With these details on the content information landscape, parameters can be defined for CMS selection. The CMS purchased should also easily integrate with multiple systems that affect this landscape as well as are necessary to help meet your defined business goals – such as campaign management systems or CRM applications. The sequitur here is: don’t purchase CMS before clearly defining your requirements. You will save yourself time and resources with a clearly envisioned road map to guide you.

#3 Select the Right CMS Solution for Your Organization

Selecting the right CMS involves consideration of a host of factors, including:

1. Ease of use for users and IT administrators

Like any other business application, the success of a CMS depends on adoption by the end user community. Subject matter experts (SMEs) with no technical knowledge must be absolutely comfortable using the system to achieve the exact look and feel they want for content presentation. Similarly, IT administrators must be able to easily enforce policies across multiple Websites using a single console, and integrate the CMS effortlessly into the organization’s IT landscape. Consider everyone’s roles and responsibilities and make sure the CMS can meet those demands.

• Speed of deployment

There is a direct correlation between CMS implementation/configuration time and costs incurred. A CMS that requires extensive coding will definitely increase implementation costs. Hence, a CMS will only be effective if it can be rapidly configured and deployed, and as such, requires minimal training for use by non-technical professionals.

• Total-cost-of-ownership (TCO)

Most organizations make the classic mistake of buying a CMS based on license price. The real work of owning a CMS begins after the site is live and as such CMS maintenance/support expenses far exceed purchase costs. Be sure to factor this into your overall costs and consider the TCO of an application to arrive at an informed decision.

#4 Involve All Critical Stakeholders

Just as it is important to have top management support for CMS implementations, it is equally crucial to encourage the participation of internal stakeholders. These content owners should be identified and their feedback on usability leveraged to build and customize the system. Involving non-technical SMEs in the design of the new CMS will also help minimize reluctance to use the system. The success of the CMS rests on this acceptance of the CMS by the shareholders .

#5 Don’t Forget the Services Aspect

As we said in step 3 the real work in any CMS implementation begins post-launch. There is a spike in effort levels at the beginning of any implementation – but for a relatively short period of time compared to the average CMS lifetime.

Change is a constant with most Web sites and your CMS needs to be as flexible as your organization, whether this is a simple template change or an entire site redesign. You need to factor in and expect that you will need to have some level of service be it from your internal IT department, your Web agency or your software vendor

On top of ongoing support and management, you also need basic application and infrastructure support of the installed software. This requires the efforts of a dedicated team, responsible for managing hardware, software, and the network.

For some organizations this is not a problem: with dedicated in-house teams for HTML template creation and modification, workflow revisions, architecture changes, site redesign support, and training, they can prepare for the worst. But for the vast majority, this is often overlooked as a part of an ongoing CMS implementation. Without this dedicated team small businesses often outsource these ‘services’ to a third party vendor, adding to the implementation costs. To avoid the distress of exceeding budget, these costs must be factored into the total implementation costs.

# 6 Plan for the Future

How scalable and flexible is the CMS when it comes to incorporating new features or managing an explosion of content? You must make sure that the chosen CMS partner/vendor has the technological bandwidth and capability to quickly capitalize on emerging communication media.

Conclusion

CMS implementation processes can be a lengthy and energy-consuming. But following the guidelines illustrated here: clearly defined goals, processes mapped to the application, gaps identified, and looking for a customized application with dependable scalability and flexibility, you can help yourself avoid some common potholes and choose the right CMS for you.

Article Source: http://www.articlesbase.com/web-design-articles/choose-the-right-content-management-system-cms-for-you-377087.html

Author: Reelay John

Article Source: http://www.articlesbase.com/programming-articles/creating-a-shopping-cart-2564538.html

For any software development or other project initiative your company may be considering, it is critical to have in place and practice a set of effective and proven guidelines to ensure project success and delivery of the expected results: taking into consideration the role and responsibilities of a well-qualified project manager, knowledge of important business and financial aspects, and a step-by-step process that all contribute to the solid foundation and implementation of an effective project plan.

Developing a Practical Approach: The Role of the Project Manager

When undertaking a software development project, the first element to consider is the establishment of a comprehensive yet practical approach to the initiative that ultimately will lead to a successful end result.

The in-house project manager has a key role in ensuring each phase of the project is carried out as planned. The project manager is responsible for considering the potential risks involved with the project and how to avoid and resolve them, establishing and maintaining momentum throughout the project, ensuring individual project team member tasks are assigned appropriately and carried out according to specifications, and successfully addressing and resolving any conflicts that may arise during the length of the development project.

A well-qualified project manager is able to address what may seem to be an overwhelmingly complex process by developing an organized approach where the process is broken down into manageable individual tasks and understanding how to keep those involved in the project dedicated to the ultimate goal of meeting and even exceeding the expected end result.

If the project manager dedicates the necessary time, effort, and resources to the preparation of an efficient, comprehensive, and practical approach, then the project team may progress with ease and confidence as they deliver on their individual tasks, having a solid foundation and strategic framework at the outset. Far too often, however, failures with such projects are the result of not only a poorly executed plan, but one that ultimately lacked the fundamental elements of a well-though-out approach rooted in adequate preparation and commitment from the project manager and project team.

Designing a strategic plan means taking into consideration all aspects that can contribute to success or potential failure.

Embarking on the Initiative: Key Steps to Consider

With a comprehensive approach and a competent project manager in place to guide the new software development initiative, there is another important element your organization may find helpful as you embark on the project: establishing specific steps that can be followed to project completion that are based on proven industry experience in such a project environment.

Following are a set of practical guidelines to approach a software development project, established by two university professors and business consultants with specialized expertise in the computing, engineering, and general business environments.

Dr. Gordon Scott Gehrs is an adjunct instructor at the Illinois Institute of Technology (IIT) and a business consultant for the Jules F. Knapp Entrepreneurship Center at IIT. Dr. Dorota Huizinga is associate dean of the College of Engineering and Computer Science and a professor in the Computer Science Department at California State University, Fullerton, as well as a frequent business seminar speaker, a business consultant, and co-author of Automated Defect Prevention: Best Practices in Software Management.

Read on for nine key steps to consider as you embark on a software development project.

Step #1: Conduct Feasibility Analysis
According to Dr. Gehrs, a critical first step is to interview stakeholders in order to uncover whether a specific need exists, identify this exact need, and determine whether the proposed project can feasibly deliver the expected software development. “Many times, this is the point at which an ROI study will be carried out in order to determine project costs and benefits,” says Dr. Gehrs.

Step #2: Analyze and Determine Requirements
When it comes to the next step of determining requirements, Dr. Gehrs believes a proper analysis should consist of interviews with end users and others who will be associated with the new software system. In addition, a thorough review and a keen understanding of user documents, business rules, and processes are keys to determining appropriate and necessary features and functionality. This is a valuable and significant step in the development process and the point at which such deliverables as those documents outlining the scope of the project and those detailing the software product requirement will be produced.

Dr. Huizinga notes the importance of having the minimum technology infrastructure in place before beginning a software project, which include:

• Desktops for development with an advanced integrated development environment suite.
• A server with a configuration management system for document tracking and version control.
• A staging server for integration testing and a production server for deployment of the final product.
• A requirement/task/defect tracking tool.
• An automated build system.
• A regression testing tool.
• An automated reporting system.

“Investing in the proper infrastructure is essential and will pay back quickly,” asserts Dr. Huizinga. There are three key elements the proper infrastructure provides:

• Product and project visibility
• Automation of repetitive and mundane tasks
• Facilitation of collaboration

Step #3: Consider Industry Best Practices
When defining a software development process, consider proven industry best practices. Dr. Huizinga recommends a good, customized Agile process with emphasis on pictorial documentation both for requirements and technical documentation. It is important to follow a standard template and all activities should be traceable through a requirements/task/defect tool and shared document repository.

Step #4: Design
During the design phase, the software architect, programmer, and/or developer may put together a detailed design document outlining exactly how the software will meet the specified requirements. Dr. Gehrs recommends the use of mock-ups to accompany the design document as a way of illustrating user-interface elements.

In some cases, customization is required in order to meet specific, individual project needs. For example, Dr. Huizinga notes that this might include the use of specialized COTS (commercial off-the-shelf) hardware and software components. The wide spectrum of products from databases to game engines is dictated by the market shift to customization of existing commercial applications to fit project needs rather than in-house development of such systems. According to Dr. Huizinga, COTS can offer higher quality because they are developed by vendors who specialize in systems that provide the required functionality and are well-tested by many users.

Step #5: Measuring and Tracking Progress
Without the proper technology infrastructure in place, it is difficult to collect and measure key project data. “Consequently, the software projects cannot be managed effectively,” says Dr. Huizinga. Project indicators can help to ensure the prompt identification of potential or existing problems, therefore allowing them to be recognized and remedied in a timely manner. When observed over an extended period, notes Dr. Huizinga, these indicators can be used to determine product quality and deployment readiness.

Step #6: Development
At the development phase, the design document is translated into a real piece of software. When prior careful planning has been executed, the software will match the requirements of the business driver that initiated the need for the project. Dr. Gehrs points out that development cycles may produce several versions of the software:

• Alpha: preliminary feature/functionality only
• Beta: used for internal testing or usability testing
• Release Candidates: usually a very stable build that may need minor tweaks
• Production Build or Gold Master: ready for release.

Project managers need feedback on the user’s navigational experience, task-completion times, ease of use, and other information related to the user interface and user-centric elements.

Step #7: Addressing Automation
Another key step is to ensure the automation of repetitive tasks:

• Code builds;
• Static code analysis scans;
• Regression tests;
• Collection of project- and product-related measures.

Dr. Huizinga believes that taking such measures reduces the error-prone human influence when the software is implemented. It also facilitates the use of best practices and collection of project-related data. “All repetitive and mundane tasks should be automated whenever possible in any portion of the software life cycle,” she adds.

Step #8: Testing
As the project continues on through each phase and on to testing, a general progression of action is as follows: software features are laid out in some sort of list, scripts are written for each task the user might perform, and those features are tested to ensure they function properly. Dr. Gehrs points out that testing also may vary quite widely depending on the individual testing procedures adopted by the organization. Testing can consist of several sub-stages as well, such as quality assurance and staging.

Once the software is in general use, any bugs found at this point are addressed based on a criticality scale: urgent fixes are scheduled to be carried out as soon as possible. In addition, feature enhancements/changes may be slated for future upgrade versions.

Step #9: Gradual Implementation Practices
“Incremental implementation of the above practices is critical to success. The approach of gradually introducing change group by group and practice by practice is essential to achieving the desired organizational culture change, as change is unsettling, and there will always be some degree of resistance,” points out Dr. Huizinga. Because of the complex nature of software projects and the technology involved, new software development warrants this systematic approach.

Understanding the role of the project leader and importance of having well-thought-out development processes in place may be a company’s only real competitive advantage in an increasingly competitive marketplace. It is the ultimate secret weapon to winning business and successfully delivering new easy-to-use software.

With workable and disciplined software project guidelines and well-qualified project managers, your organization can’t lose.

Article Source: http://www.articlesbase.com/software-articles/9-steps-to-a-hassle-free-and-effective-software-development-project-869180.html

About the Author

ExecutiveBrief, the technology management resource for business leaders, offers articles loaded with proven tips, techniques, and action plans that companies can use to better manage people, processes and tools – the keys to improving their business performance.
For more information visit us at: http://www.executivebrief.com.

I have renewed faith in Microsoft, commerce and therefore the world. See how fickle I am that a new phone OS can make me feel that way? :)

- Jack

From the MS press release:

With Windows Phone 7 Series, Microsoft takes a fundamentally different approach to phone software. Smart design begins with a new, holistic design system that informs every aspect of the phone, from its visually appealing layout and motion to its function and hardware integration. On the Start screen, dynamically updated “live tiles” show users real-time content directly, breaking the mold of static icons that serve as an intermediate step on the way to an application. Create a tile of a friend, and the user gains a readable, up-to-date view of a friend’s latest pictures and posts, just by glancing at Start.

Every Windows Phone 7 Series phone will come with a dedicated hardware button for Bing, providing one-click access to search from anywhere on the phone, while a special implementation of Bing search provides intent-specific results, delivering the most relevant Web or local results, depending on the type of query.

Windows Phone 7 Series creates an unrivaled set of integrated experiences on a phone through Windows Phone hubs. Hubs bring together related content from the Web, applications and services into a single view to simplify common tasks. Windows Phone 7 Series includes six hubs built on specific themes reflecting activities that matter most to people:

The major points:

1) It runs iPhone OS and runs the iPhone apps that exist in full screen mode

2) It is a half inch thick

3) It supports 16 to 64 GB of memory

4) It has bluetooth, wifi and optional 3GS from AT&T

5) You get 10 hours of battery life, a month if you don’t turn the sucker on

6) It is sexy looking and you can read all your PDFs plus iBooks are the thing, a boatload of publishers have signed up to provide content

Pricing

If you want 3G it is 14.99 for 250 MB per month and 29.99 for unlimited data. Not a bad deal and this is no contract and the device is not locked to AT&T

For you programmers out there:

User Interface Changes

Applications running on iPad have several new options for presenting content and receiving input from the user.

Popovers

Popovers are floating views that reside above your application’s window and help you organize the contents of your user interface. Popovers help to eliminate the clutter that might occur in applications that need to display important controls or information in an unobtrusive way that does not distract from the main content.

The benefit of using a popover is that:

• It appears only in response to specific user interactions and is dismissed automatically when the user taps outside of its bounds. This behavior makes the popover less obtrusive to the user.
• It typically covers only a small portion of the screen and so does not obscure as much of the underlying content as a modal view might.

Split Views

The UISplitViewController class is a new container view controller that you use to manage two side-by-side content views. These content views are typically used to create a master-detail interface, whereby selecting an item in one view causes the other view to display detailed information about the selection. The views themselves are managed by view controllers that you provide.

The split view controller coordinates any interactions between your view controllers and the system. For example, when the user rotates the device, the split view controller rotates both view controllers together, forwarding any needed notifications to both of them.

Custom Input Views

Instances of the UIResponder class now support the ability to display custom input and accessory views when they become the first responder. Now, you can provide input views for any of your custom views and have them presented automatically by the system. (Previously, the keyboard was the only supported input view, and it was supported only by text view and text field objects.)

In addition to input views, you can also provide a custom accessory view to display above the input view. Accessory views are commonly used to provide additional buttons and controls when the keyboard is displayed. The explicit support now provided by responder objects makes it easy to animate your accessory views into position.

External Display Support

An iPad can be connected to an external display through a set of supported cables. When connected, the associated screen can be used by the application to display content. Information about the screen, including its supported resolutions, is accessible through the interfaces of the UIKit framework. You also use that framework to associate your application’s windows with one screen or another.

• The UIScreen class provides support for retrieving screen objects for all available screens (including the device’s main screen). Each screen object contains information about the properties of the screen itself, including the dimensions that correctly take into account the size and pixel aspect ratio of the screen.
• The UIScreenMode class provides information about one particular size and pixel aspect ratio setting of a screen.
• Windows (represented by the UIWindow class) can now be assigned to a specific screen.

Gesture Recognizers

Gesture recognizers are objects that you attach to views and use to detect common types of gestures. After attaching it to your view, you tell it what action you want performed when the gesture occurs. The gesture recognizer object then tracks the raw events and applies the system-defined heuristics for what the given gesture should be. Prior to gesture recognizers, the process for detecting a gesture involved tracking the raw stream of touch events coming to your view and applying potentially complicated heuristics to determine whether the events represented the given gesture.

UIKit now includes a UIGestureRecognizer class that defines the basic behavior for all gesture recognizers. You can define your own custom gesture recognizer subclasses or use one of the system-supplied subclasses to handle any of the following standard gestures:

• Tapping (any number of taps)
• Pinching in and out (for zooming)
• Panning or dragging
• Swiping (in any direction)
• Rotating (fingers moving in opposite directions)
• Long presses

Improved Text Support

In iPhone OS 3.2, there is significant new support for text input and rendering. This support is provided for applications, such as word processors, that need more sophisticated text-handling capabilities.

Core Text

The Core Text framework (CoreText.framework) contains a set of simple, high-performance C-based interfaces for laying out text and handling fonts. The Core Text framework provides a complete text layout engine that you can use to manage the placement of text on the screen. The text you manage can also be styled with different fonts and rendering attributes.

This framework is intended for use by applications that require sophisticated text handling capabilities, such as word processing applications. If your application requires only simple text input and display, you should continue to use the existing classes of the UIKit framework.

Text Input Support

The UIKit framework (UIKit.framework) includes new protocols that allow you to implement custom text-input objects. If you are implementing an application that requires sophisticated text-handling capabilities, you can use these protocols to implement new views and controls for receiving incoming text. Depending on your needs, there are different protocols for receiving text input. Which protocols you use will depend on the complexity of your user interface.

• The UIKeyInput protocol lets you define simple objects (like text fields) that are capable of character-by-character input.
• The UITextInput protocol lets you define complex text views that support multiple lines of text, selections, pasteboard operations, and more.

Custom Font Support

Applications that want to use custom fonts can now include those fonts in their application bundle and register those fonts with the system by including the UIAppFonts key in their Info.plist file. The value of this key is an array of strings identifying the font files in the application’s bundle. When the system sees the key, it loads the specified fonts and makes them available to the application.

ICU Regular-Expression Support

The BSD layer of iPhone OS now exposes a modified version of 4.2 of the International Components for Unicode (ICU) libraries. ICU is an open-source project for Unicode support and software internationalization. The installed version of ICU includes only those header files necessary to support regular expressions.

File and Document Support

In iPhone OS 3.2, there is new support for exchanging and opening files. This support makes it easier to implement more document-centric applications, similar to what you might find on a desktop computer, while still maintaining a simplified interface for your users.

File-Sharing Support

Applications that want to share files with the user can now do so using the file-sharing support in iPhone OS 3.2. Here’s how it works:

1. An application indicates that it wants to share files by including the UIFileSharingEnabled key in its Info.plist file.
2. It puts whatever files it wants to share in its Documents/Shared directory.
3. When the device is plugged into the user’s computer, a mount point is added to the system and the contents of any shared directories appear on the user’s desktop.
4. Users can modify the contents of this directory freely by copying files out, deleting files, or dragging new files in.

Applications that support file sharing should recognize when files have been added to the directory or removed and respond appropriately. For example, if the user added files to the directory, your iPad application might make those files available from its interface. You should never expect the user to go searching for files in this directory, nor should your application rely on any files being in this directory. It is strictly for sharing files with the user’s computer.

Document Support

An application can now register the file types it supports with the system and receive notifications when a file of the given type needs to be opened. It does this by including the CFBundleDocumentTypes key in its Info.plist file. An application that registers one or more file types may also be expected to open files of those types at some point later. It does this by implementing the application:didFinishLaunchingWithOptions: method in its application delegate and look for a file in the UIApplicationLaunchOptionsURLKey key of the provided dictionary.

Complimenting the ability to open files of known types is the addition of the UIDocumentInteractionController class in the UIKit framework. This class provides a user-based interaction model for managing files that your application does not know how to open. The document interaction controller provides options for previewing the contents of a file in place or opening it in another application. Document interaction controllers are particularly useful for email applications or applications that may download files from the network.

PDF Generation

The UIKit framework (UIKit.framework) includes new functions for generating PDF files and data objects from your application’s custom content. You can use this support to generate PDF-based content for use within your application or for storing to the local disk. The UIKit functions manage the setup and pagination for the PDF data. You provide the actual content using the same native platform graphics technologies (UIKit, Core Graphics, Core Text, and so on) already available for drawing to the screen. (You cannot draw to a PDF context directly using OpenGL commands. However, you can transfer the pixels of your rendered content to a CGImageRef data type and draw that.)

Xcode Tools

Xcode includes new features to make developing applications that run on iPad much simpler, including the following:

• Xcode simplifies the process of sharing code between your iPhone and iPad applications by helping you update your existing iPhone projects to include the necessary files to support iPad. The Transition command (in the Project menu) creates a new target for the iPad and modifies a copy of your project’s nib files to support the larger screen size.
• Xcode simplifies the validation and submission process of your applications by allowing you to debug signed applications.
• You can now easily transfer your iPhone developer identity information to a new computer. The Organizer window includes an option to export your profile and certificate information. To begin developing on a new computer, all you have to do is import the resulting data file into Xcode on that computer.
• Interface Builder supports the new view controllers and window sizes available for iPad.

API Changes

The following frameworks and technologies include additional incremental changes.

UIKit Framework Changes

The UIKit framework includes the following additions:

• The UIBezierPath class is a new class that supports the creation of vector-based shapes. This class provides an object-oriented wrapper around Core Graphics paths.
• The UIScrollViewDelegate protocol includes additional methods for processing zoom-related events in a scroll view.
• Modal view controllers can now be presented in a style other than full screen. The UIViewController class includes a modalPresentationStyle property that allows you to present modal view controllers using one of several predefined styles.
• The UIMenuController class now allows you to add custom menu items. You can use custom menu items to augment the Cut, Copy, Paste, and Select behavior provided by the system.
• Support for popovers, described in “Popovers.”
• The UISplitViewController class, described in “Split Views.”
• Support for gesture recognizers, described in “Gesture Recognizers.”
• Support for implementing custom input and accessory views, described in “Custom Input Views.”
• Support for getting information about externally connected displays, described in “External Display Support”
• Support for creating PDF files, described in “PDF Generation.”
• Support for previewing and opening documents, described in “Document Support.”

Media Player Framework Changes

The video classes in the Media Player framework (MediaPlayer.framework) have been redesigned to give you more control over the presentation of video content. Instead of simply playing a video full screen, the MPMoviePlayerController class now vends a view that you can incorporate into your interface however you want. This class also includes more sophisticated support for managing and controlling the playback of movies.

For situations where you want a simpler alternative to movie presentation, you can now use the MPMoviePlayerViewController class. This new class provides a view controller-based wrapper for a movie interface and is for applications that want the same basic behavior offered by the older movie player controller design.

Core Animation Changes

The Core Animation technology (defined in QuartzCore.framework) includes the following additional features:

• The CATextLayer class is now available for incorporating text-based content into your layer hierarchies.
• You can now apply shadow effects to a layer and customize the appearance of the shadow using the shadowOpacity, shadowRadius, shadowOffset, shadowColor, and shadowPath properties.
• You can configure the rasterization behavior of the layer using the shouldRasterize and rasterizationScale properties.

MapKit Framework Changes

The MKReverseGeocoder class now includes a placemark property for accessing the placemark that was computed by the reverse geocoding service. You can use this property to retrieve placemark information after the results are reported to the associated delegate object.

Foundation Framework Changes

The NSString class now includes the ability to search the text of a string using regular expressions. The NSStringCompareOptions type includes a new flag called NSRegularExpressionSearch, which you can use in conjunction with the following methods:

• rangeOfString:options:
• rangeOfString:options:range:
• rangeOfString:options:range:locale:

When you pass the NSRegularExpressionSearch as an option, the search string is interpreted as a regular expression instead of a string literal. The regular expression syntax conforms to the syntax used by the International Components for Unicode (ICU) library. When performing regular expression searches, the only other options you can include in the mask parameter are the NSCaseInsensitiveSearch and the NSAnchoredSearch flags.

Because some regular expressions can trigger a match but still return a zero-length range, you should check both the location and range length of the result. If a match was unsuccessful, the search methods always return a range whose location is set to NSNotFound and whose length is 0.

Aaron Lennon – CTO, Gravity Jack

I noticed many postings on Amazon.com complaining about the 10 GB limited for AMI’s and how this prevented the installation of critical development components. I like the idea of Amazon keeping their AMI images as small as possible.

I will say it is not “simple” but there is a way to get the job done without having to perform any strange hacks that allow other drives to be seen as part of the system drive.

1) Start your windows AMI.
a. Any of the free default AMI’s that Amazon offers will do.

2) Create an EBS volume and attach it to your windows instance and attach it to your instance.
a. If you need help attaching the EBS volume then follow these instructions. http://www.reynoldsftw.com/2009/01/attaching-an-ebs-volume-to-ec2/
b. If you are hosting development environments on Amazon like I am it is good to checkout your Subversion repositories and host all SQL Server database files (.MDF .LDF) on an EBS volume for a fast and simple backup measure.
c. Make your EBS Volume 100GB or larger. I used 10GB for this example but there is no point to a 10GB EBS volume.

3) Install VS 2008
a. Select the options you want. I installed all languages because we host our development servers on Amazon and it is nice to be able to open a project in Visual Studio on the server is something is not working correctly after deployment. I also installed with Crystal Reports. The only options I didn’t install are a number of development tools for mobile applications and VSTO (Visual Studio Tools for Microsoft Office).

4) Install VS 2008 Service Pack
a. Now, assuming you have enough free space left install the Visual Studio 2008 service packs. These service packs don’t really take up much space at all but will fail to install if you don’t have a little over 3 gig free. If the installation does fail due to lack of free space then just install it again after the next step

5) Delete the following files to free a lot of space or move them to the D drive.
a. $NTServicePackUninstall* and $NtUninstallKB*
b. C:\WINDOWS\SoftwareDistribution\Download\

6) Install SQL Server 2008 and customize the installation so the databases are stored to the EBS volume you created in step 2.

7) Did it work? Check to be sure everything is working and clear your browser cache and uninstall any unneeded programs etc.
a. If everything went well you should still have over 2 GB of free space.

8) Bundle your new perfectly configured windows instance. (You don’t want to lose all the work you have done)
a. This is done easily from your AWS control panel. Just right click on your instance and choose Bundle Instance.
b. After you complete the bundle process you are able to start new Servers easily and the configurations can be replicated with a single click.

9) Take a Snapshot of your EBS Volume. (You don’t want to lose all the work you have done)
a. This is also easily done from your AWS Control Panel. Just right click on your EBS Volume and choose to make a Snapshot.
b. A new snapshot should be taken on regular intervals so you always have a good backup of your EBS volume.

If you have any questions about Amazon EC2 support for your applications, please contact me. I am happy to help.