Swift Bond is a binding framework that removes the mundane task of wiring up your UI. In this tutorial, which was originally published on Ray Wenderlich's website, I introduce the concepts of Bond and demonstrate how to use it to rapidly build an iOS app.
This is my final article on ReactiveCocoa 3.0 (RAC3), where I demonstrate some more complex RAC3 usages within the context of an application built using the Model-View-ViewModel (MVVM) pattern.
My previous blog post took a first look at ReactiveCocoa 3.0 (RC3), where I described the new Signal interface, and the pipe forward operator. In this blog post I continue my exploration of the RC3 APIs and turn my attention to signal producers. I also discuss a few points around the overall clarity of the new ReactiveCocoa APIs.
This blog post takes a look at the new ReactiveCocoa 3.0 swift interface, which introduces generics, a pipe-forward operator and an interesting use of curried functions.
For some reason, everybody and their dog has written about how to parse JSON in Swift. Not wishing to be left out, I thought I'd throw my hat into the ring.
This blog post explores the novel approach taken by the React.js team, where the UI is expressed as a function of the current application state, and re-implements it with Swift.
Swift has access to all of the Objective-C APIs, which means that anything you could do with Objective-C you can now do with Swift. However, there are times when it is worth exploring a better, pure-Swift, alternative. This post explores the pros and cons of KVO versus a couple of Swift alternatives.
Swift does not have a built in eventing mechanism. This post explores a few different ways events can be implemented in Swift and how to avoid problems of retain cycles and closure reference equality.
Swift doesn’t support throwing exceptions, nor does it support catching them. This wouldn’t be a problem if you could develop iOS apps in pure Swift, but unfortunately at the moment you cannot. When developing an app most of the APIs you’ll be working with are Objective-C APIs that have been...
This blog post looks at a few techniques that can be used to remove the deeply nested if-let statements that are a common sight in Swift code.
Swift's strict initialisation process results in a number of practical issues, leaving developers scratching their heads. This post explores a few solutions including two-phase initialisation, the use of optionals and lazy properties.
This post show how the simple task of computing a Mandelbrot set can be split up across multiple threads (and processors) using functional techniques.
Swift, as I am sure you are aware, is quite a strict, safe and strongly-typed language. However, because the language needs to maintain Objective-C compatibility it has some rather curious features, and the behaviour of `AnyObject` is one of them!
This post is a continuation of my previous which looked at implementing Conway’s Game of Life using functional techniques. Here I look at how memoization can be used to cache the return value of a function in order to improve performance.
Apple released the first public beta of the Swift programming language just over three months ago. Within days of the release myself and Matt Galloway started working on our book Swift by Tutorials, which as of yesterday is finally finished and shipping!
This blog post shows an implementation of Conway’s Game of Life using functional techniques in Swift. This results in code which is a clear and concise representation of the game’s logic. I also take a closer look at ranges, intervals, the pattern match operator, ~= and how local functions help...
It was just two months ago that Apple took us by surprise in releasing the Swift programming language. This blog post reflects on the first few months of Swift adoption.
This blog post looks out how Swift makes the combination of ReactiveCocoa and MVVM even better ...
In this blog post I want to take a quick look at the Swift Sequence protocol, which forms the basis for the for-in loop, and see how this allows you to write code that performs sequence operations that are only evaluated on-demand.