Latest Posts

Type Methods

Fetching Records With Core Data

Developers often complain that Core Data has an arcane syntax and complicated API. "It's tedious to work with Core Data." seems to be the general consensus. It's true that Core Data used to be difficult to use and the framework's syntax wasn't as elegant as it could be. That's something of the past, though. The more Core Data matures, the more I enjoy and appreciate the framework. First impressions are difficult to change and it's therefore unsurprising that developers often fall back to third party libraries. Using a third party library to interact with a first party framework isn't something I recommend. Many of us find fetching records from a persistent store to be clunky and tedious. Is that true? In this series, I'd like to show you how easy and elegant fetching records from a persistent store can be.

in Core Data

Working With Optionals

Swift Fundamentals

Optionals are an integral aspect of Swift development. They highlight a core concept of the Swift language. Safety. At first glance, optionals look inconvenient and a necessary evil of Swift development. That's true if safety isn't high on your list of priorities. Unless you embrace optionals and what they represent, working with Swift will be a struggle and it will end in frustration.

in Swift

Optionals

Swift Fundamentals

One of Swift's core features is safety and optionals tie neatly into that mindset. Developers new to Swift tend to struggle with optionals. Optionals are often seen as a hindrance instead of a powerful concept of the Swift language. A common question developers have when they learn about optionals is "Why?" In this episode of Swift Fundamentals, we take a close look at optionals. Let's start with the obvious question "What is an optional?"

in Swift

Exploring the Sandbox With OpenSim

It can sometimes be useful or even necessary to browse the sandbox of an application that's running in a simulator. Finding the application's sandbox isn't trivial, though. Xcode nor the simulator offer this type of functionality. Finding the application's sandbox is cumbersome and the location of the sandbox usually changes with every major release of Apple's developer tools. It's possible to find the sandbox if you know where to look.

in Tools

Meet the URLSession Family

Networking In Swift

AFNetworking has always been one of my favorite libraries and Alamofire is just as easy to like. Since the introduction of URLSession in iOS 7 and macOS Mavericks, I've been more reluctant to include either libraries in my projects. Why is that?

in Networking

Dependency Injection In Code

Dependency Injection With View Controllers

In the early days of the iPhone, many developers shied away from Interface Builder for creating user interfaces. Even though Xcode had been around for years and years, if you wanted your application to be performant, you created your user interfaces in code. The first iPhone wasn't that powerful and you had to squeeze every ounce of performance from it by optimizing how its resources were used.

in Patterns

Dependency Injection With XIB Files

Dependency Injection With View Controllers

Many developers are a bit wary of storyboards and I can understand why that is. It's fine if you're not ready to embrace storyboards in your projects. Let me show you how to adopt dependency injection if you're using XIB files.

in Patterns

Dictionaries

Swift Fundamentals

Another important collection type defined by the Swift standard library is the dictionary type. Dictionaries are better known as maps, hashes, or associative arrays in other programming languages. The idea is similar, though.

in Swift

Arrays and Sets

Swift Fundamentals

In the previous episode, we explored some of the common types defined by the Swift standard library. Today, we continue that exploration by taking a close look at collection types. The Swift standard library defines three collection types, arrays, sets, and dictionaries. This episode zooms in on arrays and sets.

in Swift

Dependency Injection With Storyboards

Dependency Injection With View Controllers

Dependency injection is a pattern that's often overlooked, ignored, or discarded by developers in favor of other patterns, such as the singleton pattern. I've talked and written about dependency injection and Swift quite a bit on Cocoacasts.

in Patterns

Exploring Xcode's Debugging Tools

Debugging Applications With Xcode

Xcode offers developers a mature development environment with a powerful debugger. Under the hood, Xcode's debugging tools take advantage of LLDB, the debugger of the LLVM project. It isn't necessary to have a deep understanding of LLDB or LLVM to make use of Xcode's debugging tools, but it certainly doesn't hurt to become familiar with LLDB and LLVM.

in Xcode

MVVM Is More Than a Pattern

A few months ago, I had an interesting conversation with a reader about the Model-View-ViewModel pattern. Let's call him John. The questions John asked me show that developers new to MVVM often miss or overlook the more profound benefits the pattern brings to the table. In this episode, I'd like to share with you the most important insights of my conversation with John.

in Model-View-ViewModel