Many application take advantage of the Mac OS X status bar to report their status or allow fast access to key program features. This short video course will show you how to add your own text and images to the status bar and respond to actions performed upon it.

This 26 minute video tutorial walks you through the process of creating reusable framework projects in Xcode and demonstrates everything you need to know to use them either directly in your projects or as shared frameworks on your Mac

It has been said that over 80% of bugs are related to memory problems. Understanding and implementing robust memory management practices in your application will reduce bugs and improve the efficiency of your application. If you are used to programming in languages such as Basic where memory management is not an issue or if you are used to the raw memory management practices of C and C++ then you will need to change your thinking to work with Objective-C’s reference counted memory management. This course walks you through Objective-C’s memory management techniques using over 86 minutes of video

There's a myth that in order to ship, you've got to get the product out the door as quickly as possible at all costs, code quality be damned. It's Dave's belief that writing clean, quality code is nearly as important as a working product. In this video of his NSConference 2010 session Dave goes over both the long- and short-term benefits of clean code and offers some advice on how to write clean code.

Mac OS X isn't just a sealed bucket of bits you receive on shiny optical discs -- under the hood is software just like you and I write (just lots more of it). It's beholden to the same laws of software-physics as you and I must obey. Together we'll spelunk the moist caverns of Mac OS X using tools like otool, otx and class-dump to explore the mach-o file format. Then we'll cover current injection technologies like Input Managers (incompatible with 64-bit), AppleScript Additions, mach_inject DYLD_INSERT_LIBRARIES. Finally, we'll talk about extension technologies like mach_override and JRSwizzle.

In some ways, we are still in infancy when it comes to harvest the enormous amount of power brought by dynamic object systems and frameworks such as Objective-C/Cocoa. Fortunately, new tools and technologies can help us. In this session, Philippe will get you up to speed with F-Script 2.0, a set of open source tools that complement Xcode and Interface Builder. You will learn how to use them, discover how they can bring Cocoa development productivity and fun to new highs, and acquire new programming superpowers not seen before on any other platform!

This video has been made available for FREE to support the Open Source effort behind F-Script

It's no surprise that Objective-C is a dynamic language, and that dynamic nature allows many design patterns that would be utterly painful in less dynamic languages with a more constrained object model. In addition to providing great flexibility, the Objective-C Runtime can be leveraged to maximize code reusability. By creating abstract superclasses that leverage the runtime to detect the properties created by their subclasses, methods can be written that do not need to be subclassed. Additional "free" functionality can be provided to subclasses using the runtime's ability to dynamically create and dispatch messages. In this session, you'll see how to leverage the inner workings of the Objective-C Runtime to reduce code clutter in your projects and create extremely reusable code that can be used in multiple Mac and iPhone applications without modification.

Core Animation is one of those technologies that is too easy to over hype. It does so many cool things that it is hard to not be overly enthusiastic about what you can do with it. Well Core Animation is not magic but it does make doing several things with your user interface much easier. In this session we are going to see what Core Animation is and how you can use it in your UI. In addition to learning about doing animations with Core Animation we will also learn how to use Core Animation to simplify your drawing and maximize the performance of your application. Come to this session and learn how to build applications that take advantage of this really exciting technology.

In this session, Marcus discusses using Core Animation and how to develop complex models. Throughout the session Marcus walks us through the more complex explicit animations as opposed to the more common implicit animations that are in wide use. The goal of this session is to help you get more comfortable with the more complex and interesting explicit animations and a better understanding of some of the things you can do with Core Animation.

This talk covers the technical lessons learned in developing Sumo Master for iPhone. Sumo Master is built entirely with the Core Animation framework, and various coding tips and tricks are included that are useful not only for games, but to add polish to any iPhone app. Aspects of the software process, such as brainstorming, design, iteration, working with a designer, and so forth, are also touched upon.

In this session, Marcus discusses his solution to local network data synchronization using Core Data and his new open source project ZSync. The session walks through how the synchronization of data works between a Mac OS X desktop/laptop and a Cocoa Touch device. This synchronization works whether the associated desktop application is running or not and has the added bonus of being able to synchronize with MobileMe if the end user happens to have an account.

This video has been made available for FREE to support the Open Source effort of ZSync

Marcus will walk through how to integrate a Core Data based application with both Spotlight and QuickLook. Add these important, and usually overlooked features, into your application to add that additional polish that we all expect from OS X applications. In this session we will discuss how these features work and how to get them to work with Core Data in a performance aware way.

This session will include a discussion of storing to and loading data from sqlite, webservices, webdav, ftp, archiving, Core Data, PostgreSQL, Tokyo Cabinet as well as others. Be ready for Code Snippets,Pros and Cons,The limitations of the Entity-Relationship model,Versioning,Change histories. Aaron also introduces his BNRPersistenceFramework.

This video has been made available for FREE to support the Open Source effort of BNRPersistenceFramework

Learn the ins and outs of adding network play to your applications. Jeff looks at using Apple's GameKit framework to add networking over Bluetooth and also looks at doing stream communications to support online and LAN play and techniques to support these two different approaches in the same application so you can offer users of your application both.

This talk covers the technical lessons learned in developing Sumo Master for iPhone. Sumo Master is built entirely with the Core Animation framework, and various coding tips and tricks are included that are useful not only for games, but to add polish to any iPhone app. Aspects of the software process, such as brainstorming, design, iteration, working with a designer, and so forth, are also touched upon.

Learn how to integrate your service or application with Apple’s photography applications iPhoto and Aperture. If your application consumes images, you’ll want to know how to get the most out of the Apple photography ecosystem. In this session, Fraser Speirs will cover the SDKs for iPhoto and Aperture and touch on some of the major System APIs you’ll want to be aware of when dealing with photographs on Mac OS X.

One reason for Mac OS X’s success is Objective-C, combining the dynamism of a scripting language with the performance of a compiled language. However, how does Objective-C work its magic and what principles is it based upon? In this session, we explore the inner workings of the Objective-C runtime, and see how a little knowledge about programming language foundations–such as lambda calculus and type theory–can go a long way to tackling difficult topics in Cocoa such as error handling and concurrency. We’ll cover a broad range of areas such as garbage collection, blocks, and data structure design, with a focus on practical tips and techniques that can immediately improve your own code’s quality and maintainability.

What if you could program the universe the way you can program a computer? What awesome feats could you accomplish with the ability to debug reality itself? Would the weight of responsibility drive you to use your powers for the good of all mankind? Are software engineers just glorified programmers, or are they latent superheroes? These questions and more will be answered with mind-bending thought experiments, and reports from the field.

Learn how to create your own digital watercolor brush in this session. Topics to be discussed include: using OpenCL to model the physics of how the watercolor pigments move around and are absorbed into the paper, and using Core Image to model the optics of compositing two watercolor glazes

Software Developers are in the midst of a crisis, and it is not of the financial variety --- it's the multi-core crisis. When Moore's Law for CPU clock speeds ground to halt around 2005, the chip manufacturers turned to multi-core in a bid to get more transistors on their chips. But multiple cores on each chip creates a whole new set of problems for software developers. There is no more free lunch; your software will not automatically get faster each year due to advances in CPU clock speed.

With Mac OS X 10.6 Snow Leopard, Apple have introduced the technologies that it thinks can help developers tackle multicore. Cocoa classes like NSOperation and NSOperationQueue, and Grand Central Dispatch, usher in a new approach to concurrency, an approach that is safer and easier to use than traditional multithreading. Based on the concept of 'packets of computation', these powerful new technologies require a new mindset from developers.

On a different front, the GPU is starting to be taken seriously as a device for more than just graphics. With hundreds of computational cores, a graphics chip can perform certain calculations much faster than a general purpose chip like the CPU. The new OpenCL standard, which is also supported in Snow Leopard, represents a watershed moment in the history of computing, and has the potential to change high-performance computing in much the same way that the introduction of OpenGL changed 3D graphics.

This 6.5 hour video course will teach you about these new technologies and how you can leverage them on Snow Leopard. It will also prepare you for the mind shift required to start using them in your application development.

This session is intended for experienced iPhone programmers who are unfamiliar with OpenGL ES and the mathematics and concepts of three dimensional graphics. It starts from the beginning, and talks about the architecture of OpenGL ES works and how it's implemented in the two GPUs currently available in iPhones and then goes on to review the basic mathematics of three dimensional graphics. Jeff looks at creating 3D geometry in third party applications and looks at the optimal ways to submit geometry to OpenGL ES, while discussing the differences between OpenGL ES 1.1, which is available on all iPhones and OpenGL ES 2.0, which is only available on the iPhone 3Gs and the 32mb and 64mb third generation iPod touch. Though starting from the beginning, this session crams a lot of information and sample code into an hour, giving you everything you need to hit the ground running with 3D programming on the iPhone.

Software Developers are in the midst of a crisis, and it is not of the financial variety --- it's the multi-core crisis. When Moore's Law for CPU clock speeds ground to halt around 2005, the chip manufacturers turned to multi-core in a bid to get more transistors on their chips. But multiple cores on each chip creates a whole new set of problems for software developers. There is no more free lunch; your software will not automatically get faster each year due to advances in CPU clock speed.

With Mac OS X 10.6 Snow Leopard, Apple have introduced the technologies that it thinks can help developers tackle multicore. Cocoa classes like NSOperation and NSOperationQueue, and Grand Central Dispatch, usher in a new approach to concurrency, an approach that is safer and easier to use than traditional multithreading. Based on the concept of 'packets of computation', these powerful new technologies require a new mindset from developers.

On a different front, the GPU is starting to be taken seriously as a device for more than just graphics. With hundreds of computational cores, a graphics chip can perform certain calculations much faster than a general purpose chip like the CPU. The new OpenCL standard, which is also supported in Snow Leopard, represents a watershed moment in the history of computing, and has the potential to change high-performance computing in much the same way that the introduction of OpenGL changed 3D graphics.

This 6.5 hour video course will teach you about these new technologies and how you can leverage them on Snow Leopard. It will also prepare you for the mind shift required to start using them in your application development.

Take a journey through the Mac performance cosmos, with stopovers in exotic destinations like Xgrid Foundation, NSOperation, and Grand Central Dispatch. Never observed an XGActionMonitor in full flight, or got your NSOperation priorities right? Join us for this once in a lifetime opportunity. We’ll look at the emerging trends, and common threads that bind all levels of the performance equation. How are the techniques used in High-Performance Computing similar to those used in modern Cocoa apps running on the latest multi-core laptops? Don’t know, but come along and we’ll see if we can figure it out. This talk will cover everything, from the death of multi-threading, to Snow Leopard niceties like blocks in C and OpenCL. Not to be missed.

Mac OS X has a reputation for being a secure operating platform, and many of its security features are available for third-party developers to use in their own application. But there’s also a more fundamental aspect to security – understanding how your software will be used and anticipating how it may be misused. In this session Graham gets us to take a step back and ask ourselves some basic questions about security

iPhone developers all use code signing all the time. They typically have one reason for that: they need to. But what does it do? Should Mac developers be signing their apps, too? How does code signing work? Is there anything it can't do? If you love code signing so much, Graham, why don't you marry it? These questions are all answered during this session.
WARNING: THIS PRESENTATION CONTAINS ADULT LANGUAGE,
IF THIS OFFENDS PLEASE DO NOT PURCHASE

Previously only available as part of the full NSConference 2009 video set we have decided to release the now infamous Cocoa Face Off session from NSConference 2009 as a stand alone purchase. A Mac developer Hints and Tips session cleverly disguised as a fun finish to NSConference 2009 in which a team from Europe takes on a team from the USA in an application design contest that gets a little out of hand as whole nations get insulted and friendly competition turns into deep set rivalry that will continue to run way after NSConference 2009 is over

It's hard to imagine an application that doesn't present any data to its user at all. In fact, designing a user interface is largely a question of establishing how best to expose the internal data representation of an application to the user. Data presentation can range from the very simple, such as a single text field, to more advanced but standard controls such as NSTableView and NSOutlineView, right up to completely custom visualizations and graphs. In this presentation, Drew McCormack takes a look at the resources available to a Cocoa developer for the presentation of data, and the circumstances in which each one is suitable. The question of when to use standard controls and when to search for a custom solution is also be addressed.

Takes a look at any of the most popular Mac applications and it quickly becomes clear that standard UI controls no longer suffice. Custom user interface is the order of the day, but consistency and intuitive interaction have never been more important – and that principle applies both to what the user sees, and to the code which makes it work. In this session, Matt Gemmell discusses how to create your own controls while maintaining consistency and usability, for both the user and other developers who may use your code.

You and the users of your software are very different indeed. Your situations, motivations, and expectations are radically different, often leading to conflict. However, you do have one thing very much in common with your users: you are annoyed by things that suck. Starting from this simple seed, you will learn to see things from another person's eyes.

Software usability isn't just about making your app intuitive and discoverable and guessable, it's also about what you do when the user makes a mistake. Users make mistakes all the time, and it's almost always because the app allows them to. There are certain attitudes and conventions in software GUI and functionality design which inevitably lead to user errors - and they can be avoided. in this session, we'll discuss why users make mistakes, and how you can design your app to make many mistakes impossible.
WARNING: THIS PRESENTATION CONTAINS ADULT LANGUAGE,
IF THIS OFFENDS PLEASE DO NOT PURCHASE

In a global software economy, it’s foolish for Europeans to compete on price. Someone who lives in a smaller economy than yours can always undercut you. Instead, you must compete on merit. You need to make your application better than any free knockoff. You have to sweat the details and add value to your application. You need to pimp your app.
We start at Pimp 101, and learn about the second 80%, the work that begins when you think you’re done. We’ll talk about the idea of a hook, the thing that makes people want to talk about your app with their friends — and other facets of polishing an application, such as performance, stability, and beauty. We’ll talk about the importance of professional artists.
Then we’ll delve into human interaction, and the subtle art of empathy. We’ll talk about your feature list, and how discipline in application design can save you time and make you money. We’ll talk about rule #1: don’t annoy the user, and some common mistakes. Finally, we’ll apply all we’ve learned by pimping an existing app.

The World According To Gemmell Workshop was a day-long session hosted by Matt Gemmell for around 30 attending developers with some guest speakers from NSConference, discussing user interface, user experience and interaction design issues for Mac, iPhone and iPad software.

Section 1: iPad Application Design
The full original presentation which was distilled into Matt's article "iPad Application Design". The design language, philosophy and psychology behind iPad applications and touchscreen software user interfaces in general.

Section 2: User Interface Design Questions
Attendee questions that were submitted before the workshop for discussion.

This pack contains almost 5 hours of video covering all 10 sessions from the NSConference MINI held in the UK In June 2010.

• Twiddle your bits
• Beyond Build and Analyze
• Reinventing the wheel, and why it's worth it.
• Building better software quicker
• Making Terrific Screencasts
• Welcome to Cocos2d for iPhone
• Next Train Home - Tips and tricks for CoreLocation in iPhone OS
• Lessons Learned from 18 Months of Cappuccino
• Beyond 1.0 - Lessons Learnt from LittleSnapper
• eXtreme Programming for the Solo Developer (or Small Team)

This video pack contains all 5 sessions from the NSConference 2010 iPhone day, Save almost 20% by buying them together in this pack

You and the users of your software are very different indeed. Your situations, motivations, and expectations are radically different, often leading to conflict. However, you do have one thing very much in common with your users: you are annoyed by things that suck. Starting from this simple seed, you will learn to see things from another person's eyes.

This session is intended for experienced iPhone programmers who are unfamiliar with OpenGL ES and the mathematics and concepts of three dimensional graphics. It starts from the beginning, and talks about the architecture of OpenGL ES works and how it's implemented in the two GPUs currently available in iPhones and then goes on to review the basic mathematics of three dimensional graphics. Jeff looks at creating 3D geometry in third party applications and looks at the optimal ways to submit geometry to OpenGL ES, while discussing the differences between OpenGL ES 1.1, which is available on all iPhones and OpenGL ES 2.0, which is only available on the iPhone 3Gs and the 32mb and 64mb third generation iPod touch. Though starting from the beginning, this session crams a lot of information and sample code into an hour, giving you everything you need to hit the ground running with 3D programming on the iPhone.

In this session, Marcus discusses his solution to local network data synchronization using Core Data and his new open source project ZSync. The session walks through how the synchronization of data works between a Mac OS X desktop/laptop and a Cocoa Touch device. This synchronization works whether the associated desktop application is running or not and has the added bonus of being able to synchronize with MobileMe if the end user happens to have an account.

This talk covers the technical lessons learned in developing Sumo Master for iPhone. Sumo Master is built entirely with the Core Animation framework, and various coding tips and tricks are included that are useful not only for games, but to add polish to any iPhone app. Aspects of the software process, such as brainstorming, design, iteration, working with a designer, and so forth, are also touched upon.

Learn the ins and outs of adding network play to your applications. Jeff looks at using Apple's GameKit framework to add networking over Bluetooth and also looks at doing stream communications to support online and LAN play and techniques to support these two different approaches in the same application so you can offer users of your application both.