Top-notch video tutorials for Swift developers

In this episode we take a look at the basics of NSOperation, NSOperationQueue, starting from block operations and moving to custom NSOperation subclasses. We'll also see why it's important to make your operations thread safe.

In this episode we cover local notifications in iOS 8. We cover the difference between count-down style notifications and time-zone based notifications. We also discuss how to add actions to the notifications and handle those in your application.

In this episode we take the Magic Move transition from last week's episode and make interactive, so that you can feel the transition along with your swipe.

In this episode we'll create a custom view controller animation that mimics the Magic Move behavior from keynote, taking one object and animating into its place on the next slide (or view controller).

In this episode we examine how we can leverage the NSDateComponents class to convert a set of individual date parts like month, day, year into an actual NSDate

In this episode we talk about a Swift testing framework called Quick. Quick offers a familiar BDD style syntax, some really friendly matchers, as well as support for testing asynchronous parts of our code. We'll use a Ninja class as our example, testing initialization, equality, and an asynchronous method.

In this episode I cover configuring your Xcode project to conditionally include or exclude a feature, in case there is a feature you can't have in the App Store, or perhaps something that isn't quite ready yet.

In this episode we take a look at CoreAnimation's easiest form of animation with CABasicAnimation. Using this class we can animate properties of a layer, such as frame, background color, paths for CAShapeLayer, and more. We also cover timing functions and how to make a transition between shapes a bit easier for the system to interpolate between.

In this first episode covering OS X development, I cover how to manage windows, window controllers and xibs with Objective-C and Swift. There are lots of options (and opinions) here, so we follow some advice from Mike Ash's blog post on the topic.

Have you ever wondered how bezier paths work? What are the control points, and how exactly do they affect the line? In this episode we'll build our own visualization of how a bézier path is constructed to help understand it better.

We continue our example of CoreImage CIFilters, this time showing how function composition can facilitate working with filters a bit more flexible and chainable. Starting with the imperative, method-based approach, then gradually building towards a pattern that allows us to easily build filters functionally, swapping out the order, and changing around input parameters.

In this episode we take a look at Core Image, Apple's image framework for image effects on iOS and Mac OS X.

In this episode we create an application and share extension that lets us post to the Imgur API. We use a Framework to share API code between application and extension, and we leverage App Groups so that background sessions transfer across both as well.

In this episode we cover a horribly named, yet fairly powerful concept called flat map. We'll use this technique to solve the problem we discovered last time dealing with Result<T> and having to use a switch statement everywhere.

In this episode I talk about the pattern of communicating errors in Cocoa and how it can be improved by leveraging features in Swift. By introducing a Result type that is generic and applies to any type, it appears useful, however we run into some cumbersome use cases that will require further discussion.

In this episode we use UIKit Dynamics to create something fun: Rope! By attaching many segments together with attachments, we can simulate the physics of a rope. We also discover the best way to move an object on the screen in conjunction with existing attachments.

In this episode we take another look at UIKit Dynamics, this time focusing on UIAttachmentBehavior, which allows you to create springs between elements to fix them in place or make them swing.

One of iOS 8's more powerful new features is App Extensions. With extensions we have a whole new range of possibilities. In this episode we'll focus on the Today Extension, which is a way to add a widget to Notification Center for quick access.

Finally iOS 8 and Xcode 6 are available and out of NDA and we can cover them on NSScreencast. There are tons of new features to cover, so today I'm just going to pick one: IBDesignable. With IBDesignable you can live preview your custom views so you don't have to stare at empty gray boxes in Interface Builder anymore. Interface Builder just got way more useful!

In this episode we wrap up our JSON parsing exploration in Swift by extending the decoding to work with arrays. Doing so cleans up the extraction code significantly.

In this episode we attempt to write a more idiomatic JSON Parsing framework leveraging Swift. To accomplish this we'll lean heavily on Swift's powerful enum features and apply a couple of custom operators to clean up syntax and reduce redundant code.

Parsing JSON (which provides no contracts or type guarantees) can be difficult and tedious in Swift. Many of the problems you are forced to deal with were easier to ignore in Objective-C, but that doesn't mean they weren't present. In this episode we'll take a look at a very manual approach to mapping from a JSON response to a Swift type.

In this episode we take a look at the NSURLSession API from a Swift perspective. We create a class to fetch JSON from an API, and along the way see lazy properties and type aliases.

One of Swift's powerful features is the ability to define custom operators. In this episode we take a look at two examples of custom operators, one for easy regular expression matching, and another for computing the dot product between two vectors.